Superclass and Subclass

Inheritance is one characteristic of object-oriented programming, which states that a class can be derived again into new classes. Java allows us to define a generic class. Furthermore, the class can be derived again into a new class with more specific properties. In Java terminology, the parent class is called superclass and the new derived class is called subclass. In this derivation process, the derived class will inherit the properties contained in the parent class. Furthermore, the derived class can have specific properties previously not owned by the parent class. For example, class Animal. The class can then be derived again into new more specific classes without leaving the properties of class Animal, to: class Herbivore and Carnivore. Derived classes can also be derived again into new classes. For example, class Herbivore can be derived to class Cow and Sheep, class Carnivore can be derived to class Lion and Tiger, and so forth. The class hierarchy can be illustrated by the following picture:



In this case, class Animal is a superclass of class Herbivore and Carnivore. Herbivore and Carnivore class itself acts as a subclass. However, as you can see above, a subclass can be a superclass for other derived classes. In this case, subclass Herbivore can be a superclass of class Cow and Sheep. Likewise subclass Carnivore, can be a superclass of class Lion and Tiger.

Making Subclass

Java provides keyword extends that used to perform class derivation. The general form of the use of the keyword as follows:

class subclass-name extends superclass-name {
   class body
}

Consider the following simple program, which will show how to create a derived class and any benefits from the process.

class A {

   private int a;

   public void setA (int value) {
      a = value;
   }

   public int getA() {
      return a;
   }
}

//create subclass from class A
class B extends A {
   private int b;

   public void setB(int value) {
      b = value;
   }

   public int getB() {
      return b;
   }
}

class InheritanceDemo1 {
   public static void main(String[] args) {

      B obj = new B();

      obj.setA(100);
      obj.setB(200);

      System.out.println("nilai a : " + obj.getA());
      System.out.println("nilai b : " + obj.getB());
   }
}

As you can see in the code above, class B is a subclass or an instance of class A. As a result, class B will inherit the properties contained in the class A. As a proof of this statement, observe the return code above. There, we create an object or an instance of class B, but in fact, the object also has method setA() and getA(), but we never define both method in class B. This means, class B has inherited method setA() and getA() of class A. However, private data contained in the superclass (class A) remains inaccessible to the subclass (class B). When executed, the above program will give the following results:

Value a : 100
Value b : 200

Derived classes can be derived again into other new classes. For example in this case, we want to derived class B into a new class, namely the class C. In this way, the class C will inherit the properties contained in the class A and class B. The following code will demonstrate this:

class A {

   private int a;

   public void setA (int value) {
      a = value;
   }

   public int getA() {
      return a;
   }
}

//create subclass from class A
class B extends A {
   private int b;

   public void setB(int value) {
      b = value;
   }

   public int getB() {
      return b;
   }
}

//create subclass from class B
class C extends B {
   private int c;

   public void setC(int value) {
      c = value;
   }

   public int getC() {
      return c;
   }

class InheritanceDemo2 {
   public static void main(String[] args) {

      C obj = new C();

      obj.setA(100);
      obj.setB(200); 
      obj.setC(300);

      System.out.println("Value a : " + obj.getA());
      System.out.println("Value b : " + obj.getB());
      System.out.println("Value c : " + obj.getC());
   }
}

This time, the result that will be provided by the program is as follows:

Value a : 100
Value b : 200
Value c : 300

From these results, we can see clearly that the object of class C will have the methods defined in the class A and B, namely: method setA(), getA(), setB(), and getB().

Unlike C++, Java does not support multiple inheritance. In C++, a derivative class may be formed from two or more parent classes. The derived class will then have the properties contained in all of the parent class.