Hybrid Inheritance

Hybrid Inheritance is the combination of single and multiple inheritance. By using interface it can achieve multiple inheritance as well.

Hierarchical Inheritance

Hierarchical inheritance is refer to one to many relationship. That means one superclass has more than one subclasses. Example: Animal

class Animal
{

}

class Dog extends Animal
{

}

class Cat extends Animal
{

}

class Rat extends Animal
{

}

Multiple Inheritance

Multiple inheritance is not allowed in Java. In Java one class can only inherit from one superclass not more. It will cause compilation error when one class tries to extends more than one superclass. Another reason it is not allowed is that it will cause ambiguity if subclass tries to override methods from superclass. It doesn't know which methods should be overridden from. It is so called Deadly Diamond of Dead (DDD) issue. By default even Java doesn't allow multiple inheritance but we can achieve it by implementing interfaces. Interface is one of important concept in object-oriented programming.

class A{ }

class B{ }

class C extends A{ }

class C extends B{ }

public class MultipleTest

{

  public static void main(String args[])

  {

  

  }

}

Result:

MultipleTest.java:16: error: duplicate class: C

class C extends B

^

1 error

Multilevel Inheritance

Multilevel inheritance is similar to our family relationship Grandfather-Father-Son. Son inherits characteristics from Father and Father inherits behaviors from Grandfather. Also Son inherits some behaviors from Grandfather as well. It is similar to Java Multilevel inheritance.

Examples: Alien IS-A Superhuman and Superhuman IS-A Human.

In this example we have three classes Human, Superhuman and Alien. Human can do basic things like eating, running and jumping. Superhuman inherits human abilities. They can do what human do as well as emitting laser beam and fly. Alien is even unbelievable. They can do what human and superhuman do. They also can invisible.

Human attribute: haircolor
Superhuman attribute: specialty

class Human
{
  String haircolor;

  public Human (String h) { haircolor = h;}
 
  public void eat()  { System.out.println("I can eat !!");}
  public void run()  { System.out.println("I can run !!");}
  public void jump() { System.out.println("I can jump !!");}
  public String getHairColor() { return haircolor; }
}

class Superhuman extends Human
{
  String specialty;
 
  public Superhuman (String hc, String specialty)
  {
super(hc);
this.specialty = specialty;
  }
 
  public void laserbeam()  {System.out.println("I can emit laserbeam !!"); }
  public void fly() { System.out.println("I can fly !!"); }
  public String getSpecialty() { return specialty; }
}

class Alien extends Superhuman
{
  public Alien (String hc, String s)
  {
super (hc,s);
  }
 
  public void invisible() {System.out.println("I can be invisible suddenly !!");}
}

public class MultilevelTest
{
  public static void main (String args[])
  {
     Superhuman s1 = new Superhuman("black","laser");
     System.out.println("Superhuman s1 created.");
     Alien a1 = new Alien("green","mind control");
     System.out.println("Alien a1 created.\n");

    System.out.println("Alien a1 can do following....");
    a1.eat();
    a1.run();
    a1.jump();
    a1.laserbeam();
    a1.fly();
    a1.invisible();

    System.out.println("\nSuperhuman s1 can do following....");
    s1.fly();
    s1.laserbeam();
    s1.eat();
    s1.jump();
    s1.run();
    System.out.println("s1: "+"hair color: "+s1.getHairColor()+" / specialty: "+s1.getSpecialty());
    System.out.println("a1: "+"hair color: "+a1.getHairColor()+" / specialty: "+a1.getSpecialty());
  }
}

Result:
Superhuman s1 created.
Alien a1 created.

Alien a1 can do following....
I can eat !!
I can run !!
I can jump !!
I can emit laserbeam !!
I can fly !!
I can be invisible suddenly !!

Superhuman s1 can do following....
I can fly !!
I can emit laserbeam !!
I can eat !!
I can jump !!
I can run !!
s1: hair color: black / specialty: laser
a1: hair color: green / specialty: mind control

Single Inheritance

Single inheritance is the most simple form among five types of inheritance. It requires one superclass and one subclass.

Examples: Dog IS-A Canine, Student IS-A Person, Mobile Phone IS-A Electronics

We adopt Dog and Canine as single inheritance example. Dog is one kind of Canine. They share common attributes like color, size. For simplicity we don't use abstraction but the concept is the same. We create Canine class with instance variables color and size as well as instance methods. Then Dog inherits from Canine and gets all its instance variables and methods. Later we create a Dog object and set its color and size. That is single inheritance.

class Canine

{
  String color;
  int size;

  public int getSize()
  {    return size;  }

  public String getColor()
  {    return color;  }

  public void setSize(int s)
  {    size = s;  }

  public void setColor(String c)
  {    color = c;  }
}

class Dog extends Canine { }

public class SingleInheritanceTest
{
  public static void main (String args[])
  {
     Dog d1 = new Dog();
     d1.setColor("brown");
     d1.setSize(30);
     System.out.println("Dog color: "+ d1.getColor());
     System.out.println("Dog size: "+ d1.getSize());
  }
}

Results:
Dog color: brown
Dog size: 30

Inheritance (IS-A)

Inheritance is a compile-time mechanism. A super-class can have any number of subclasses. But a subclass can have only one superclass. This is because Java does not support multiple inheritance. The superclass and subclass have “is-a” relationship between them.

There are five types of inheritance in Java. They are single, multilevel, multiple, hierarchical and hybrid. I will illustrate them one by one.

Single inheritance: There are only two entities in this inheritance. One is superclass and other is subclass.

Multilevel inheritance: There are more than two entities in this inheritance. Typical example is GFS relationship. That is Grandfather-Father-Son. Son inherits from Father and Father inherits from Grandfather.

Multiple inheritance: A subclass inherits from more than one superclass. But it is not allowed in Java but it can be achieved by implementing interfaces.

Hierarchical inheritance: This kind of inheritance appears in our life so often. A superclass has many subclasses. Dog, cat, tiger, lion are all animals. They inherit from same ancestor.

Hybrid inheritance: Hybrid inheritance is the combination of single and multiple inheritance. By using Interface we can achieve multiple inheritance in Java.