Inheritance and Abstract Classes

The Concept of Inheritance

The idea behind inheritance is specialization. For example, suppose you have a class representing an employee and a class representing a manager. In this case, the manager is a specialized type of employee and thus the class manager inherits from the class employee.

Inheritance is a relationship model between classes where one class, called superclass, represents a general concept and one class, called subclass, represents a more specialized concept. The subclass inherits from the superclass which means:

• it has the same methods as the superclass,
• it is possible to override methods of the superclass,
• you cannot access instance fields of the superclass in the subclass,
• and you can add additional instance fields and methods to the subclass.

Specialization:

• object is member of ONE class only
• no multiple inheritance in Java => single specialization of disjunct subclasses
• superclass might or might not have objects

Employee e = new Manager(); 
e.getSalary();

public double getSalary()   {     return super.getSalary() + bonus;    }       

public Manager( String aName )
{
    super(aName);
	   bonus = 0;
}

Abstract classes

An abstract method is an undefined method which must be defined in a subclass. A class containing one or more abstract methods must be declared as abstract and is thus called an abstract class. An abstract class can have instance fields. It is not possible to create objects of an abstract class. 

The Template Method Pattern

Context:

• An algorithm is applicable for multiple types.
• The algorithm can be broken down into primitive operations.
• The primitive operations can be different for each type.
• The order of the primitive operations does not depend on the type.

Solution

• define superclass with
  • one method for the algorithm
  • abstract methods for the primitive operations.
• implement the algorithm to call the primitive operations in the appropriate order.
• do not define the primitive operations in the superclass, or define them to have appropriate default behavior.
• each subclass defines the primitive operations (but not the algorithm).

Protected interfaces

The protected keyword allows access to a method of a superclass from all subclasses of this class and from classes of the same package. The idea behind using protected methods is to provide a protected interface and a public interface. The protected interfacedoes only contain operations which are made for the subclasses. The public interface is made for the clients of the superclass (other program parts / packages using it).

Example:

CompoundShape (superclass):

import java.awt.*;
import java.awt.geom.*;

public abstract class CompoundShape
{
	private GeneralPath path;
	
	public CompoundShape()
	{
		path = new GeneralPath();
	}
	
	protected void add( Shape s )
	{  
		path.append( s, false );
	};
}

CarShape (subclass):

public class CarShape extends CompoundShape 
{
	public CarShape( int x, int y, int width, int height )
	{
		Rectangle2D.Double base = ...;
		add( base );
	}
}

The intention of using the add method in the CarShape's constructor is that it allows access to the private instance field path of the superclass CompoundShape.

Someone could argue that it is possible to declare the add method as public but in that case, clients of the class could accidentally add not fitting shapes.

However, protected fields should not be used because they have the same disadvantages as public fields.

When not to use inheritance

• if two classes have has-a relationship
  • example: a class circle has points, it is not a point
• do not use inheritance if it violates the substitution principle
  • example: the class stack in the java.util package which extends a dynamic array class although it has no use for some methods of a dynamic array
    • for instance, removing an element of a stack given its index

See also

1. http://en.wikipedia.org/wiki/Template_method_pattern
2. http://en.wikipedia.org/wiki/Inheritance_(computer_science)