Doesn’t Java have multiple inheritance?

Question

I had seen somewhere now I don’t remember, I think it was in a course on object orientation, which Ruby possesses. But in Java I’ve never seen it. Is that why abstract classes are used? Or is this meaningless?

Answer 1

In Java it is not possible for a class to inherit multiple classes.

The reason for this, imagine that one class inherits two other classes, however these two inherited classes have methods with the same signature but with different implementations. It would be difficult to deal with, because how would the subclass know which implementation of the method it should use? So it is not possible for a class to extend from more than one class in Java.

An abstract class may have abstract methods as well as concrete methods, that is, methods that have already been implemented, so the fact that the class is abstract does not help much to solve the problem mentioned above.

What you can do in Java is that a class implements several interfaces, because interfaces are like 100% abstract classes, that is, it is completely forbidden any kind of implementation in it, therefore, there is no problem if the two interfaces have a method with the same signature, because who will implement the method is the class that implements the interfaces.

Something curious is that the word reserved extends can be used for interfaces, which is when one interface inherits another interface(s), but in this case there is no problem of an interface inheriting from several other interfaces, as there is no implementation involved in this case. It would be a code that would look like this:

Interface1:

public interface Interface1 { public void teste(); }

Interface2:

public interface Interface2 { public void teste(); }

Subinterface:

public interface SubInterface extends Interface1, Interface2 { }

Note that there is no problem in doing this, because the implementation goes in the first concrete class that implement the Subinterface:

public class MinhaClasse implements SubInterface {
    @Override
    public void teste() {
        System.out.println("sou apenas um teste");
    }
}

Answer 2

Correct conceptualization

I think you are looking to know if Java allows multiple inheritance. In it the class can inherit from several other classes, whether concrete or abstract.

Abstract classes are those that cannot be instantiated, that is, that you cannot create an object based on it. They only exist to be inherited. They must be part of another class. Your methods may or may not have implementations.

A special case of abstract class is the interface. It cannot have been (roughly, variables that hold values) and methods cannot have implementation (in Java 8 can). It has only the signature of the method defining the behavior but not how the behavior will act. It is considered a purely abstract class because it has not been.

In Java you can get multiple inheritance of interfaces through implements. That is, you can inherit several sets of behaviors without defined implementations but cannot inherit state and implementations at ease. Only one concrete or abstract class can be inherited. If you need to add other features in the new class it must be through specific implementation.

You can use multiple implements, that is, you can implement as many interfaces as you need to indicate what that class is capable of. When you extend, you’re saying the new class is an "improved version" of the class that will be extended. When you implement something, you are saying that the class has certain characteristics necessary for its proper functioning. This way you and the compiler know if a class can be used in a given context. That is, if she possesses all that will be necessary in that context.

This was partially minimized with the new Default Methods in the interfaces.

Using "multiple inheritance"

I don’t know Ruby well, but as far as I know she also doesn’t have multiple inheritance. She does this through mixins. A combination of features is made and not exactly a heritage of resources. It is similar to interfaces with default methods.

So in Java 8 it’s possible to have something very close to what Ruby gets. Being a new resource I still don’t understand all its limitations but it is clear that there can be no state and there can be no constructors as occurs in concrete or abstract classes. It seems to me that are similar limitations to those found in mixins.

Note the examples of the Java documentation on default methods that it is possible to add complete behavior, that is, defining your signature plus the implementation, but this is not considered de facto multiple inheritance. It’s more of a combination. Of course popularly it can be interpreted as being.

It seems to be a trend that all languages have some form of combination of methods, or with default methods, or with Extension methods (C#) or with mixins or with traits (PHP). Without such resources, it forces the programmer to violate the DRY and copy identical implementations to methods that do exactly the same thing in different classes.

Simplified example:

interface Teste {
    default public void teste() {
        System.out.println("teste");
    }
}

class Classe { };

class NovaClasse extends Classe implements Teste { }

class HelloWorld {
    public static void main(String[] args) {
        NovaClasse teste = new NovaClasse();
        teste.teste(); //vai imprimir a palavra teste conforme definido na interface
    }
}

Behold working in the ideone. And in the repl it.. Also put on the Github for future reference.

Problem of multiple inheritance

Multiple inheritance is discouraged because of the diamond problem and the difficulty of correct implementation in languages. In addition, programmers have difficulty understanding the functioning and constraints that it imposes. There is often abuse using multiple inheritance as a mechanism to facilitate coding when it should facilitate semantic organization of the application.

Few languages implement this feature. C++ is one of them but it is recommended to avoid at most. Eiffel is a case that even encourages but is a language that has other limitations. Smalltalk also allows. Some features are not very orthogonal, and do not match well. So it is necessary to make choices.