Inheritance

Every class that you create in Java is a subclass, its ultimate parent is the Object class that every class inherits even if you dont declare it. To inherit a class we use the extends keyword the extended class is known as the parent or base class or superclass, the object performing the extending is known as the child (derived) or subclass

• Inheritance of state - state is defined by the classes static and instance fields
• Inheritance of implementation - implementation is defined by the behavior of the class, its methods in other words
• Inheritance of type - an inherited type in Java can be a class or an interface.

A subclass is said to be of type superclass and an instance of the subclass can be used anywhere an instance of the superclass can be used basically subclass 'IS A' of the superclass

There are a few rules regarding IS-A and HAS-A relationships

There are visual object modelling languages such has the Unified Modeling Language (UML) which allow designers to design and easily modify classes without having to write code first because object-oriented components are represented graphically. This helps coders to create a map of the class relationships and helps them recognize errors before coding begins. There are many design patterns available which cover a lot of different types of projects.

To obtain what class an object belongs to you can use the following

A class consists of two types of elements:

• Members - members include fields, any methods and any nested types (classes enums, interfaces). Members of a class can be inherited by subclasses
• Elements that are not members such as constructors, initializer blocks and static initializer blocks are NOT inherited by subclasses, however remember that there is an implied call to the superclasses constructor even if an explicit call is not made.

The rules for inheritance is as follows:

• You cannot extend a class that marked final
• A subclass does NOT inherit the private members of its parent, an important note is that the object which is instantiated from the subclass type, is instantiated with the private field variables of the superclass
• A subclass inherits all of the public and protected members of its parent
• If the subclass is in the same package as its parent, it also inherits the package-private members of its parent
• You can declare new fields and methods in the subclassand thus extending the parent class
• You can hide fields and override methods in the parent class see overriden methods, unless they are mark final

Create and Extend Abstract Classes

An abstract class is a class that is declared with the abstract modifier and it may or may not include abstract methods. An abstract class defers some or all of its implementation to its subclass and thus an abstract class cannot be instantiated. An abstract class is use to define common attributes and behavior for a class that will extend it.

The class example of an abstract class is the Animal class which is extended by the Dog class, as you normally will not instantiate an Animal class, the Animal class will contain common attributes and behavior that can be used by several animals, for example walk, bite, number of legs, etc. A class that is not abstract is called a concrete class. Note to remember is that an abstract class needs a subclass to implement its methods, thereby forcing commonality of interface. If one method is declared abstract then the class itself needs to be abstract as well, fields cannot be declared abstract.

Abstract class rules are as follows:

• Any class that has an abstract method must be declared abstract
• Any subclass must implement ALL of the abstract methods or be declared abstract itself
• An abstract class does not actually have to have any abstract methods
• An abstract class can have implemented methods of any type
• An abstract class can have atributes, and other inner types, such as class, enum and interface
• An abstract class cannot be declared as final, as its opposite to abstract, but you can have final methods in an abstract class
• An abstract class cannot be declared as private because no other class would be able to extend it
• An abstract class cannot be static, a static method cannot be overriden which is opposite to abstract
• You cannot create an abstract constructor

abstract class AbstractClass {}

public abstract class Vehicle {

    // We create an enum which describes possible subclasses
    protected enum VehicleType {
        Automobile, Motorcycle, Moped, Bicycle, Scooter
    }

    // These attributes will be common to all subclasses
    private VehicleType type;
    private String owner;
    private String make;

    // Standard Constructor
    public Vehicle(VehicleType type, String owner, String make) {
        this.type = type;
        this.owner = owner;
        this.make = make;
    }

    // toString method
    public String toString() {
        return "Vehicle{" +
                "type=" + type +
                ", owner='" + owner + '\'' +
                ", make='" + make + '\'' +
                '}';
    }

    // As the below are all abstract they will need to be implemented by the subclass
    public abstract void drive();

    public abstract void park();

    public abstract void makeNoise();
}
    
// Vehicle is a concrete class which extends the abstract class Vehicle
public class Auto extends Vehicle {

    // Create a constructor that is a pass thru to Vehicle constructor
    public Auto(VehicleType type, String owner, String make) {
        super(type, owner, make);
    }

    // Implement Vehicle's drive method
    public void drive() {
        System.out.println("Release Brake, go");
    }

    // Implement Vehicle's park method
    public void park() {
        System.out.println("Parallel or back in?");
    }

    // Implement Vehicle's makeNoise method
    public void makeNoise() {
        System.out.println("Vroom Vroom");
    }

    // Main method creates an instance of Auto and demonstrates calling the
    // concrete methods
    public static void main(String[] args) {
        Auto car = new Auto(VehicleType.Automobile, "Allen", "Ford");
        System.out.println(car);
        car.drive();
        car.park();
        car.makeNoise();
    }
}

I have not covered Interfaces yet but here is a table of the differences between abstract class and an interface. If you want to provide common, implemented functionality among all implementations of your component, use an abstract class. Abstract classes allow you to partially implement your class, whereas interfaces contain no implementation for any members.

Using super

Whenever a subclass needs to refer to it's immediate superclass it can do so by using the keyword super. super has two general forms, the first calls the superclass constructor, the second is to access a member of the superclass that has been hidden by a member of a subclass.

public class SuperTest extends SuperClass {

    int i = 10;                                                       // hides the superclass variable i

    public SuperTest() {
        super();                                                      // we call the superclasses constructor
    }

    public static void main(String[] args) {
        SuperTest st = new SuperTest();
        st.getSuperVariable();
    }

    public void getSuperVariable() {
        System.out.println("local variable i is : " + i);             // getting the local variable i
        System.out.println("superclass variable i is : " + super.i);  // getting the superclasses variable i
    }
}

class SuperClass {

    int i = 5;                                                        // this gets hidden by the local variable i

    public SuperClass() {
        System.out.println("This is the super constructor");
    }
}

Object Class

There is a special class in Java called the Object Class, all other classes are subclasses of Object, its a superclass of all other classes. Object defines a number of mewthod that all classes inherit or can override.

When you want a to read something more meaningful about an object of your own class you can override the toString() method.

Overriding equals()

There are cases when you want to compare two objects that contain the same attributes and because the equals() method in the Object class uses only the = = operator for comparison, the two objects are only considered equal if the references refer to the same object. This method for comparing has a problem when using Hashtables, lets say we have a number of car objects with the same attributes and you put these into a Hashtable, when you search the Hashtable to get a number of objects with the same attributes, you will only retrieve the one which matches the reference you have, this is because the equals() method only uses the = = operator and hence only one object will match within the Hashtable

The equals() method has a contract which has a number of rules that must be followed (obtained from the Java docs)

• it is reflexive: for any reference value x, x.equals( y ) should return true if and only if y.equals( x ) returns true
• it is symmetric: for any reference values x and y, x.equals( y ) should return true if and only if y.equals( x ) returns true
• it is transitive: for any reference values x, y and z, if x.equals(y) returns true and y.equals(z) returns true then x.equals(z) should return true
• it is consistent: for any reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false.
• for any nonnull reference value x, x.equals(null) should return false

equals() and hashCode() are bound together by a joint contract, that states two equal objects should have the same hashcode as well, so to be very safe if you override the equals() method then you should override the hashCode() method.

Overriding hashCode()

The hashcode value of an object is used in collection classes, it's basically a object ID number, however it is not unique. The hashcode is used to store the object in collections such as HashMap and HashSet, this code is also used to locate the object as well.

How do hashcode's work, is that the collection will use a number of buckets that will contain hashcode's that point to data. For example lets say we have four people objects, each object is hashed by using an hashing algorithm and then placed into a bucket

In real life the hash algorithm is a lot more advanced than this, as we can see Alex and Dirk will go into one bucket, Bob in another and Fred in another, so we have a bucket that contains two people objects which is acceptable. So now when you perform a search you no longer need to check each object, you simple hash the object you want to search for then go straight to that bucket and then only search through that bucket cutting down the number of objects to check against thus speeding up processing., in this case if you searched for Alex we would go straight to bucket 42 then search the two objects in there for Alex (thus only two searches instead of 4).

Now the problems arise if you do not pass the right name to search for (missing letter, upper case instead of lower case, thus the hashcode produced for you search would not match any bucket, now you see why if two objects are considered equal, their hashcode's must also be equal, Otherwise you'd never be able to find the object since the default hashcode method in class Object virtually always comes up with a unique number for each object. so if two objects are equal their hashcode's must be equal as well.

What we are trying to achieve is a even distribution of data across the buckets, thus speeding up searches. Again the hashCode contract states the following rules

• Whenever the hashcode() method is invoked on the same object more than once during an execution of a Java application, the hashcode() method must consistently return the same integer, provided no information used in equals() comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application.
• If two objects are equal according to the equals(Object) method, then calling the hashCode() method on each of the two objects must produce the same integer.
• It is not required that if two objects are unequal according to the equals(Object) method, then calling the hashCode() method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve performance of hash tables

In short this means

Using instanceof

Sometimes you need to know what type an object is during runtime, for example you could have one thread creating objects and another thread processing them, the processing thread can then check th type of object to confirm that it can process it, also you can check before you cast an object to make sure it can be casted (otherwise you could get errors). Java uses the instanceof operator to confirm the type of an object.

class A {
    int i, j;
}
class B {
    int i, j;
}
class C extends A {
    int k;
}
class D extends A {
    int k;
}
class InstanceofTest {
    public static void main(String args[]) {
        A a = new A();
        B b = new B();
        C c = new C();
        D d = new D();
        
        if(a instanceof A)
            System.out.println("a is instance of A");
        if(b instanceof B)
            System.out.println("b is instance of B");
        if(c instanceof C)
            System.out.println("c is instance of C");
        if(c instanceof A)
            System.out.println("c can be cast to A");
        if(a instanceof C)
            System.out.println("a can be cast to C");
        System.out.println();
        
        // compare types of derived types
        A ob;
        ob = d; // A reference to d
        System.out.println("ob now refers to d");
        
        if(ob instanceof D)
            System.out.println("ob is instance of D");
        System.out.println();
        
        ob = c; // A reference to c
        System.out.println("ob now refers to c");
        if(ob instanceof D)
            System.out.println("ob can be cast to D");
        else
            System.out.println("ob cannot be cast to D");
        
        if(ob instanceof A)
            System.out.println("ob can be cast to A");
        System.out.println();
        
        // all objects can be cast to Object
        if(a instanceof Object)
            System.out.println("a may be cast to Object");
    }
}

Static Import

Using static import will import all static members of a class or interface, you can then access directly using their names with qualifying the with their class name.

// Use static import to bring sqrt() and pow() into view. 
import static java.lang.Math.sqrt;             // you can use a wildcard here to import all static members
import static java.lang.Math.pow; 
 
// Compute the hypotenuse of a right triangle. 
class Hypot { 
  public static void main(String args[]) { 
    double side1, side2; 
    double hypot; 
 
    side1 = 3.0; 
    side2 = 4.0; 
 
    // Here, sqrt() and pow() can be called by themselves, without their class name. 
    hypot = sqrt(pow(side1, 2) + pow(side2, 2)); 
 
    System.out.println("Given sides of lengths " + 
                       side1 + " and " + side2 + 
                       " the hypotenuse is " + 
                       hypot); 
  } 
}