Combining composition

and
inheritance

It

is very common to use composition and inheritance together. The following

example shows the creation of a more complex class, using both inheritance and

composition, along with the necessary

//: PlaceSetting.java
// Combining composition & inheritance
 
class Plate {
  Plate(int i) {
    System.out.println("Plate constructor");
  }
}
 
class DinnerPlate extends Plate {
  DinnerPlate(int i) {
    super(i);
    System.out.println(
      "DinnerPlate constructor");
  }
}
 
class Utensil {
  Utensil(int i) {
    System.out.println("Utensil constructor");
  }
}
 
class Spoon extends Utensil {
  Spoon(int i) {
    super(i);
    System.out.println("Spoon constructor");
  }
}
 
class Fork extends Utensil {
  Fork(int i) {
    super(i);
    System.out.println("Fork constructor");
  }
}
 
class Knife extends Utensil {
  Knife(int i) {
    super(i);
    System.out.println("Knife constructor");
  }
}
 
// A cultural way of doing something:
class Custom {
  Custom(int i) {
    System.out.println("Custom constructor");
  }
}
 
public class PlaceSetting extends Custom {
  Spoon sp;
  Fork frk;
  Knife kn;
  DinnerPlate pl;
  PlaceSetting(int i) {
    super(i + 1);
    sp = new Spoon(i + 2);
    frk = new Fork(i + 3);
    kn = new Knife(i + 4);
    pl = new DinnerPlate(i + 5);
    System.out.println(
      "PlaceSetting constructor");
  }
  public static void main(String[] args) {
    PlaceSetting x = new PlaceSetting(9);
  }
} ///:~ 

While

the compiler forces you to initialize the base classes, and requires that you

do it right at the beginning of the constructor, it doesn’t watch over

you to make sure that you initialize the member objects, so you must remember

to pay attention to that.

Guaranteeing
proper cleanup

Java

doesn’t have the C++ concept of a

Often

this is fine, but there are times when your class might perform some activities

during its lifetime that require cleanup. As mentioned in Chapter 4, you

can’t know when the garbage collector will be called, or if it will be

called. So if you want something cleaned up for a class, you must write a

special method to do it explicitly, and make sure that the client programmer

knows that they must call this method. On top of this, as described in Chapter

9 (

Consider

an example of a computer-aided design system that draws pictures on the screen:

//: CADSystem.java
// Ensuring proper cleanup
import java.util.*;
 
class Shape {
  Shape(int i) {
    System.out.println("Shape constructor");
  }
  void cleanup() {
    System.out.println("Shape cleanup");
  }
}
 
class Circle extends Shape {
  Circle(int i) {
    super(i);
    System.out.println("Drawing a Circle");
  }
  void cleanup() {
    System.out.println("Erasing a Circle");
    super.cleanup();
  }
}
 
class Triangle extends Shape {
  Triangle(int i) {
    super(i);
    System.out.println("Drawing a Triangle");
  }
  void cleanup() {
    System.out.println("Erasing a Triangle");
    super.cleanup();
  }
}
 
class Line extends Shape {
  private int start, end;
  Line(int start, int end) {
    super(start);
    this.start = start;
    this.end = end;
    System.out.println("Drawing a Line: " +
           start + ", " + end);
  }
  void cleanup() {
    System.out.println("Erasing a Line: " +
           start + ", " + end);
    super.cleanup();
  }
}
 
public class CADSystem extends Shape {
  private Circle c;
  private Triangle t;
  private Line[] lines = new Line[10];
  CADSystem(int i) {
    super(i + 1);
    for(int j = 0; j < 10; j++)
      lines[j] = new Line(j, j*j);
    c = new Circle(1);
    t = new Triangle(1);
    System.out.println("Combined constructor");
  }
  void cleanup() {
    System.out.println("CADSystem.cleanup()");
    t.cleanup();
    c.cleanup();
    for(int i = 0; i < lines.length; i++)
      lines[i].cleanup();
    super.cleanup();
  }
  public static void main(String[] args) {
    CADSystem x = new CADSystem(47);
    try {
      // Code and exception handling...
    } finally {
      x.cleanup();
    }
  }
} ///:~ 

Everything

in this system is some kind of

(which is itself a kind of

since it’s implicitly inherited from the root class). Each class redefines

’s

method in addition to calling the base-class version of that method using

.

The specific

classes

,

and

all have constructors that “draw,” although any method called

during the lifetime of the object could be responsible for doing something that

needs cleanup. Each class has its own

method to restore non-memory things back to the way they were before the object

existed.

In

,

you can see two keywords that are new, and won’t officially be introduced

until Chapter 9:

Note

that in your cleanup method you must also pay attention to the calling order

for the base-class and member-object cleanup methods in case one subobject

depends on another. In general, you should follow the same form that is imposed

by a C++ compiler on its destructors: First perform all of the work specific to

your class (which might require that base-class elements still be viable) then

call the base-class cleanup method, as demonstrated here.

There

can be many cases in which the cleanup issue is not a problem; you just let the

garbage collector do the work. But when you must do it explicitly, diligence

and attention is required.

Order
of garbage collection

There’s

not much you can rely on when it comes to

Name
hiding

Only

C++ programmers might be surprised by name hiding, since it works differently

in that language.

//: Hide.java
// Overloading a base-class method name
// in a derived class does not hide the
// base-class versions
 
class Homer {
  char doh(char c) {
    System.out.println("doh(char)");
    return 'd';
  }
  float doh(float f) {
    System.out.println("doh(float)");
    return 1.0f;
  }
}
 
class Milhouse {}
 
class Bart extends Homer {
  void doh(Milhouse m) {}
}
 
class Hide {
  public static void main(String[] args) {
    Bart b = new Bart();
    b.doh(1); // doh(float) used
    b.doh('x');
    b.doh(1.0f);
    b.doh(new Milhouse());
  }
} ///:~ 

As

you’ll see in the next chapter, it’s far more common to override

methods of the same name using exactly the same signature and return type as in

the base class. It can be confusing otherwise (which is why C++ disallows it,

to prevent you from making what is probably a mistake).

|

|