Multiple inheritance in Java. Comparison of composition and inheritance

"The Diamond Problem"

package com.journaldev.inheritance;
public abstract class SuperClass {
   	public abstract void doSomething();
}

package com.journaldev.inheritance;
public class ClassA extends SuperClass{
    @Override
 public void doSomething(){
        System.out.println("Какая-то реализация класса A");
    }
  //собственный метод класса  ClassA
    public void methodA(){
    }
}

package com.journaldev.inheritance;
public class ClassC extends ClassA, ClassB{
    public void test(){
        //вызов метода родительского класса
        doSomething();
    }
}

Multiple inheritance and interfaces

package com.journaldev.inheritance;
public interface InterfaceA {

    public void doSomething();
}

package com.journaldev.inheritance;

public interface InterfaceB {

    public void doSomething();
}

package com.journaldev.inheritance;

public interface InterfaceC extends InterfaceA, InterfaceB {

    //метод, с тем же названием описан в  InterfaceA и InterfaceB
    public void doSomething();

package com.journaldev.inheritance;

public class InterfacesImpl implements InterfaceA, InterfaceB, InterfaceC {

    @Override
    public void doSomething() {
        System.out.println("doSomething реализация реального класса ");
    }

    public static void main(String[] args) {
        InterfaceA objA = new InterfacesImpl();
        InterfaceB objB = new InterfacesImpl();
        InterfaceC objC = new InterfacesImpl();

        //все вызываемые ниже методы получат одинаковую реализацию конкретного класса

        objA.doSomething();
        objB.doSomething();
        objC.doSomething();
    }
}

Composition as salvation

package com.journaldev.inheritance;

public class ClassC{

    ClassA objA = new ClassA();
    ClassB objB = new ClassB();

    public void test(){
        objA.doSomething();
    }

    public void methodA(){
        objA.methodA();
    }

    public void methodB(){
        objB.methodB();
    }
}

Composition or inheritance?

1. Suppose we have the following combination of parent-heir classes:

   ClassC.java

   package com.journaldev.inheritance;
   
   public class ClassC{
   
   public void methodC(){
     	}
   
   }

   ClassD.java

   package com.journaldev.inheritance;
   
   public class ClassD extends ClassC{
   
       public int test(){
           return 0;
       }
   }

   The code above compiles and works fine, but what if ClassCit were implemented differently:

   package com.journaldev.inheritance;
   
   public class ClassC{
   
       public void methodC(){
       }
   
       public void test(){
       }
   }

   Note that the method test()already exists in the descendant class, but returns a result of a different type. Now ClassD, in case you are using an IDE, it will not compile. You will be advised to change the return type in the descendant or superclass.

   Now let's imagine a situation where there is multi-level inheritance of classes and the superclass is not available for our changes. Now, to get rid of the compilation error, we have no other options than to change the signature or name of the subclass method. We will also have to make changes to all places where this method was called. Thus, inheritance makes our code brittle.

   The problem described above never occurs in the case of composition, and therefore makes the latter preferable to inheritance.

2. The next problem with inheritance is that we expose all the methods of the parent to the client. And if the superclass is not designed very correctly and contains security holes. Then, even though we take full care of security in the implementation of our subclass, we will still depend on the flawed implementation of the parent class.

   Composition helps us in providing controlled access to the methods of a superclass, whereas inheritance does not maintain any control over its methods. This is also one of the main advantages of composition over inheritance.

3. Another benefit of composition is that it adds flexibility when calling methods. The implementation of the class ClassCdescribed above is not optimal and uses early binding to the called method. Minimal changes will allow us to make method calling flexible and allow late binding (binding at runtime).

   ClassC.java

   package com.journaldev.inheritance;
   public class ClassC{
       SuperClass obj = null;
       public ClassC(SuperClass o){
           this.obj = o;
       }
       public void test(){
           obj.doSomething();
       }
   
       public static void main(String args[]){
           ClassC obj1 = new ClassC(new ClassA());
           ClassC obj2 = new ClassC(new ClassB());
   
           obj1.test();
           obj2.test();
       }
   }

   The program above will display:

   doSomething implementation of A
   doSomething implementation of B

   This flexibility in method calling is not seen with inheritance, which makes composition the best approach.

4. Unit testing is easier in the case of composition because we know that for all the methods that are used in the superclass we can stub the tests, while in inheritance we depend heavily on the superclass and don't know how the methods of the parent class will be used. So, due to inheritance, we will have to test all the methods of the superclass, which is unnecessary work.

   Ideally, inheritance should only be used when the “ is-a ” relationship is true for the parent and child classes, otherwise composition should be preferred.