COMP553 - OBJECT ORIENTED PROGRAMMING IN JAVA

1. Overview
2. Lectures
3. Practicals and Course Work
4. The Java Development Kit 2.0 (JDK)

5. Java Web Sites
6. List of example problems
7. List of example code fragments
8. Course book
9. Additional material

1. OVERVIEW

Description: COMP553 is the first semester , programming module for the MSc programmes offered by the Department of Computer Science at the University of Liverpool. The aims are two fold:

To teach the students the elements of the Java programming language
To give the students a general understanding of object-oriented programming, with respect to the analysis, design and implementation stages of program development

Students will learn how to analyse problems and devise algorithms to produce solutions to problems using the Java Object Oriented high level computer programming language. A sophisticated set of web pages have been produced to support the course (http://www.csc.liv.ac.uk/~frans/COMP553/comp553.html).

Teaching Method: Two lectures are given each week for the 10-week duration of the course. In addition, for one hour each week, students will work in a tutorial/practical setting under staff guidance. To this end students will be allocated to a tutorial groups.

Each group comprises some 20 students and is supervised by a "COMP553" tutor. The first "port of call" for any student who has a COMP553 related problem should be their COMP553 tutor.

Assessment: Assignments are carried out individually. Each assignment comprises a "stand-alone" problem which is to be addressed, using the object oriented approach taught on the course, to produce a computer generated solution. A grade will be returned for each assignment. The course is 100% continuously assessed.

2. LECTURES

The course comprises 20 lectures (spanning over 10 weeks commencing in week 3 of the first semester) taught by Dr Frans Coenen (Room 1.06, first floor, Chadwick Building) as follows:

Week	Lecture topics	Practicals
3	(1) the Java programming language, (2) the principles of Object Oriented Programming (OOP). (3) Data and Categories of data and introduction to data types,	None
4	(4) Input and "wrapper" classes, (5) Arithmetic and the `Math` class (plus note on method calls), (6) type conversion.	Practical 1: (assessed) Swimming Pool.
5	(7) The character type, (8) expressions and statements, and (9) Inheritance and class hierarchies.	Practical 1: (assessed) Swimming Pool.
6	(10) Selection (if-else), and (11) selection (switch).	Practical 2: (assessed) Triangle recognition.
7	(12) For loop (see also more on for loop), and (13) while loops, the break statement, and Do-while loops,	Practical 2: (assessed) Triangle recognition.
8	(14) compound data types and arrays (see also Array processing), and (15) unconstrained arrays.	Practical 3: (assessed) Bubble sort.
9	(16) Strings, and (17) arrays of Instances.	Practical 3: (assessed) Bubble sort.
10	(18) Graphical User Interfaces (GUIs), and (19) parameter passing mechanisms.	Practical 4: (assessed) GUI for Bubble sort.
11	(20) Applets and Graphics.
12	None.

Lectures are timetabled as shown in the table to the right. At the beginning of the module all three of these slots will be used, however as the course progressesw amd the practical load increases the number of lectures per week will be decreased.

DAY	TIME	ROOM
Wednesday	10:00	A
Wednesday	14:00	A
Friday	14:00	A

and tutorials:

DAY	TIME	ROOM
Wednesday	15:00	Lab 2 and Lab 6
Wednesday	16:00	Lab 2 and Lab 6

Note 1 COMP553 students are only requred to attend one tutorial (students will be allocated to tutorial groups in the first two weeks of the first semester). Note 2 All lectures take place in the Science Faculty Lecture Block, and all tutorials in the Computer Science Labs., ground floor, Chadwick Tower.

3. PRACTICALS AND COURSE WORK

Lectures are supported by 8 x one hour tutorial sessions (one per week commencing in week 4 and ending in week 11). These are official times set aside for students to work on their assignments. There will be 4 assessed assignments. Practical sessions will take place in the Chadwick Building (ground or first floor labs). Practical sessions will be supervised by various members of the computer science staff.

Each student will be assigned a tutor and will be expected to attend one 1 hour tutorial per week and complete assessments in their own time. Details concerning tutor groups and the tutorials timetable will be made available at the end of week1. Practical sessions commence at the start of week4 (15th October). Each student is expected to spend at least 9 hours per week on COMP553 related work - 3 hours formal lectures, 1 hour scheduled tutorial, 5 hours private study. To facilitate the latter computer labs are available outside tutorial times between 9:00 and 18:00 during term time. Do not enter a lab if it is being used for a tutorial (timetable outside every lab).

3.1. Presentation of course work

Completed practicals should be submitted to, and marked by, practical tutors.

	All course work is to be presented as a paper report (not email).
	Computer programs should be included in the form of a "print-out" (not hand written).
	Supporting documentation (design etc.) may be hand written or typed.
	Results of test data should be included in the form of a "screen dump".

3.2. Mark scheme

Course work will be marked and awarded a precentage. A students final mark will be calculated by totalling the percentages awarded for all 4 practicals and then dividing by 4 to arrive at an overall percentage.

3.3. Late submission policy

Students who fail to hand in practicals on time will, under normal circumstances, be awarded a mark of 0 for that practical. If there is some extenuating circumstance whereby a student cannot hand in a practical on time than that student should approach his/her tutor. It is then up to the discretion of the tutor whether to mark the course work or not, and whether some penalty should be applied. (see also the departmental policy statement on late submission of Assessed Assignments.)

It is always better to hand in something rather than nothing at all. If you hand in nothing you are guaranteed to get 0. This is not necessarily the case if you hand in something!

4. THE JAVA DEVELOPMENT KIT 2.0 (JDK)

We will be using the suite of programs known as the Java Development Kit (JDK) which is available free-of-charge (but subject to a licensing agreement) from Sun (the developers of Java) through their Web pages http://java.sun.com. The JDK Software comprises the essential software required for writing and running Java programs. There is also a directory on documentation for all Java libraries (know as Application Programming Interfaces --- API) and a directory called the "Java tutorial". The JDK, the API documentation and the tutorial occupy about 10 Mbyte each on disk (i.e 30 Mbyte all together).

5. JAVA WEB SITES

Java is a WWW language thus, not surprisingly, there are many Java web sites that can be accessed and which provide all sorts of useful Java information. Some notable sites include:

	`http://www.javasoft.com`, Sun's Java site, the source for the JDK and the primary reference ("standard") for Java.
	`http://www.javasoft.com`, a good site for Java sources, information and interesting applets.
	`http://www.javaworld.com`, a monthly on-line magazine devoted to Java.
	`http://www.cs.up.ac.za/javagently`, the web site for Judy Bishop's book, "Java Gently" (Addison-Wesley 1998).
	`http://www.mhhe.com/eng cs/compsci/kamin` The home page for Samual kamin, Dennis Mickunas and Edward Reingold's book "An Introduction to Computer Science Using Java" (McGraw-Hill, 1998).
	`http://www.csc.liv.ac.uk/~frans/COMP101/comp101.html`, the Liverpool University Java web site.

6. LIST OF EXAMPLE PROBLEMS (QUICK REFERENCE)

Here follows a list all the complete problems given as examples in the COMP553 www pages referenced above:

Week	Title	Description
3	Giant Java	Strings, classes and output methods.
3	Swimming pool	Floats, constants and varaibales, and input methods.
4	Circle	Doubles and use `Math` class constants.
4	Pythagoras	Use of `Math` class methods (`pow` and `sqrt`).
4	2D Geographic Distance	Type conversion (casts), passing instances as arguments, reusing user defined classes.
5	Lower to Upper Case Conversion	The character type.
5	Vertical Motion	Operators.
5	Cylinder calculation	Inheritance and class hierarchies.
6	Power 4	Selection, simple `if` statement.
6	Linear Equation	Selection, `if-else` statement.
6	Calculator	Use of `switch` statement, and writing Boolean functions.
6	Temperature Conversion	more examples of the use of switch statements.
7	ASCII Code Output	For loops.
7	Arithmetic Progression	For loops.
7	Factorial	For loop with loop parameter decrementation.
7	Extended Factorial Application	More for loops.
7	Euler's Number Approximation	While loop.
8	Fibonacci sequence	Do-while loop example.
8	Multiplication table	Nested for loops and alternative implementation without nesting.
9	Random number generator	While loops and do-while loops.
9	Decimal to binary conversion	Recursion.
9	Metres to Yards, Feet and Inches conversion	Simple constrained array.
10	Set I/O	Array input and output.
10	Set intersection	Working with unconstrained arrays.
11	Password verification	String handling (character arrays).

6.1. Additional example problems

Additional example problems not included in the main body of the WWW material referenced above, but which have significant relavance to the material contained there in.

Week	Title	Description
4	Sine, Cosine and Tangent	Trigonometric ratios.

7. LIST OF EXAMPLE CODE FRAGMENTS

Here follows a list of example code fragments (as opposed to complete example problems and their solution) that can be found in the COMP553 WWW reference material.

Week	Title	Description
2	Hello World 1	First ever Java program, simple output.
3	Data initialisation Class	Examples of declaring and initialising data items.
3	Data initialisation Application Class	Example application class with data initialisation.
3	Hello World 2	Simple input and output.
3	Integer input 1	Numeric input (and output).
3	Integer input 2	More sophisticated numeric input.
4	Example class	Illustration of method calls.
4	Test harness 1	"Test harness" program 1 (Pythagoras).
4	Test harness 2	"Test harness" program 2 (2-D geog. distance).
4	Rounding	Distinction between casting and rounding.
5	Character input	Using read to input single characters.
5	Operator evaluation	Evaluation of operators, precedence rules.
5	Super/Sub class	Inheritance and class hierarchies.
6	switch example 1	Use of the switch (case) statement.
6	switch example 2	Use of the switch (case) statement (date validation).
6	Menu interface 1	Use of switch statement to create a style menu interface.
7	"Smiley" faces 1	For loop example.
7	Sequence of numbers	Use of loop parameter in for loops (output).
7	sequence of even numbers	Use of loop parameter in for loops (calculation).
7	Backward sequence of numbers	Use of for loop with loop parameter decrementation.
7	For loop examples	Omitting parameters in for loop construct.
7	Euler's numbers 2	Solution to Euler's Number problem implemented using a for loop.
7	"Smiley" faces 2	"Smiley" faces example implemented using a "while" loop.
7	Menu interface 2	Second version of Menu interface (with switch and while statements).
8	Integer input loop 1	Variable count "do-while" loop example.
8	Integer input loop 2	Same as "Integer input loop 1" but implemented using a variable count "while" loop.
8	Integer input loop 3	Same as "Integer input loop 1" but implemented using a variable count "for" loop.
8	Integer input loop 4	Continuous "do-while" loop with break statement.
8	"Smiley" faces 3	"Smiley" faces example implemented using a "do-while" loop.
8	Random number generator 2	Alternative solution to Random number generator example problem using the `Random` API class.
9	Dicimal to hexadecimal conversion	Use of recursion.
9	Fibonacci	Alternative (recursive) implementation of Fibonacci problem.
10	Array length example	use of `length` variable.
10	Cube mapping	Example of an array mapping operation.
10	Odd number filter	Example of an array filter operation.
10	Average	Example of an array folding operation.
10	Zip	Example of an array zipping operation.
10	Set I/O	Declaration of unconstrained arrays.
11	Dec2Hex 2	Declaration of arrays of instances.
11	String example 1	Declaration of instances of the class `String`.
11	String example 2	"Short cut" declaration of instances of the class `String`.
11	String operations	Use of methods in the `String` class.
11	Call by value example	Example of "call by value" parameter passing.
11	Call by reference example	Example of "call by reference" parameter passing.
11	Hello World 3	Command line arguments.
11	Add up 1	Numeric command line arguments
11	Add up 2	Numeric command line arguments
11	Scope rule example	Scope rule illustration.

7.1. Additional example code fragments

Additional example code fragments not included in the main body of the COMP553 notes, but which have some relavance to the material contained there in.