Chapter 9Object-Oriented Software Development

Software Development Process Analyze Relationships Among Objects Class Development Class Design Guidelines Wrapper Classes Generic Sort Class Generic Matrix Class Generic Linked List Class

Software Development

Process

Requirement Specification

System Analysis

System Design

Implementation

Testing

Deployment

Maintenance

Relationships among Classes

Association

Aggregation

Inheritance

Association

Association represents a general

binary relationship that describes an

activity between two classes.

Student FacultyCourse*5..60Take Teach

0..3 1Teacher

Representing Association in ClassesAn association is usually represented as a data field in the class.

public class Student {

/** Data fields */

/** Constructors */

/** Methods */

}

public class Course {

private Student

classList;

private Faculty faculty;

/** Data fields */

/** Constructors */

/** Methods */

}

public class Faculty {

/** Data fields */

/** Constructors */

/** Methods */

}

or

public class Student {

private Course[]

courseList;

/** Data fields */

/** Constructors */

/** Methods */

}

public class Course {

/** Data fields */

/** Constructors */

/** Methods */

}

public class Faculty {

private Course[]

courseList;

/** Data fields */

/** Constructors */

/** Methods */

}

Aggregation

Aggregation is a special form of association,

which represents an ownership relationship

between two classes. Aggregation models the

relationship like has-a, part-of, owns, and

employed-by.

Magazine ConsultantPublisher1*

Owned by Employed by**

Expert

Representing Composition in Classes

A composing class is usually represented

as a data field in the composed class.

public class

Publisher {

 

/**Constructors*

/

  /**Methods*/

}

public class

Consultant {

  private

Publisher[] p;

/**Constructors*/

/**Date

fields*/

  /**Methods*/

}

public class

Magzine {

private

Publisher p;

 

/**Constructors

*/

/**Date

fields*/

  /**Methods*/

}

Inheritance

Inheritance models the is-a relationship

between two classes.

Person

Faculty

Student

Inheritancepublic class Student extends Person {

/**Constructors*/

  /**Methods*/

}

public class Faculty extends Person {

/**Constructors*/

/**Methods*/

}

Weak Inheritance RelationshipA weak is-a relationship can be

represented using interfaces. For

example, the weak is-a

relationship “students are

comparable based on their grades”

can be represented by

implementing the Comparable

interface, as follows:

Weak Inheritance Relationship, cont.public class Student extends Person

implements Comparable {

/** Data fields */

/** Constructors */

/** Methods */

/** Implement the compareTo method */

public int compareTo(Object object) {

// ...

}

}

Class Development

1. Identify classes for the system.

2. Describe attributes and methods in each

class.

3. Establish relationships among classes.

4. Create classes.

Example 9.1 Borrowing Mortgages

NameName BorrowerBorrowerPersonPersonMortgageMortgage

Name

1 1 Has Live 1 1

Mortgage Borrow

Borrower -mortgage: Mortgage +Borrower() +Borrower(name: Name, address: Address) +getMortgage(): Mortgage +setMortgage(mortgage: Mortgage): void +toString(): String

Address -street: String -city: String -state: String -zip: String +Address() +Address(street: String, city: String, state: String, zip: String) getStreet(): String +getCity(): String +getState(): String +getZip(): String +setStreet(street: String): void +setCity(city: String): void +setState(state: String): void +setZip(zip: String): void +getFullAddress(): String

Defined in Example 6.7

Defined in Example 8.6

Person -name: Name -address: Address +Person() +Person(name: Name, address: Address) +getName(): Name +setName(name: Name): void +getAddress(): Address +setAddress(address: Address): void +toString(): String

AddressAddress

Example 9.1 Borrowing Mortgages, cont.

The following is a test program that uses the classes Name, Person, Address, Borrower, and Mortgage.

BorrowMortgageBorrowMortgage RunRun

Example 9.2 The Rational Class

RationalRational RunRunTestRationalClassTestRationalClass

1

1 Add, Subtract, Multiply, Divide

Rational -numerator: long -denominator: long +Rational() +Rational(numerator: long, Denomination: long) +getNumerator(): long +getDenominator(): long +add(secondRational: Rational): Rational +multiply(Rational secondRational): Rational +subtract(Rational secondRational): Rational +divide(Rational secondRational): Rational +toString(): String -gcd(n: long, d: long): long

java.lang.Number +byteValue(): byte +shortValue(): short +intValue(): int +longVlaue(): long +floatValue(): float +doubleValue():double

java.lang.Comparable +int compareTo(Object)

Class Design Guidelines

Designing a Single Class.

Using Modifiers public, protected, private and static

Using Inheritance or Composition

Using Interfaces or Abstract Classes

Designing a Single Class

A class should describe a single entity or a set of similar operations. A single entity with too many responsibilities can be broken into several classes to separate responsibilities. The String class, StringBuffer class, and StringTokenizer class all deal with strings, for example, but have different responsibilities.

Designing a Single Class, cont.

Classes are usually designed for use by many different customers. To make a class useful in a wide range of applications, the class should provide a variety of ways for customization through properties and methods.

Designing a Single Class, cont. Classes are designed for reuse. Users can incorporate classes in many different combinations, orders, and environments. Therefore, you should design a class that imposes no restrictions on what or when the user can do with it, design the properties to ensure that the user can set properties in any order, with any combination of values, and design methods to function independently of their order of occurrence.

Designing a Single Class, cont.

Provide a public default constructor and override the equals method and the toString method defined in the Object class whenever possible.

Designing a Single Class, cont.

Follow standard Java programming style and naming conventions. Choose informative names for classes, data fields, and methods. Always place the data declaration before the constructor, and place constructors before methods. Always provide a constructor and initialize variables to avoid programming errors.

Using Modifiers public, protected, private and static

Each class can present two contracts – one for the users of the class and one for the extenders of the class. Make the fields private and accessor methods public if they are intended for the users of the class. Make the fields or method protected if they are intended for extenders of the class. The contract for the extenders encompasses the contract for the users. The extended class may increase the visibility of an instance method from protected to public, or change its implementation, but you should never change the implementation in a way that violates that contract.

Using Modifiers public, protected, private and static, cont.

A class should use the private modifier to hide its data from direct access by clients. You can use get methods and set methods to provide users with access to the private data, but only to private data you want the user to see or to modify. A class should also hide methods not intended for client use. The gcd method in the Rational class in Example 9.2, “The Rational Class,” is private, for example, because it is only for internal use within the class.

Using Modifiers public, protected, private and static, cont.

A property that is shared by all the instances of the class should be declared as a static property.

Using Inheritance or Composition

In general, the difference between inheritance and composition is the difference between the is-a relationship and the has-a relationship. For example, an apple is fruit; thus, you would use inheritance to model the relationship between the classes Apple and Fruit. A person has a name; thus, you would use composition to model the relationship between the classes Person and Name.

Using Inheritance or Composition, cont.

Sometimes, the choice between inheritance and composition is not obvious. For example, you have used inheritance to model the relationship between the classes Circle and Cylinder. One could argue that a cylinder consists of circles; thus, you might use composition to define the Cylinder class as follows:

Using Inheritance or Composition, cont.

public class Cylinder { private Circle circle;  /** Constructors */  /** Methods */}

Using Inheritance or Composition, cont.

Both designs are fine. Which one is preferred? If polymorphism is desirable, you need to use the inheritance design. If you don’t care about polymorphism, the composition design gives more flexibility because the classes are less dependent using composition than using inheritance.

Using Interfaces or Abstract Classes

Both interfaces and abstract classes can be used to generalize common features. How do you decide whether to use an interface or a class? In general, a strong is-a relationship that clearly describes a parent-child relationship should be modeled using classes.

Using Interfaces or Abstract Classes, cont.

For example, since an orange is a fruit, their relationship should be modeled using class inheritance. A weak is-a relationship, also known as an is-kind-of relationship, indicates that an object possesses a certain property. A weak is-a relationship can be modeled using interfaces. For example, all strings are comparable, so the String class implements the Comparable interface. A circle or a rectangle is a geometric object, for example, so Circle can be designed as a subclass of GeometricObject. Circles are different and comparable based on their radius, for example, so Circle can implement the Comparable interface.

Using Interfaces or Abstract Classes, cont.

Interfaces are more flexible than abstract classes, because a subclass can extend only one superclass, but implement any number of interfaces. However, interfaces cannot contain concrete methods. You can combine the virtues of interfaces and abstract classes by creating an interface with a companion abstract class that implements the interface. So you can use the interface or its companion class whichever is more convenient.

Wrapper Classes

Boolean

Character

Short

Byte

Integer Long

Float

Double

Object

-

Double -

Float -

Long -

Integer -

Short -

Byte -

Character -

Boolean -

Number -

Comparable -

The Integer Classand The Double Class

Constructors

Class Constants MAX_VALUE, MIN_VALUE

Conversion Methods

Example 9.3 Sorting an Array of Objects

Objective: The example presents a generic method for sorting an array of objects. The objects are instances of the Comparable interface and they are compared using the compareTo method.

GenericSortGenericSort RunRun

Example 9.4Designing Generic Classes

Objective: This example gives a generic class for matrix arithmetic. This class implements matrix addition and multiplication common for all types of matrices.

GenericMatrixGenericMatrix

Example 9.4, cont.

GenericMatrix

-matrix: Object[][] #GenericMatrix(matrix: Object[][]) +getMatrix(): Object[][] +setMatrix(matrix: Object[][]): void +addMatrix(secondMatrix: Object[][]): Object[][] +multiplyMatrix(secondMatrix: Object[][]): Object[][] +printResult(m1: GenericMatrix, m2: GenericMatrix, m3: GenericMatrix, op: char): void #createGenericMatrix():GenericMatrix #add(o1: Object, o2: Object): Object #multiply(o1: Object, o2: Object): Object #zero():Object

IntegerMatrix

RationalMatrix

Example 9.4, cont.

Objective: This example gives two programs that utilize the GenericMatrix class for integer matrix arithmetic and rational matrix arithmetic.

TestIntegerMatrixTestIntegerMatrix RunRun

TestRationalMatrixTestRationalMatrix RunRunRational MatrixRational Matrix

IntegerMatrixIntegerMatrix

Linked ListArrays are useful for storing and managing a set of elements of the same type. However, since the length of an array is fixed once the array is created, you need to know the length of the array before you create it. A linked list can grow or shrink dynamically as needed.

A linked list consists of nodes, as shown in Figure 9.14. Each node contains an element and each node is linked to its next neighbor. Thus, a node can be defined as a class as follows:

Linked List Structure

public class Node { Object element; Node next;  public Node(Object o) { element = o; }}

first element

next

element next

element next

last …

node1 node2 node n

Create a Linked List with three Nodes

Node n1 = new Node(new String(“Welcome to Java!”));

Node n2 = new Node(new JButton(“OK”));

Node n3 = new Node(new Rational(1, 2));

n1.next = n2;

n2.next = n3;

Node first = n1;

Node last = n3;

Generic Linked List

… element next

element next

current

first element next

element next:null

last …

element next

New node inserted here

temp

Add a new node

Generic Linked List

Remove a new node

… element next

element next

previous

first element next

element next:null

last …

Node to be deleted

current

After the node isdeleted

Example 9.5 Using Linked List

This example creates a linked list using GenericLinkedList. It then uses the add method to add strings to the list and uses the remove method to remove strings from the list.

GenericLinkedListGenericLinkedList

RunRunTestLinkedListTestLinkedList

Generic Linked List

GenericLinkedList list = new GenericLinkedList();

list.addLast(new String(“Welcome to Java”));list.addLast(new JButton(“OK”));list.addLast(new Rational(1, 2));