THE COMP101 OO DEVELOPMENT METHODOLOGY

(To be followed when undertaking practical assugments)


CONTENTS

1. Introduction
2. Requirements
3. Analysis
3.1. Class Diagrams
3.2. Field, constructor and method
summary tables
 
4. Design
4.1. Nassi-Shneiderman Charts
4.2. Activity Diagrams
5. Implementationn
6. Testing
7. Documentation



1. INTRODUCTION

The OO methodology described here is a fairly standard approach to creating small to medium sized OO applications. The prescribed techniques have been borrowed from an number of sorces and include:

  1. Class diagrams founded on a simplified notation to that described by UML
  2. Field, constructor and method summary tables identical to those used to describe the Java API by Sun on their Java WWW pages.
  3. UML Activity Diagrams to describe the flow of control through a system.
  4. Nassi-shneiderman charts to describe the procedural aspects of individual methods.

2. REQUIREMENTS

These will be presented to students in the form of a "requirements statement".


3. ANALYSIS

Students should analyse thne requirements to identify the classes that will be required to produce a solution. As a guide line students should consider developing at least two classes: (i) an "operational" class and (ii) an application class. A particular problem may require several operational classes, but can only have one application class.

Once the classes have been identified students should identify the fields, constructors and methods required by each class.

The result of the analysis should be presented in the form of a class diagrm and a set of summary tables.


3.1. Details to include in class diagrams

Class diagrams can be produced at many levels of granularity. With respect to COMP101 the class diagram should include all classes that an application uses including those taken from the Java API with the exception of the System class. The latter is used so regularly that its presence can be assumed (it will also be compiled in automayically).

The diagrams should include all fields, methods and constructors that will be designed and implemented by the student (with the exception of default constructors). The diagram should also include any fields, constructors (again with the exception of default constructors) and methods taken from the Java API that might be used in the solution. There is no need for students to list all the members in every Java API class used --- only those that are actually used in the solution.

Occaisionally it is necessary the create an anonymous instance as part of the input to some method or constructor. For example:

public static BufferedReader keyboardInput = 
               new BufferedReader(new InputStreamReader(System.in));

which includes a reference to an anonymous isntance of the InputStreamReader class. It is not necessary to include such classes in class diagrams.


3.1. Field, Constructor and Method Summary Tables

Class summaries should be presented in a tabular format exactly the same as those found on Sun's Java WWW pages ( http://java.sun.com/j2se/1.4/docs/api/).

For each programmer defined class (i.e. not one taken from the Java API) there should be a set of tables describing the fields, constructors (except default constructors) and methods associated with that class. Clearly if a particular class has no fields then there is no need to include a field summary table.




4. DESIGN

The detailed design should be expressed in terms of Nassi-Shneiderman charts and, where appropriate, activity diagrams.


4.1. Nassi-Shneiderman Charts

Students should include Nassi-Shneiderman charts for each of their methods.


4.2. Activity Diagrams

In the context of COMP101 Activity Diagrams are to be included to indicate the "paths" through a systems. This requirement should therefore govern the level of detail to be included in such diagrams. In many cases a very "high level" view will normally suffice.

Note: For the first few practicals there will be no requirement to include activity diagrams.




5. IMPLEMENTATION

Students should follow a "top-down" style of implementation. Starting with the "bones" of a class (i.e. empty methods) and then adding the detail in a step-wise manner. It is recommended that students compile their code repeatedly through out the implementation rather than once the implementation is complete.




6. TESTING

(Other than for the first practical) students should design a set of test cases to exercise all aspects of their implementations. These test cases should be presented in tabular form.

The students should then run these test cases to check the actual result against the expected result.




7. DOCUMENTATION

It is not necessary for students to use Word Processing or Graphics packages to produce their class diagrams, summary tables, Nassi Shneiderman charts, Activity Diagrams and test case tables. These can all be done "free hand". However the implementation and results of testing mist be presented in the form of "hard copy".




Created and maintained by Frans Coenen. Last updated 10 October 2002