Inheritance in Java Example

Today we will look into Multiple Inheritance in Java. Sometime back I wrote few posts about inheritance, interface and composition in java. In this post, we will look into java multiple inheritance and then compare composition and inheritance.

Multiple Inheritance in Java

Numerous legacy in java is the capacity of making a solitary class with different superclasses. Dissimilar to some other prevalent article situated programming dialects like C++, java doesn't offer help for numerous legacy in classes.

Java doesn't bolster various legacies in classes since it can prompt diamond problem and as opposed to giving some intricate method to comprehend it, there are better routes through which we can accomplish a similar outcome as different inheritances.

Diamond Problem in Java

To comprehend precious stone issue effectively, let's accept that different legacies were upheld in java. All things considered, we could have a class progressive system like underneath image.

Let’s say SuperClass is an abstract class declaring some method and ClassA, ClassB are concrete classes.

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("doSomething implementation of A"); } //ClassA own method public void methodA(){ } } package com.journaldev.inheritance; public class ClassA extends SuperClass{ @Override public void doSomething(){ System.out.println("doSomething implementation of A"); } //ClassA own method public void methodA(){ } } package com.journaldev.inheritance; public class ClassB extends SuperClass{ @Override public void doSomething(){ System.out.println("doSomething implementation of B"); } //ClassB specific method public void methodB(){ } } Now let’s say ClassC implementation would be something like below and it’s extending both ClassA and ClassB. package com.journaldev.inheritance; // this is just an assumption to explain the diamond problem //this code won't compile public class ClassC extends ClassA, ClassB{ public void test(){ //calling super class method doSomething(); } } Notice that test() method is making a call to superclass doSomething() method. This leads to the ambiguity as the compiler doesn’t know which superclass method to execute. Because of the diamond-shaped class diagram, it’s referred to as Diamond Problem in java. The diamond problem in Java is the main reason java doesn’t support multiple inheritances in classes.

Notice that the above problem with multiple class inheritance can also come with only three classes where all of them has at least one common method.

Multiple Inheritance in Java Interfaces

You might have noticed that I am always saying that multiple inheritances is not supported in classes but it’s supported in interfaces. A single interface can extend multiple interfaces, below is a simple example.

package com.journaldev.inheritance; public interface InterfaceA { public void doSomething(); } package com.journaldev.inheritance; public interface InterfaceB { public void doSomething(); } Notice that both the interfaces are declaring the same method, now we can have an interface extending both these interfaces like below. package com.journaldev.inheritance; public interface InterfaceC extends InterfaceA, InterfaceB { //same method is declared in InterfaceA and InterfaceB both public void doSomething(); } This is perfectly fine because the interfaces are only declaring the methods and the actual implementation will be done by concrete classes implementing the interfaces. So there is no possibility of any kind of ambiguity in multiple inheritances in Java interfaces. Composition vs Inheritance

One of the best practices of Java programming is to “favor composition over inheritance”. We will look into some of the aspects favoring this approach.

  1. Suppose we have a superclass and subclass as follows:

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

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

    The above code compiles and works fine but what if ClassC implementation is changed like below:

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

    Notice that test() method already exists in the subclass but the return type is different. Now the ClassD won’t compile and if you are using any IDE, it will suggest you change the return type in either superclass or subclass.

    Now imagine the situation where we have multiple levels of class inheritance and superclass is not controlled by us. We will have no choice but to change our subclass method signature or its name to remove the compilation error. Also, we will have to make a change in all the places where our subclass method was getting invoked, so inheritance makes our code fragile.

    The above problem will never occur with composition and that makes it more favorable over inheritance.

  2. Another problem with inheritance is that we are exposing all the superclass methods to the client and if our superclass is not properly designed and there are security holes, then even though we take complete care in implementing our class, we get affected by the poor implementation of the superclass.

    Composition helps us in providing controlled access to the superclass methods whereas inheritance doesn’t provide any control of the superclass methods, this is also one of the major advantages of composition over inheritance.

    Another benefit with composition is that it provides flexibility in the invocation of methods. Our above implementation of ClassC is not optimal and provides compile-time binding with the method that will be invoked, with minimal change we can make the method invocation flexible and make it dynamic.

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

    Output of above program is:

    doSomething implementation of A doSomething implementation of B

    This flexibility in method invocation is not available in inheritance and boosts the best practice to favor composition over inheritance.

  3. Unit testing is easy in composition because we know what all methods we are using from superclass and we can mock it up for testing whereas in inheritance we depend heavily on superclass and don’t know what all methods of superclass will be used, so we need to test all the methods of superclass, that is an extra work and we need to do it unnecessarily because of inheritance.

That’s all for multiple inheritances in java and a brief look at composition.

© Journaldev Python 3 tutorial spring tutorial