Why can't we use multiple inheritance in Java 8 by calling the specific class's method name?

Question

Java 8's default methods in an interface can be called from the child class using InterfaceName.super.methodName . Why doesn't Java 8 allow us to use a similar syntax to call the specific class's method name? Can this resolve the Diamond Problem encountered for multiple inheritance?

class Employee {
    public static void displayName() {
        System.out.println("Employee!");
    }
}

class Engineer extends Employee {
    public static void displayName() {
        System.out.println("Engineer!");
    }
}

class Manager extends Employee {
    public static void displayName() {
        System.out.println("Manager!");
    }
}

public class Resource extends Engineer,Manager {

    public static void main(String args[]) {
        //Insert similar code here like InterfaceName.super.methodName to call any of the above methods to handle multiple inheritance.
    }

}

what is the intent of Resource extending both Engineer and Manager? Is it an object that is both a manager and engineer at the same time? What would you expect to happen if its displayName() is called? — Always Learning, May 03 '20 at 16:10
Java doesn't support multiple inheritance with classes because it's messy (at least the way the JVM works, implementing it would be really hard). Therefore, in your extends clause, you can only have one class (in a class. Interfaces can extend multiple interfaces). You'll just have to refactor your code so Resource doesn't extend both Engineer and Manager. Try making those 2 interfaces, or try composition. — user, May 03 '20 at 16:27
The question is not only how to call the parents' methods, isn't it? If you write a method named `displayName()` in your new class, does it override the mother's method or the father's method? When someone creates an instance and calls `displayName()`, do they call the mother's or the father's method? If you assign this object to a variable of type `Engineer`, it's supposed to behave differently than when you assign it to a variable of type `Manager`. How do you do that? — RealSkeptic, May 03 '20 at 16:55

score 0 · Answer 1 · answered May 03 '20 at 16:59

In Java 8, you can not extend (inherit) multiple classes all in one shot. What I mean by this is that if you write:

public class Resource extends Engineer, Manager { //This generates a compiler error.
}

However, you may inherit multiple classes into one, main class by making a chain of inheritance.

public class Master {
  public void method1(){};
}
public class Child1 extends Master{
  public void method2() {};
}
public class Child2 extends Child1 {
  //you can access method 1 and method 2 here by simply calling
method1();
method2();
}

A way you can go about addressing your issue is to write an "EmployeeInterface" and write an "EmployeeClass". To access the methods in "EmployeeClass", you must make an object of the "EmployeeClass" in your main method. You will need to write a constructor to pass the name of the employee in. I will provide an example here:

public interface EmployeeInterface {

public void displayName(); 

public void setName(String name);

}

The above is an Interface. An interface contains the methods that you want to use in a class, however, you do not yet define them here. You only write the method headers. Think of this as a shopping list. Writing an item such as bread on a shopping list does not mean you will now have bread, it just marks it as an item that needs to be purchased.

Next, you will need to write a class implementing the EmployeeInterface.

public class EmployeeClass implements EmployeeInterface{

private String employeeName;

public EmployeeClass(String name) { //This is a constructor
    this.employeeName = name;
}

@Override
/**
 * This function will display the name of the employee.
 */
public void displayName() {
    System.out.println(employeeName);
}

@Override
/**
 * This function with use the given string and change the employee's name.
 */
public void setName(String name) {
    this.employeeName = name;
 }//end of setName method
}//end of class

Above is the class that implements the EmployeeInterface. It looks at the Interface and says that you must define what these methods do. This is like looking at your shopping list and seeing bread, and going to the store and buying it. There is also a constructor in this class. A constructor in java is a method that is executed upon the instantiation of an instance of a class. This means that whatever code you write in the constructor, it will be run once and only once when you make an object of the class. Constructors must be spelled the same as the class, is case sensitive, and must be public. You can add as many parameters as you'd like. We use @Override over the functions in the class because we are overriding (Changing the body) from nothing to our definition from the EmployeeInterface. Depending on your IDE/Compiler, it may work without the @Override tag, but it is highly reccomended that you do this. In the constructor, you see we use this.employeeName = name; the "this" keyword refers to the field (variable) within the class that we write it in. In this case, it is not necessary, because the name of the variable in the class and the name of the variable being passed in are different. But in the case that variable names are the same, you can use "this.variableName" to specify the class variable.

Finally, to use these classes, you must make a main method in a separate class to execute these functions. Making the main method is like making a sandwich out of the bread that you purchased at the store.

public class Main {

public static void main(String[] args)  {

    EmployeeInterface manager = new EmployeeClass("Bob");
    EmployeeInterface engineer = new EmployeeClass("Mary");

    System.out.println("The name of the manager is: ");
    manager.displayName();

    System.out.println("The name of the engineer is: ");
    engineer.displayName();

    manager.setName("Jack");
    System.out.println("The new manager's name is: ");
    manager.displayName();

  }//end of method Main
}//end of class Main

Above is the method that executes the methods that you defined in the EmployeeClass using the EmployeeInterface. First, you create an object of the class, of the type that is the name of the Interface.

EmployeeInterface manager = new EmployeeClass("Bob");

This is an object of the EmployeeClass, and we called it manager. We made it of type EmployeeInterface because we want to be able to use the methods we defined in the EmployeeInterface. We write "= new EmployeeClass("Bob");" afterward because we want to make a new Instance of the EmployeeClass, and pass the String "Bob" into our constructor.

Next, we display the name of the manager.

    System.out.println("The name of the manager is: ");
    manager.displayName();

This will display the name of the manager.

We can also change the name of the manager with our defined "setName()" function.

manager.setName("Jack");

We call the function like this and pass in the String "Jack" which will become the new name for the manager.

Upon execution of the Main method, we get this output: Image of the output

All in all, this solution does not use inheritance of methods to print the names of different employees, but uses an EmployeeInterface, along with a definition of the Interface, EmployeeClass, to store and display the employee names. Rather than making a new class for every employee, you make a new object with the parameters containing the name of the new employee in the main method.

I hope this answered your question, and please do reply if you require any more clarifications.

Here I also include some articles about the Java concepts I talked about.

Here is a resource for Inheritance and Interfaces.

Interfaces on Oracle

Inheritance on Oracle

Constructors on Oracle

Why can't we use multiple inheritance in Java 8 by calling the specific class's method name?

1 Answers1