1. Delegation
a relationship that is not directly supported by Java. This is a midway between inheritance and composition, because you place a number object in the class you are building(like composition), but at the same time you expose all the methods from the member object in your new class(like inheritance)
public class SpaceShipDelegation {
private String name;
private SpaceShipControls controls = new SpaceShipControls();
public SpaceShipDelegation(String name){
this.name = name;
}
// Delegated methods:
public void back(int velocity) {
controls.back(velocity);
}
public void dowm(int velocity) {
controls.down(velocity);
}
public void forward(int velocity) {
controls.forward(int velocitly);
}
......
public static void main(String[] args) {
SpaceShipDelegation protector = new SpaceShipDelegation("NSEA Protector" );
protector.forward(100);
}
}
2. Guaranteening proper cleanup
you must also pay attention to the calling order for the base-class and number object cleanup methods in case one subobject depends on another. In general, you should follow the same form that is imposed by a C++ complier on its destructors: reverse the order of creation.
3. Name hiding
if a Java base class has method name that is overloaded several times, redefineing that method name in the derived-class would not hide any of the base-class versions(unlike C++), Thus overloading works regardless of whether the method was defined at this level or in the base class
class Homer {
char doh(char c) {
print("doh(char)");
return ‘d‘;
}
float doh(float f) {
print("doh(float)");
return 1.0f;
}
}
class Milhouse {}
class Bart extends Homer {
void doh(Milhouse m) { // overloading between in inheritance ? I‘m not sure
print("doh(Milhouse)");
}
}
public class Hide {
public static void main(String[] args) {
Bart b = new Bart();
b.doh(1);
b.doh(‘x‘);
b.doh(1.0f);
b.doh(new Milhouse());
}
}/*Output:
doh(float)
doh(char)
doh(float)
doh(Milhouse)
*/
3. Chossing composition vs inheritance
Composition is generally used when you want the functionality of an existing class inside your new class, but not its interface. That is, you embed an object so that you can it to implement features in your new class, but the user of your new class sees the interface you‘ve defined for the new class rather than the interface from the embedded object. For this effect, you embed private objects of existing classes inside your new class.
the is-a relationship is expressed with inheritance, and the has-a relationship is expressed with composition.
4. Protected
The protected keyword is a nod to pragmatism. available to anyone who inherits from this class or anyone else in the same package(protected also provides package access)