Multiple Inheritance in java

I have read that most programmers don't use multiple inheritance in a proper way. "Just go ahead and inherit from a class just to reuse code" is not the best practice in case of multiple inheritance.

Many programmers do not know when to use simple inheritance in most cases. Multiple inheritance must be used with caution and only if you know what you are doing if you want to have a good design.

I don't think that the lack of multiple inheritance in java (as in c++) will put restrictions in your code / application design / problem domain mapping into classes.

Simplicity. To quote Tom Sintes,

The Java design team strove to make Java:

• Simple, object oriented, and familiar
• Robust and secure
• Architecture neutral and portable
• High performance
• Interpreted, threaded, and dynamic

The reasons for omitting multiple inheritance from the Java language mostly stem from the "simple, object oriented, and familiar" goal. As a simple language, Java's creators wanted a language that most developers could grasp without extensive training. To that end, they worked to make the language as similar to C++ as possible (familiar) without carrying over C++'s unnecessary complexity (simple).

In the designers' opinion, multiple inheritance causes more problems and confusion than it solves. So they cut multiple inheritance from the language (just as they cut operator overloading). The designers' extensive C++ experience taught them that multiple inheritance just wasn't worth the headache.

if java support multiple inheritance then it may effect other features of java
consider super() method which is used to call super class constructor.if program has multiple super class(because of multiple inheritance) then compiler will get confused about which super class constructor should be called and throw an error

Java designers decided that. Multiple inheritance can be simulated by the use of interfaces.

One simple answer is that all classes in Java derive from java.lang.Object IIRC. So, you would always have a diamond problem... :-D

It is true that Java did not use to support multiple inheritance of implementation (just of type i.e. interface). That was a design decision.

However, since Java 8, it supports multiple inheritance using default methods. See http://docs.oracle.com/javase/tutorial/java/IandI/multipleinheritance.html:

Multiple inheritance of implementation is the ability to inherit method definitions from multiple classes. Problems arise with this type of multiple inheritance, such as name conflicts and ambiguity. ... Default methods introduce one form of multiple inheritance of implementation.

package org.example;

public class Main {

  public static void main(String[] args) {
    Two_D circle = new Circle(5);
    System.out.println("Area of circle: " + circle.Area());

    Two_D square = new Square(4);
    System.out.println("Area of square: " + square.Area());

    Two_D triangle = new Triangle(3, 4, 5);
    System.out.println("Area of triangle: " + triangle.Area());

    Three_D sphere = new Sphere(3);
    System.out.println("Surface area of sphere: " + sphere.SurfaceArea());
    System.out.println("Volume of sphere: " + sphere.Volume());

    Three_D cube = new Cube(4);
    System.out.println("Surface area of cube: " + cube.SurfaceArea());
    System.out.println("Volume of cube: " + cube.Volume());
  }
}

class Shape {

}

class Two_D extends Shape {

  double Area() {
    return 0;
  }
}

class Three_D extends Shape {

  double SurfaceArea() {
    return 0;
  }

  double Volume() {
    return 0;
  }
}

class Circle extends Two_D {
  double radius;

  Circle(double radius) {
    this.radius = radius;
  }

  @Override
  double Area() {
    return Math.PI * radius * radius;
  }
}

class Square extends Two_D {
  double side;

  Square(double side) {
    this.side = side;
  }

  @Override
  double Area() {
    return side * side;
  }
}

class Triangle extends Two_D {
  double a, b, c;

  Triangle(double a, double b, double c) {
    this.a = a;
    this.b = b;
    this.c = c;
  }

  @Override
  double Area() {

    double s = (a + b + c) / 2;
    return Math.sqrt(s * (s - a) * (s - b) * (s - c));
  }
}

class Sphere extends Three_D {
  double radius;

  Sphere(double radius) {
    this.radius = radius;
  }

  @Override
  double SurfaceArea() {
    return 4 * Math.PI * radius * radius;
  }

  @Override
  double Volume() {
    return (4 / 3) * Math.PI * Math.pow(radius, 3);
  }
}

class Cube extends Three_D {
  double side;

  Cube(double side) {
    this.side = side;
  }

  @Override
  double SurfaceArea() {
    return 6 * side * side;
  }

  @Override
  double Volume() {
    return side * side * side;
  }
}

The diamond problem arises when multiple parent classes define their own implementations of something and the child class of these two has to deal with the ambiguity of which implementation to use. So what if all classes in Java derive from Object, that's a single parent class. "Single parent, multiple derived classes" is not the same as "Multiple parents, single derived class"