Why Java doesn't support multiple inheritance

1)

The first reason is ambiguity around Diamond problem, consider a class A has foo() method and then B and C derived from A and has there own foo() implementation and now class D derive from B and C using multiple inheritance and if we refer just foo() compiler will not be able to decide which foo() it should invoke.

This is also called Diamond problem because structure on this inheritance scenario is similar to 4 edge diamond, see below

A foo()
/ \
/ \
foo() B C foo()
\ /
\ /
D
foo()

In my opinion even if we remove the top head of diamond class A and allow multiple inheritances we will see this problem of ambiguity.

Some times if you give this reason to interviewer he asks if C++ can support multiple inheritance than why not Java. 

hmmmmm in that case I would try to explain him the second reason which I have given below that its not because of technical difficulty but more to maintainable and clearer design was driving factor though this can only be confirmed by any of java designer and we can just speculate.

2)

Second and more convincing reason to me is that multiple inheritances does complicate the design and creates problem during casting, constructor chaining etc and given that there are not many scenario on which you need multiple inheritance its wise decision to omit it for the sake of simplicity.

Also java avoids this ambiguity by supporting single inheritance with interfaces. Since interface only have method declaration and doesn't provide any implementation there will only be just one implementation of specific method hence there would not be any ambiguity.

What is the output of following program?

1. package com.javastepbystep;
2. 
   
3. class A
4. {
5.  
6.      static int method1(int i)
7.     {
8.          return method2(i *= 11);
9.      }
10.  
11.       static int method2(int i)
12.      {
13.           return method3(i /= 11);
14.       }
15.  
16.        static int method3(int i)
17.       {
18.            return method4(i -= 11);
19.       }
20.  
21.       static int method4(int i)
22.      {
23.          return i += 11;
24.      }
         
25.      public static void main(String [] args)
26.     {
27.           System.out.println(method1(11));
28.      }
29.  
30. }

Ans: 11

What is the output of following program?

 public class B{
    
      B b= new B();
    
     public int show(){
          return (true ? null : 0);
     }
    
     public static void main(String[] args)  {
    
            B b= new B();
            b.show();
        }
    
    }

Output:

1. Exception in thread "main" java.lang.StackOverflowError
2. at com.instanceofjava.B.<init>(B.java:3)
3. at com.instanceofjava.B.<init>(B.java:5)
4. at com.instanceofjava.B.<init>(B.java:5) 

Explanation:

• Whenever we create the object of any class constructor will be called first and memory allocated for all non-static variables
• Here  B b= new B(); the variable is an object and assigned to a new object of the same class
• B b= new B(); statement leads to recursive execution of constructor will create infinite objects so at the run time an exception will be raised
• Exception in thread "main" java.lang.StackOverflowError
• The common cause for a stack overflow exception is a bad recursive call. Typically this is caused when your recursive functions don't have the correct termination condition

What will be the output of java program

public class Test {
    public static void main(String[] args) {
        System.out.println(Math.min(Double.MIN_VALUE, 0.0d));
    }
}

Answer: 

This question is tricky because unlike the Integer, where MIN_VALUE is negative, both the MAX_VALUE and MIN_VALUE of the Double class are positive numbers.

The Double.MIN_VALUE is 2^(-1074), a double constant whose magnitude is the least among all double values. So unlike the obvious answer, this program will print 0.0 because of Double.MIN_VALUE is greater than 0.

Difference between == and .equals()

They both differ very much in their significance. equals() method is present in the java.lang.Object class and it is expected to check for the equivalence of the state of objects! That means, the contents of the objects.

Whereas the '==' operator is expected to check the actual object instances are same or not.

For example, lets say, you have two String objects and they are being pointed by two different reference variables s1 and s2.

 s1 = new String("abc");
 s2 = new String("abc");

Now, if you use the "equals()" method to check for their equivalence as

 if(s1.equals(s2))
      System.out.println("s1.equals(s2) is TRUE");
 else
      System.out.println("s1.equals(s2) is FALSE");

You will get the output as TRUE as the 'equals()' method check for the content equivality.

Lets check the '==' operator.

if(s1==s2)
     System.out.printlln("s1==s2 is TRUE");
   else
     System.out.println("s1==s2 is FALSE");

Now you will get the FALSE as output because both s1 and s2 are pointing to two different objects even though both of them share the same string content.

It is because of 'new String()' everytime a new object is created.

Try running the program without 'new String' and just with

   String s1 = "abc";
   String s2 = "abc";

You will get TRUE for both the tests.