A constructor has no type and is therefore a void method

There are two ways to reuse existing classes, namely, composition and inheritance. With composition (aka aggregation), you define a new class, which is composed of existing classes. With inheritance, you derive a new class based on an existing class, with modifications or extensions.

Nội dung chính Show

Composition
Composition vs. Inheritance
Abstract Classes & Interfaces
(Advanced) Object-Oriented Design Issues
Is a constructor a void method?
What is the type of constructor?
What happens if you declare a class constructor to have a void return type?
What differentiates the constructor from a method?

Composition

We shall begin with reusing classes via composition - through examples.

Composition EG. 1: The Author and Book Classes

Let's start with the Author class

A constructor has no type and is therefore a void method

A class called

3 is designed as shown in the class diagram. It contains:

Three

4 member variables:

5 (

6),

7 (

6), and

9 (

0 of either

1 or

2 - you might also use a

3 variable called

4 having value of

5 or

6).

A constructor to initialize the

7 and

9 with the given values.
(There is no default constructor, as there is no default value for

7 and

9.)

Public getters/setters:

5, and

6.
(There are no setters for

5 and

9, as these properties are not designed to be changed.)

9 method that returns "

0", e.g., "

1".

The Author Class (Author.java)

A Test Driver for the Author Class (TestAuthor.java)

A Book is written by one Author - Using an "Object" Member Variable

Let's design a

2 class. Assume that a book is written by one (and exactly one) author. The Book class (as shown in the class diagram) contains the following members:

Four

4 member variables:

5 (

6),

6 (an instance of the

3 class we have just created, assuming that each book has exactly one author),

8 (

9), and

class Goalkeeper extends SoccerPlayer {......}
class MyApplet extends java.applet.Applet {.....}
class Cylinder extends Circle {......}

0 (

class Goalkeeper extends SoccerPlayer {......}
class MyApplet extends java.applet.Applet {.....}
class Cylinder extends Circle {......}

1).

The

class Goalkeeper extends SoccerPlayer {......}
class MyApplet extends java.applet.Applet {.....}
class Cylinder extends Circle {......}

2 getters and setters:

class Goalkeeper extends SoccerPlayer {......}
class MyApplet extends java.applet.Applet {.....}
class Cylinder extends Circle {......}

class Goalkeeper extends SoccerPlayer {......}
class MyApplet extends java.applet.Applet {.....}
class Cylinder extends Circle {......}

class Goalkeeper extends SoccerPlayer {......}
class MyApplet extends java.applet.Applet {.....}
class Cylinder extends Circle {......}

class Goalkeeper extends SoccerPlayer {......}
class MyApplet extends java.applet.Applet {.....}
class Cylinder extends Circle {......}

class Goalkeeper extends SoccerPlayer {......}
class MyApplet extends java.applet.Applet {.....}
class Cylinder extends Circle {......}

9 that returns "

0". You could reuse the

3's

9 method, which returns "

3".

The Book Class (Book.java)

A Test Driver Program for the Book Class (TestBook.java)

Notes: In this example, I used "

5" for

2 class instead of "

6" to illustrate that you can have a variable

5 in both the

3 and

2 classes, but they are distinct.

Composition EG. 2: The Point and Line Classes

As an example of reusing a class via composition, suppose that we have an existing class called

0, defined as shown in the above class diagram. The source code is .

Suppose that we need a new class called

1, we can design the

1 class by re-using the

0 class via composition. We say that "A line is composed of two points", or "A line has two points". Composition exhibits a "has-a" relationship.

UML Notation: In UML notations, composition is represented as a diamond-head line pointing to its constituents.

The Line Class via Composition (Line.java)

A Test Driver for Line Class (TestLine.java)

Exercise: Try writing these more complex methods for the

1 class:

Composition EG. 3: The Point and Circle Classes

Suppose that we have an existing class called

0, defined as shown in the class diagram. The source code is .

A class called

6 is designed as shown in the class diagram.

It contains:

Two

4 member variables: a

8 (double) and a

9 (an instance of

0 class, which we created earlier).

The constructors,

class Goalkeeper extends SoccerPlayer {......}
class MyApplet extends java.applet.Applet {.....}
class Cylinder extends Circle {......}

2 getters and setters.

Methods

7, etc.

9 method that returns a string description of

9 instance in the format of "

0". You should re-use the

0's

9 to print "

3".

4 method that returns the distance from the center of

9 instance to the center of the given

6 instance (called

7).

The Circle class (Circle.java)

A Test Driver for the Circle Class (TestCircle.java)

Exercises

In OOP, we often organize classes in hierarchy to avoid duplication and reduce redundancy. The classes in the lower hierarchy inherit all the variables (static attributes) and methods (dynamic behaviors) from the higher hierarchies. A class in the lower hierarchy is called a subclass (or derived, child, extended class). A class in the upper hierarchy is called a superclass (or base, parent class). By pulling out all the common variables and methods into the superclasses, and leave the specialized variables and methods in the subclasses, redundancy can be greatly reduced or eliminated as these common variables and methods do not need to be repeated in all the subclasses. For example,

A subclass inherits all the variables and methods from its superclasses, including its immediate parent as well as all the ancestors. It is important to note that a subclass is not a "subset" of a superclass. In contrast, subclass is a "superset" of a superclass. It is because a subclass inherits all the variables and methods of the superclass; in addition, it extends the superclass by providing more variables and methods.

In Java, you define a subclass using the keyword "

8", e.g.,

class Goalkeeper extends SoccerPlayer {......}
class MyApplet extends java.applet.Applet {.....}
class Cylinder extends Circle {......}

UML Notation: The UML notation for inheritance is a solid line with a hollow arrowhead leading from the subclass to its superclass. By convention, superclass is drawn on top of its subclasses as shown.

Inheritance EG. 1: The Circle and Cylinder Classes

In this example, we derive a subclass called

9 from the superclass

6, which we have created in the previous chapter. It is important to note that we reuse the class

6. Reusability is one of the most important properties of OOP. (Why reinvent the wheels?) The class

9 inherits all the member variables (

8 and

04) and methods (

05,

06, among others) from its superclass

6. It further defines a variable called

08, two public methods -

09 and

10 and its own constructors, as shown:

Circle.java (Re-produced)

Cylinder.java

A Test Drive for the Cylinder Class (TestCylinder.java)

Keep the "

11" and "

12" in the same directory as "

13" (because we are reusing the class

6). Compile and run the program.

Method Overriding & Variable Hiding

A subclass inherits all the member variables and methods from its superclasses (the immediate parent and all its ancestors). It can use the inherited methods and variables as they are. It may also override an inherited method by providing its own version, or hide an inherited variable by defining a variable of the same name.

For example, the inherited method

06 in a

9 object computes the base area of the cylinder. Suppose that we decide to override the

06 to compute the surface area of the cylinder in the subclass

9. Below are the changes:

06 is called from a

6 object, it computes the area of the circle. If

06 is called from a

9 object, it computes the surface area of the cylinder using the overridden implementation. Note that you have to use public accessor method

05 to retrieve the

8 of the

6, because

8 is declared

4 and therefore not accessible to other classes, including the subclass

But if you override the

06 in the

9, the

10 (

32) no longer works. It is because the overridden

06 will be used in

9, which does not compute the base area. You can fix this problem by using

35 to use the superclass' version of

06. Note that

35 can only be issued from the subclass definition, but no from an instance created, e.g.

38, as it break the information hiding and encapsulation principle.

Annotation @Override (JDK 1.5)

The "

39" is known as annotation (introduced in JDK 1.5), which asks compiler to check whether there is such a method in the superclass to be overridden. This helps greatly if you misspell the name of the method to be overridden. For example, suppose that you wish to override method

9 in a subclass. If

39 is not used and

9 is misspelled as

43, it will be treated as a new method in the subclass, instead of overriding the superclass. If

39 is used, the compiler will signal an error.

39 annotation is optional, but certainly nice to have.

Annotations are not programming constructs. They have no effect on the program output. It is only used by the compiler, discarded after compilation, and not used by the runtime.

Keyword "super"

Recall that inside a class definition, you can use the keyword

9 to refer to this instance. Similarly, the keyword

47 refers to the superclass, which could be the immediate parent or its ancestor.

The keyword

47 allows the subclass to access superclass' methods and variables within the subclass' definition. For example,

49 and

50 can be used invoke the superclass’ constructor. If the subclass overrides a method inherited from its superclass, says

06, you can use

35 to invoke the superclass' version within the subclass definition. Similarly, if your subclass hides one of the superclass' variable, you can use

53 to refer to the hidden variable within the subclass definition.

More on Constructors

Recall that the subclass inherits all the variables and methods from its superclasses. Nonetheless, the subclass does not inherit the constructors of its superclasses. Each class in Java defines its own constructors.

In the body of a constructor, you can use

54 to invoke a constructor of its immediate superclass. Note that

54, if it is used, must be the first statement in the subclass' constructor. If it is not used in the constructor, Java compiler automatically insert a

49 statement to invoke the no-arg constructor of its immediate superclass. This follows the fact that the parent must be born before the child can be born. You need to properly construct the superclasses before you can construct the subclass.

Default no-arg Constructor

If no constructor is defined in a class, Java compiler automatically create a no-argument (no-arg) constructor, that simply issues a

49 call, as follows:

Take note that:

The default no-arg constructor will not be automatically generated, if one (or more) constructor was defined. In other words, you need to define no-arg constructor explicitly if other constructors were defined.

If the immediate superclass does not have the default constructor (it defines some constructors but does not define a no-arg constructor), you will get a compilation error in doing a

49 call. Note that Java compiler inserts a

49 as the first statement in a constructor if there is no

60.

Single Inheritance

Java does not support multiple inheritance (C++ does). Multiple inheritance permits a subclass to have more than one direct superclasses. This has a serious drawback if the superclasses have conflicting implementation for the same method. In Java, each subclass can have one and only one direct superclass, i.e., single inheritance. On the other hand, a superclass can have many subclasses.

Common Root Class - java.lang.Object

Java adopts a so-called common-root approach. All Java classes are derived from a common root class called

61. This

62 class defines and implements the common behaviors that are required of all the Java objects running under the JRE. These common behaviors enable the implementation of features such as multi-threading and garbage collector.

Inheritance EG. 2: The Point2D and Point3D Classes

The Superclass Point2D.java

The Subclass Point3D.java

A Test Driver for Point2D and Point3D Classes (TestPoint2DPoint3D.java)

Inheritance EG. 3: Superclass Person and its Subclasses

Suppose that we are required to model students and teachers in our application. We can define a superclass called

63 to store common properties such as

5 and

65, and subclasses

66 and

67 for their specific properties. For students, we need to maintain the courses taken and their respective grades; add a course with grade, print all courses taken and the average grade. Assume that a student takes no more than 30 courses for the entire program. For teachers, we need to maintain the courses taught currently, and able to add or remove a course taught. Assume that a teacher teaches not more than 5 courses concurrently.

We design the classes as follows.

The Superclass Person.java

The Subclass Student.java

The Subclass Teacher.java

A Test Driver (TestPerson.java)

Exercises

Composition vs. Inheritance

"A line is composed of 2 points" vs. "A line is a point extended by another point"

Recall that there are two ways of reusing existing classes: composition and inheritance. We have seen that a

1 class can be implemented using composition of

0 class - "A line is composed of two points", in the previous section.

1 can also be implemented, using inheritance from the

0 class - "A line is a point extended by another point". Let's call this subclass

72 (to differentiate from the

1 class using composition).

The Superclass Point.java

As above.

The Subclass LineSub.java

A Test Driver (TestLineSub.java)

Notes: This is the same test driver used in the earlier example on composition, except change in classname.

Study both versions of the Line class (

1 and

72). I suppose that it is easier to say that "A line is composed of two points" than that "A line is a point extended by another point".

Rule of Thumb: Use composition if possible, before considering inheritance. Use inheritance only if there is a clear hierarchical relationship between classes.

Exercises

The word "polymorphism" means "many forms". It comes from Greek word "poly" (means many) and "morphos" (means form). For examples, in chemistry, carbon exhibits polymorphism because it can be found in more than one form: graphite and diamond. But, each of the form has it own distinct properties (and price).

Substitutability

A subclass possesses all the attributes and operations of its superclass (because a subclass inherited all attributes and operations from its superclass). This means that a subclass object can do whatever its superclass can do. As a result, we can substitute a subclass instance when a superclass instance is expected, and everything shall work fine. This is called substitutability.

In our earlier example of

6 and

9 is a subclass of

6. We can say that

9 "is-a"

6 (actually, it "is-more-than-a"

6). Subclass-superclass exhibits a so called "is-a" relationship.

Circle.java

Cylinder.java

Via substitutability, we can create an instance of

9, and assign it to a

6 (its superclass) reference, as follows:

You can invoke all the methods defined in the

6 class for the reference

86, (which is actually holding a

9 object), e.g.

This is because a subclass instance possesses all the properties of its superclass.

However, you CANNOT invoke methods defined in the

9 class for the reference

86, e.g.

This is because

86 is a reference to the

6 class, which does not know about methods defined in the subclass

86 is a reference to the

6 class, but holds an object of its subclass

9. The reference

86, however, retains its internal identity. In our example, the subclass

9 overrides methods

06 and

00 or

01 invokes the overridden version defined in the subclass

9, instead of the version defined in

6. This is because

86 is in fact holding a

9 object internally.

Summary

A subclass instance can be assigned (substituted) to a superclass' reference.
Once substituted, we can invoke methods defined in the superclass; we cannot invoke methods defined in the subclass.
However, if the subclass overrides inherited methods from the superclass, the subclass (overridden) versions will be invoked.

Polymorphism EG. 1： Shape and its Subclasses

Polymorphism is very powerful in OOP to separate the interface and implementation so as to allow the programmer to program at the interface in the design of a complex system.

Consider the following example. Suppose that our program uses many kinds of shapes, such as triangle, rectangle and so on. We should design a superclass called

06, which defines the public interfaces (or behaviors) of all the shapes. For example, we would like all the shapes to have a method called

06, which returns the area of that particular shape. The

06 class can be written as follow.

Superclass Shape.java

Take note that we have a problem writing the

06 method in the

06 class, because the area cannot be computed unless the actual shape is known. We shall print an error message for the time being. In the later section, I shall show you how to resolve this problem.

We can then derive subclasses, such as

11 and

12, from the superclass

06.

Subclass Rectangle.java

Subclass Triangle.java

The subclasses override the

06method inherited from the superclass, and provide the proper implementations for

06.

A Test Driver (TestShape.java)

In our application, we could create references of

06, and assigned them instances of subclasses, as follows:

The beauty of this code is that all the references are from the superclass (i.e., programming at the interface level). You could instantiate different subclass instance, and the code still works. You could extend your program easily by adding in more subclasses, such as

18, etc, with ease.

Nonetheless, the above definition of

06 class poses a problem, if someone instantiate a

06 object and invoke the

06 from the

06 object, the program breaks.

This is because the

06 class is meant to provide a common interface to all its subclasses, which are supposed to provide the actual implementation. We do not want anyone to instantiate a

06 instance. This problem can be resolved by using the so-called

25 class.

Polymorphism EG. 2： Monster and its Subclasses

Polymorphism is a powerful mechanism in OOP to separate the interface and implementation so as to allow the programmer to program at the interface in the design of a complex system. For example, in our game app, we have many types of monsters that can attack. We shall design a superclass called

26 and define the method

27 in the superclass. The subclasses shall then provides their actual implementation. In the main program, we declare instances of superclass, substituted with actual subclass; and invoke method defined in the superclass.

Superclass Monster.java

Subclass FireMonster.java

Subclass WaterMonster.java

Subclass StoneMonster.java

A Test Driver TestMonster.java

Upcasting & Downcasting

Upcasting a Subclass Instance to a Superclass Reference

Substituting a subclass instance for its superclass is called "upcasting". This is because, in a UML class diagram, subclass is often drawn below its superclass. Upcasting is always safe because a subclass instance possesses all the properties of its superclass and can do whatever its superclass can do. The compiler checks for valid upcasting and issues error "incompatible types" otherwise. For example,

Downcasting a Substituted Reference to Its Original Class

You can revert a substituted instance back to a subclass reference. This is called "downcasting". For example,

Downcasting requires explicit type casting operator in the form of prefix operator

28. Downcasting is not always safe, and throws a runtime

29 if the instance to be downcasted does not belong to the correct subclass. A subclass object can be substituted for its superclass, but the reverse is not true.

Another Example on Upcasting and Downcasting

The following program tests the upcasting an downcasting (refer to the above instance diagram):

Casting Operator

Compiler may not be able to detect error in explicit cast, which will be detected only at runtime. For example,

The "instanceof" Operator

Java provides a binary operator called

30which returns

5 if an object is an instance of a particular class. The syntax is as follows:

An instance of subclass is also an instance of its superclass. For example,

Summary of Polymorphism

A subclass instance processes all the attributes operations of its superclass. When a superclass instance is expected, it can be substituted by a subclass instance. In other words, a reference to a class may hold an instance of that class or an instance of one of its subclasses - it is called substitutability.
If a subclass instance is assign to a superclass reference, you can invoke the methods defined in the superclass only. You cannot invoke methods defined in the subclass.
However, the substituted instance retains its own identity in terms of overridden methods and hiding variables. If the subclass overrides methods in the superclass, the subclass's version will be executed, instead of the superclass's version.

Exercises

Abstract Classes & Interfaces

The abstract Method and abstract class

In the above examples of

06 and

26, we encountered a problem when we create instances of

06 and

26 and run the

06 or

27. This can be resolved via

25 method and

25 class.

25 method is a method with only signature (i.e., the method name, the list of arguments and the return type) without implementation (i.e., the method’s body). You use the keyword

25 to declare an

25 method.

For example, in the

06 class, we can declare

25 methods

06,

46, etc, as follows:

Implementation of these methods is NOT possible in the

06 class, as the actual shape is not yet known. (How to compute the area if the shape is not known?) Implementation of these

25 methods will be provided later once the actual shape is known. These

25 methods cannot be invoked because they have no implementation.

A class containing one or more

25 methods is called an

25 class. An

25 class must be declared with a class-modifier

25. An

25 class CANNOT be instantiated, as its definition is not complete.

UML Notation:

25 class and method are shown in italic.

Abstract Class EG. 1: Shape and its Subclasses

Let us rewrite our

06 class as an

25 class, containing an

25 method

06 as follows:

The abstract Superclass Shape.java

25 class is incomplete in its definition, since the implementation of its

25 methods is missing. Therefore, an

25 class cannot be instantiated. In other words, you cannot create instances from an

25 class (otherwise, you will have an incomplete instance with missing method's body).

To use an

25 class, you have to derive a subclass from the

25 class. In the derived subclass, you have to override the

25 methods and provide implementation to all the

25 methods. The subclass derived is now complete, and can be instantiated. (If a subclass does not provide implementation to all the

25 methods of the superclass, the subclass remains

25.)

This property of the

25 class solves our earlier problem. In other words, you can create instances of the subclasses such as

11 and

12, and upcast them to

06 (so as to program and operate at the interface level), but you cannot create instance of

06, which avoid the pitfall that we have faced. For example,

In summary, an

25 class provides a template for further development. The purpose of an abstract class is to provide a common interface (or protocol, or contract, or understanding, or naming convention) to all its subclasses. For example, in the

25 class

06, you can define abstract methods such as

06 and

46. No implementation is possible because the actual shape is not known. However, by specifying the signature of the

25 methods, all the subclasses are forced to use these methods' signature. The subclasses could provide the proper implementations.

Coupled with polymorphism, you can upcast subclass instances to

06, and program at the

06 level, i,e., program at the interface. The separation of interface and implementation enables better software design, and ease in expansion. For example,

06 defines a method called

06, which all the subclasses must provide the correct implementation. You can ask for a

06 from any subclasses of Shape, the correct area will be computed. Furthermore, you application can be extended easily to accommodate new shapes (such as

6 or

18) by deriving more subclasses.

Rule of Thumb: Program at the interface, not at the implementation. (That is, make references at the superclass; substitute with subclass instances; and invoke methods defined in the superclass only.)

Notes:

An abstract method cannot be declared

88, as

88 method cannot be overridden. An

25 method, on the other hand, must be overridden in a descendant before it can be used.

25 method cannot be

4 (which generates a compilation error). This is because

4 method are not visible to the subclass and thus cannot be overridden.

Abstract Class EG. 2: Monster

We shall define the superclass

26 as an

25 class, containing an

25 method

27. The

25 class cannot be instantiated (i.e., creating instances).

The Java's interface

A Java

99 is a 100% abstract superclass which define a set of methods its subclasses must support. An

99 contains only

class Goalkeeper extends SoccerPlayer {......}
class MyApplet extends java.applet.Applet {.....}
class Cylinder extends Circle {......}

2 abstract methods (methods with signature and no implementation) and possibly constants (

class Goalkeeper extends SoccerPlayer {......}
class MyApplet extends java.applet.Applet {.....}
class Cylinder extends Circle {......}

88 variables). You have to use the keyword "

99" to define an

99 (instead of keyword "

07" for normal classes). The keyword

class Goalkeeper extends SoccerPlayer {......}
class MyApplet extends java.applet.Applet {.....}
class Cylinder extends Circle {......}

2 and

25 are not needed for its abstract methods as they are mandatory.

(JDK 8 introduces default and static methods in the interface. JDK 9 introduces private methods in the interface. These will not be covered in this article.)

Similar to an

25 superclass, an

99 cannot be instantiated. You have to create a "subclass" that implements an interface, and provide the actual implementation of all the

25 methods.

Unlike a normal class, where you use the keyword "

8" to derive a subclass. For interface, we use the keyword "

14" to derive a subclass.

An interface is a contract for what the classes can do. It, however, does not specify how the classes should do it.

An interface provides a form, a protocol, a standard, a contract, a specification, a set of rules, an interface, for all objects that implement it. It is a specification and rules that any object implementing it agrees to follow.

In Java,

25 class and

99 are used to separate the public interface of a class from its implementation so as to allow the programmer to program at the interface instead of the various implementation.

Interface Naming Convention: Use an adjective (typically ends with "

17") consisting of one or more words. Each word shall be initial capitalized (camel-case). For example,

18,

19,

20,

21,

22, etc.

Interface EG. 1: Shape Interface and its Implementations

We can re-write the

25 superclass

06 into an

99, containing only

25 methods, as follows:

UML Notations: Abstract classes, Interfaces and abstract methods are shown in italics. Implementation of interface is marked by a dash-arrow leading from the subclasses to the interface.

A test driver is as follows:

Interface EG. 2: Movable Interface and its Implementations

Suppose that our application involves many objects that can move. We could define an interface called

27, containing the signatures of the various movement methods.

Interface Moveable.java

Similar to an

25 class, an

99 cannot be instantiated; because it is incomplete (the abstract methods' body is missing). To use an interface, again, you must derive subclasses and provide implementation to all the abstract methods declared in the interface. The subclasses are now complete and can be instantiated.

MovablePoint.java

To derive subclasses from an

99, a new keyboard "

14" is to be used instead of "

8" for deriving subclasses from an ordinary class or an

25 class. It is important to note that the subclass implementing an interface need to override ALL the abstract methods defined in the interface; otherwise, the subclass cannot be compiled. For example,

Other classes in the application can similarly implement the

20 interface and provide their own implementation to the

25 methods defined in the interface

20.

TestMovable.java

We can also upcast subclass instances to the

20 interface, via polymorphism, similar to an

25 class.

Implementing Multiple Interfaces

As mentioned, Java supports only single inheritance. That is, a subclass can be derived from one and only one superclass. Java does not support multiple inheritance to avoid inheriting conflicting properties from multiple superclasses. Multiple inheritance, however, does have its place in programming.

A subclass, however, can implement more than one interfaces. This is permitted in Java as an interface merely defines the abstract methods without the actual implementations and less likely leads to inheriting conflicting properties from multiple interfaces. In other words, Java indirectly supports multiple inheritances via implementing multiple interfaces. For example,

interface Formal Syntax

The formal syntax for declaring interface is:

All methods in an interface shall be

class Goalkeeper extends SoccerPlayer {......}
class MyApplet extends java.applet.Applet {.....}
class Cylinder extends Circle {......}

2 and

25 (default). You cannot use other access modifier such as

42 and default, or modifiers such as

03,

88.

All fields shall be

class Goalkeeper extends SoccerPlayer {......}
class MyApplet extends java.applet.Applet {.....}
class Cylinder extends Circle {......}

03 and

88 (default).

99 may "

8" from a super-interface.

UML Notation: The UML notation uses a solid-line arrow linking the subclass to a concrete or abstract superclass, and dashed-line arrow to an interface as illustrated. Abstract class and abstract method are shown in italics.

Why interfaces?

An interface is a contract (or a protocol, or a common understanding) of what the classes can do. When a class implements a certain interface, it promises to provide implementation to all the abstract methods declared in the interface. Interface defines a set of common behaviors. The classes implement the interface agree to these behaviors and provide their own implementation to the behaviors. This allows you to program at the interface, instead of the actual implementation. One of the main usage of interface is provide a communication contract between two objects. If you know a class implements an interface, then you know that class contains concrete implementations of the methods declared in that interface, and you are guaranteed to be able to invoke these methods safely. In other words, two objects can communicate based on the contract defined in the interface, instead of their specific implementation.

Secondly, Java does not support multiple inheritance (whereas C++ does). Multiple inheritance permits you to derive a subclass from more than one direct superclass. This poses a problem if two direct superclasses have conflicting implementations. (Which one to follow in the subclass?). However, multiple inheritance does have its place. Java does this by permitting you to "implements" more than one interfaces (but you can only "extends" from a single superclass). Since interfaces contain only abstract methods without actual implementation, no conflict can arise among the multiple interfaces. (Interface can hold constants but is not recommended. If a subclass implements two interfaces with conflicting constants, the compiler will flag out a compilation error.)

Interface vs. Abstract Superclass

Which is a better design: interface or abstract superclass? There is no clear answer.

Use abstract superclass if there is a clear class hierarchy. Abstract class can contain partial implementation (such as instance variables and methods). Interface cannot contain any implementation, but merely defines the behaviors.

As an example, Java's thread can be built using interface

22 or superclass

51.

Exercises

(Advanced) Dynamic Binding or Late Binding

We often treat an object not as its own type, but as its base type (superclass or interface). This allows you to write codes that do not depends on a specific implementation type. In the

06 example, we can always use

06 and do not have to worry whether they are triangles or circles.

This, however, poses a new problem. The compiler cannot know at compile time precisely which piece of codes is going to be executed at run-time (e.g.,

06 has different implementation for

12 and

11).

In the procedural language like C, the compiler generates a call to a specific function name, and the linkage editor resolves this call to the absolute address of the code to be executed at run-time. This mechanism is called static binding (or early binding).

To support polymorphism, object-oriented language uses a different mechanism called dynamic binding (or late-binding or run-time binding). When a method is invoked, the code to be executed is only determined at run-time. During the compilation, the compiler checks whether the method exists and performs type check on the arguments and return type, but does not know which piece of codes to execute at run-time. When a message is sent to an object to invoke a method, the object figures out which piece of codes to execute at run-time.

Although dynamic binding resolves the problem in supporting polymorphism, it poses another new problem. The compiler is unable to check whether the type casting operator is safe. It can only be checked during runtime (which throws a

29 if the type check fails).

JDK 1.5 introduces a new feature called generics to tackle this issue. We shall discuss this problem and generics in details in the later chapter.

Exercises

(Advanced) Object-Oriented Design Issues

Encapsulation, Coupling & Cohesion

In OO Design, it is desirable to design classes that are tightly encapsulated, loosely coupled and highly cohesive, so that the classes are easy to maintain and suitable for re-use.

Encapsulation refers to keeping the data and method inside a class such users do not access the data directly but via the

class Goalkeeper extends SoccerPlayer {......}
class MyApplet extends java.applet.Applet {.....}
class Cylinder extends Circle {......}

2 methods. Tight encapsulation is desired, which can be achieved by declaring all the variable

4, and providing

class Goalkeeper extends SoccerPlayer {......}
class MyApplet extends java.applet.Applet {.....}
class Cylinder extends Circle {......}

2 getter and setter to the variables. The benefit is you have complete control on how the data is to be read (e.g., in how format) and how to the data is to be changed (e.g., validation).

[TODO] Example: Time class with private variables hour (0-23), minute (0-59) and second (0-59); getters and setters (throws

61). The internal time could also be stored as the number of seconds since midnight for ease of operation (information hiding).

Information Hiding: Another key benefit of tight encapsulation is information hiding, which means that the users are not aware (and do not need to be aware) of how the data is stored internally.

The benefit of tight encapsulation out-weights the overhead needed in additional method calls.

Coupling refers to the degree to which one class relies on knowledge of the internals of another class. Tight coupling is undesirable because if one class changes its internal representations, all the other tightly-coupled classes need to be rewritten.

[TODO] Example: A class uses Time and relies on the variables hour, minute and second.

Clearly, Loose Coupling is often associated with tight encapsulation. For example, well-defined public method for accessing the data, instead of directly access the data.

Cohesion refers to the degree to which a class or method resists being broken down into smaller pieces. High degree of cohesion is desirable. Each class shall be designed to model a single entity with its focused set of responsibilities and perform a collection of closely related tasks; and each method shall accomplish a single task. Low cohesion classes are hard to maintain and re-use.

[TODO] Example of low cohesion: Book and Author in one class, or Car and Driver in one class.

Again, high cohesion is associated with loose coupling. This is because a highly cohesive class has fewer (or minimal) interactions with other classes.

"Is-a" vs. "has-a" relationships

"Is-a" relationship: A subclass object processes all the data and methods from its superclass (and it could have more). We can say that a subclass object is-a superclass object (is more than a superclass object). Refer to "polymorphism".

"has-a" relationship: In composition, a class contains references to other classes, which is known as "has-a" relationship.

You can use "is-a" and 'has-a" to test whether to design the classes using inheritance or composition.

Is a constructor a void method?

Constructor is not like any ordinary method or function, it has no return type, thus it does not return void.

What is the type of constructor?

There are mainly 3 types of constructors in C++, Default, Parameterized and Copy constructors.

What happens if you declare a class constructor to have a void return type?

The class's default constructor will be used instead of the one you're declaring. It is a syntax violation to declare a constructor with any type, even void, so you'll receive a syntax error.

What differentiates the constructor from a method?

A Constructor is a block of code that initializes a newly created object. A Method is a collection of statements which returns a value upon its execution. A Constructor can be used to initialize an object. A Method consists of Java code to be executed.

Cryto Eth A constructor cannot