Achieving multiple inheritance via interface

I am a beginner in interface concept.

when I surfing for the information about "Achieving multiple inheritance via interface", I came across this link.. Multiple inheritance

I have a same doubt as the programstudent had.

hi, Good Explanation very much helpful In the uml diagram for java there is no connection to Animal from Bird and horse why? Is it necessary to use the implement the same method in the derived class and why

void birdNoise(); 
void horseNoise(); 

why in the Peagus class

public void horseNoise()
{
    System.out.println("Horse Noise!");
}

public void birdNoise()
{ 
    System.out.println("Bird Noise!");
} 

why this must be there? Why "Remember, we must write each cl开发者_StackOverflow社区ass's own implementation for each method in the interface. reason? Thank for this good explanation Thank you

In that post, they have used multiple inheritance in c++ and converted to interfaces in java.

1.what I thought about inheritance is having some methods in parent class, and whenever the same methods are needed in other class(es) too, then those class(es) will inherit the parent class and use it. But in interface concept if each derived class(es) has to define its own implementation then what is the use of inheriting it?

2.If we have to provide own implementation then why not we define that method in the derived class(es) itself. What is the use of inheriting it?

Someone please explain.

Thanks in advance.

When I switched from c++ to java I had this same feeling but now that I been working with java for a while it all kinda makes sense.

1.what I thought about inheritance is having some methods in parent class, and whenever the same methods are needed in other class(es) too, then those class(es) will inherit the parent class and use it.

Like the original author did, you can still do multiple inheritance in java you just must use interfaces. Interfaces are like pure virtual classes in c++.

But in interface concept if each derived class(es) has to define its own implementation then what is the use of inheriting it?

The reason you implement an interface in java is so that you guarantee that class has those methods. That way you can have a specific class implement a generic interface and then treat every specific class that implements that generic interface the same.

Java Design is a bit different then c++ design but after doing several java program's you will become just as good at using multiple interfaces as you are at using multiple inheritance.

Each subclass has to define it's own implementation because each subclass may perform the operation slightly differently. Consider the following example:

public interface animal {
    //All implementers must define this method
    void speak();
}

This interface states that any Animal MUST have a way to speak. Basically, any type of animal is going to be able to make a noise. We then have 2 subclass, or 2 different types of animals that we create.

public class Dog implements animal {
    //Define how a Dog speaks
    public void speak() {
        System.out.println( "woof" );
    }
}

We then define another animal, cat

public class Cat implements animal {
    //Define how a Cat speaks
    public void speak() {
        System.out.println( "meow" );
    }
}

In this example, both Cat and Dog are animals, and therefore must be able to speak due to our interface. However, everybody knows that cats and dogs make different sounds. By allowing each subclass to define how it 'speaks', we can give Dog and Cat their own respective sound when the speak() method is called, while ensuring they are both Animals.

In answer to your question more specifically, inheritance forces it's subclasses to have a specific method. In other words, an interface states that "all my subclasses will define each of these methods". What this allows us to do is to write code that deals with the methods in an interface without knowing the specific subclass. We can safely do that because we know that each subclass MUST have defined the method in the interface class. If only the subclasses that use the method defined it, then we would have no way of knowing for sure whether it is safe to call the method on all subclasses.

Just a note: If you do not want a subclass to define the method, you can simply define an empty method like this:

public class MuteAnimal implements animal {
    //A MuteAnimal can't speak!
    public void speak() { }
}

Inheritance is often useless without polymorphism. It is really not easy to explain it all just in few sentences. My advices would be to look at interfaces for defining behavior (something like can-do relationship), and concrete inheritence for is-a relationships.

In the center of everything as you may learn is something called Single Responsibility Principle. This means that one class has one responsibility, if you are having more of them, you separate the class.

If you take your example, even the Pegasus isn't both horse and bird at the same time 100% percent. It would inherit the horse, but implement specific characteristics of the birds, which would be defined in interfaces, like Flyable for instance. You can say that birds have one way of flying common to them all, so inherit them from Bird. Pegasus is a little different, so that custom logic can be defined after you implement the Flyable interface with method Fly. Also, the example with horseNoise and birdNoise is little unrealistic, you want one method speak() which will due to internal class alhorithm perform certain action. What if that pegasus could talk? Would you have a method for each word?

Back to Flyable example, say you now have a video-game. Now you can have polimorphism for this: Lets say that in game earthquake happens. You want for each animal that can fly to go and fly. You have a collection of animals currently in game, so you write this:

foreach(Flyable flyableAnimal in animals)
    flyableAnimal.Fly();

You just rely on polimorphism ...

These were just some random thoughts, you can find far better examples online, hope this helps ...

If class A inherits from class B, that effectively means two things:

1. Class A can implicitly use all methods and properties of class B, and need only define that functionality which is in fact unique to class A.
2. Code which expects an object of type B will accept an object of type A.

Those two features of inheritance are in some sense orthogonal; one can imagine places where either could be useful without the other. Although derived classes can only have one parent class from which they gain implicit access to methods and properties, they may define an arbitrary number of interfaces for which they are substitutable.

Note that while some people insist that interfaces form a "has-a" rather than "is-a" relationship, I think it's better to think of them as saying something "is __able" or "is a __er", the point being that interfaces don't just define abilities, but define substitutability (i.e. "is a") in terms of ability.