Inheritance vs. Composition, Abstract Classes

Inheritance vs. Composition

Class inheritance is a technique that allows us to create new classes from existing classes.
Inheritance contributes a lot to software reuse.
Another technique for software reuse is composition.

By composition, in our classes under development, we explicitly declare data members as objects of some existing classes.

Example of composition :

////////// class Engine ////////////
public class Engine { 
    public void start() { ... } 
    public void stop () { ... } 
}


////////// class Wheel ////////////
public class Wheel { 
    public void inflate ( int psi ) { ... } 
}


////////// class Window ////////////
public class Window { 
    public void rollup  () { ... } 
    public void rolldown() { ... } 
}


////////// class Door////////////
public class Door { 
    // a door has a window
    public Window window = new Window();

    public void open  () { ... } 
    public void close () { ... } 
}

////////// class Car ////////////
public class Car {

    // a car has a an engine 
    private Engine   engine = new Engine();

    // a car has  four wheels
    private Wheel[] wheels = new Wheel[4];

    // a car has a left doow
    private Door     left   = new Door();

    // a car has a right doow
    private Door     right  = new Door();

    public Car () {
        for ( int i = 0; i < 4; i ++ ) 
            wheels[i] = new Wheel();
    }

}

////////// class CarApp ////////////
class CarApp {
    public static void main ( String [] args ) {
        Car car = new Car();
        car.left.window.rollup();
        car.wheels[0].inflate(72);
        car.engine.start();
        ......
    }
}

It seems that both inheritance and composition allow you to place objects of other existing classes. But there are important differences:
- Composition is generally used when we want the feature of some existing classes inside our new classes, but not their interface.
- That is, we want to use their functionalities to implement features of our new classes.
- But what the users of our new classes see are the interfaces of our new classes, rather than the interfaces of the embedded objects.
- By inheritance, we take an existing class and make a special (specific) version of it.
- In generally, it means that we are taking a general-purpose class and specializing it for a particular need.
- With inheritance, the whole interface of the parent class automatically becomes part of the interface of the new class.
- It make sense that a Car class inherits from a more general class vehicle.
- But it does not make sense to compose a car using a vehicle object.
- While inheritance establish a is-a relationship, composition establish a has-a relationship.
It should be not difficult to decide whether we need composition or inheritance with a little thought.
In some situations, you may need both for our new classes, i.e., you inherit from some more general class and embed objects of other classes.

Abstract Classes

Motivations
- Suppose we have identified a class hierarchy as follows:
```
                          Vehicle
                          / |  \
                         /  |   \
                        /   |    \
                       /    |     \
                      /     |      \
                     /      |       \
                    /       |        \
                  Car      Boat      Plane

             
```
- Suppose you decide to have a drive method in the parent class Vehicle as follows:
```
                  class  Vehicle { 
                      // some data members
                         ......

                      // method drive
                      void drive ( int miles ) {  

                          // what should be here ??????

                      }
                  }
             
```
- What should be put inside the body of the drive( int miles) method ?
- Well, since the ways we drive different types of vehicles may differ significantly, it is really difficult to figure out a set of operations which are common to all types of vehicles.
- As a solution, we may choose to put nothing there and let the derived classes to override the this method.
- But what if in the derived classes (say Car), we forget to override this method and wrongly think that this method has already been properly implemented in the parent class ?
- We will get no compile errors, but the resulted Car class simply can not "drive" at all.
- Are there any systematic ways which enforce us to implement a method in the derived classes ?
- Yes, by declaring the Vehicle class as an abstract class.
How to create abstract classes ?
- Add modifier abstract to the class header and all its methods we want to be abstract.
- Add modifier abstract to the declaration of all the methods we want to be abstract, and make them bodyless.
  
  Example of Abstract class:
```
        abstract class  Vehicle { 
            // some data members
               ......

            // method drive, bodyless
            abstract  void drive ( int miles );   
        }
            
```
Semantics and requirements of abstract classes
- In abstract classes, the abstract modifier must be applied to each of abstract method.
- An abstract method is a method that has certain signature but does not have any implementation. (Note: a method with an empty body is different than a method without a body! )
- Any class that that contains one or more abstract methods must be declared as abstract class.
- An abstract class serves as placeholder in a class hierarchy. It represent an abstract entity that is usually insufficiently defined to be useful by itself.
- As a result, an abstract class itself can not be used to create any object.
```
            Vehicle vehicle = new Vehicle(); // Not allowed !
            
```
- Yet an abstract class establishes some requirements for all its derived classes (e.g., what methods with what signatures must be implemented in the derived classes and so on).
- The derived classes have to implement ALL the abstract methods of its parent class.
```
            class Car extends Vehicle {
                // some additional data members
                ......

                void drive ( int miles ) {

                    // some code here
                }

            }
            
```
- Objects can only be created from derived classes which are non-abstract.
```
            Car car = new Car (); // this is allowed !
            
```
- Note 1: We can declare a class which contains no abstract methods as abstract. In this case, we just want this class to be inherited and do not want the users to create objects from this class.
- Note 2: We may still consider to declare a derived class of some abstract class as abstract class.
- Note 3: It is possible, of course, that we declare an abstract which contains only abstract methods and constant (but no variable) data members. Such a special abstract is called an interface, which we will disscuss after midterm exam.