CareerCup

overridden method will be applicable for both the interface.

for eg:

interface A
{
	public void foo();
}


interface B
{
	public void foo();
}


public class MultipleInheritenceTest implements A,B {

	/**
	 * @param args
	 */
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		A a=new MultipleInheritenceTest();
		a.foo();
		
		B b=new MultipleInheritenceTest();
		b.foo();
	}

	@Override
	public void foo() {
		System.out.println("Hello");
		
	}

}


Output:
Hello
Hello

I think it doesn't make any difference. In fact, the implementation of both similar methods will be common and one in C Class.

Please correct me if I am wrong

Although you don't have multi-inherentence in java, but you can extends from two classes that have the same method. In C++, they are quite different.

class base1 {
   void start() { cout << "Inside base1"; }
};

class base2 {
   void start() { cout << "Inside base2"; }
};

class derived : base1, base2 { };

int main() {
  derived a;
  a.start();

}

You can solve it like this

a.base1::start();

a.base2::start();

Or

class derived:public base1,public base2
{
public:
    using base1::start;
};

interface  A {
    /**
     * Doc A
     * **/
    public void MethodA();

    public String MethodB();

}

interface  B {
    /**
     * Doc B
     * **/
    public String MethodA();

    public void MethodB();
}

class lucy implements A,B{

    @Override
    public String MethodA() {
        //To change body of implemented methods use File | Settings | File Templates.
        return null;
    }

    @Override
    public String MethodB() {
        //To change body of implemented methods use File | Settings | File Templates.
        return null;
    }
}

Implemented class will throw these compile error:

'MethodA()' in 'lucy' clashes with 'MethodA()' in 'A'; attempting to use incompatible return type
'MethodB()' in 'lucy' clashes with 'MethodB()' in 'B'; attempting to use incompatible return type

So，it proves that class lucy implements both of the interface A and B。

I would like to bring  some clarity on these questions on interfaces that are been asked and discussed .
1) When there are two methods with same signature in different interfaces and if class implements both the interfaces which one gets implemented .
ex: interface A {
String fun(int a  ) ;
}
interface B{
String fun(int a  ) ;
}

class TestMultipleInheritence implements A,B 
{
String fun()
{
return null;
}

Answer : 
If you check the java Doc on interfaces , " An interface is a contract , which a class implements need to adhere to " . As in interfaces all the methods are "abstract" ( basically no body ) it doesn't make any difference as the developer need to provide the business logic for that method in the  implementation class.  Compiler checks for the signature of the method and here it follows the "overriding rules for a method in java " . 

2) When there are smilar methods in two different interfaces with different return types . 
ex :  interface A{
String fun(); }
interface B{
void fun(); }



Ans : When class tries to implement both these interfaces there will be an issue with the return type and there will be a compilation error saying " return type void is not compatible with String "  as , java uses the overriding rules for the interfaces and the overriding rules says that "The return type must be the same as, or a subtype of, the return type declared in the original overridden method in the superclass (also called covariant return type).
if the code gets modified as this as given below . we see no compliation error as String is descending from Object class there is no issue . 

interface A{
Object fun(); }

interface B{
String fun(); }

class TestMultipleInheritence implements A,B 
{

String fun()
{
return null;
}

}






}

your question is absurd...if methods are same then implementation is also same if you are implementing both

In this case only one implementation is enough if the both the method having same signature and return type.

I think there are 2 ways to look at it....

1)The method C has different signatures in interface A, B

2)The method C has the same signature in both A, B

Now in the 1st case obviously class C will have to implement 2 methods one that has the signature in A and the other that has signature in B...So obviously in this case the method C has different identities and Class C will be implementing both separately.

and in the second case as the signatures will be identical so it doesnt really matter if it belongs to A or B...it will be one method anyway with a concrete body.

Common sense! Lol

Multiple interfaces with same signature and same return type will have only one method implementation in implemented class. However, interfaces with same signature and different return types is not allowed, gives you compile time error.

Java doesn't support multiple inheritance using classes. It does support using interfaces.