Why are interfaces helpful?

Question

I know exactly what are the differences between Interfaces and Abstract classes, but why are Interfaces helpful? look at this :

Answer 1

Now imagine abstractions Point and Circle. How would you achieve that a MovablePoint is both Movable and Point? Only interfaces can give you that, and that's what they are here for.

Answer 2

see HERE

• An abstract class is good if you think you will plan on using inheritance since it provides a common base class implementation to derived classes.
• An abstract class is also good if you want to be able to declare non-public members. In an interface, all methods must be public.
• If you think you will need to add methods in the future, then an abstract class is a better choice. Because if you add new method headings to an interface, then all of the classes that already implement that interface will have to be changed to implement the new methods. That can be quite a hassle.
• Interfaces are a good choice when you think that the API will not change for a while.
• Interfaces are also good when you want to have something similar to multiple inheritance, since you can implement multiple interfaces.

SO in your scenario only with interfaces you can specify if a MovablePoint is both Movable and Point.

Answer 3

Imagine someone using your library wants to introduce something other usable, such as a MovableTirangle. If they let this implement Movable, it can be perfectly used with your library.

For example, the library provides a

void move(Movable m, int horiz, int vert) {
    int i;
    if (horiz >= 0) {
        for (i=0; i < horiz; i++) {
            m.moveRight();
        }
    } else {
        for (i=0; i > horiz; i--) {
            m.moveLeft();
        }
    }
    if (vert >= 0) {
        for (i=0; i < vert; i++) {
            m.moveUp();
        }
    } else {
        for (i=0; i > vert; i--) {
            m.moveDown();
        }
    }
}

which can be used with all current and future kinds of Movables.

Until now, this is valid for base classes as well, so that doesn't really count.

But, as Java doesn't support multiple inheritance, a class cannot inherit from more than one base class. But it can implement more than one interface, if this should be needed.

Besides, if you had a functional interface (which you haven't, because you have more than one non-default function in it), you could additionally make use of the new lambda feature of Java. That's another thing which doesn't work with abstract classes.

Answer 4

Yes--in this instance you could have, but try looking at the bigger picture, too. I asked the same question when I first learning OOP and interfaces confused me for a long time.

What if you wanted to add the 'movable' methods to an object that wasn't a subclass of Point, let's say 'MovableJPEG' or some such thing. The end result of the move actions would be the same, but you'd have to rewrite the interface for both classes and different methods to handle moving these features around in classes that interacted with Movable objects.

With an interface you pass a any number of Types related only by having a similar interface to the same method because their implementation details are guaranteed to be the same.

Answer 5

Both interfaces and abstract classes allow a programmer to write modular classes.

The advantage of an interface over an abstract class is that it does not carry any predefined methods or properties with it. An abstract class may have things that you do not want implemented inside of your class.

A second advantage is that a java class can only extend one class, but a large number of interfaces.

Interfaces provide more freedom, where an abstract class can influence the internal design of a class. One advantage of an abstract class is code sharing, which is more difficult with interfaces.

Answer 6

1. you do not have multiple inheritance in java. so multiple classes cant be inherited in same class but multiple interfaces can be implemented
2. helps in keeping things organized. Like all the things related to DOG is under one interface, all CATs under CAT and so on.
3. Runtime polymorphisim : with interface u can have superclass reference variable referring different different sub classes. This helps in keeping code clean, improves scalability ( makes possible all those bridge/proxy/factory etc design patterns which otherwise might not have been there).

Answer 7

Conceptual Difference:

I will not list all the differences between using interfaces or abstract classes or when to use each of them, I think you will find a lot of resources in the web and SO talking only about that, as an example: How should I have explained the difference between an Interface and an Abstract class?

To answer you, Yes, you can use only abstract class in your example and you don't have to use an interface

But, there is a Conceptual Difference, Interfaces are not created to expose public behavior, it's a contract for what a class can do. While abstract classes are parent of a hierarchy to produce children having core structure and providing default behavior.

Analogy with your example:

Conceptually, Movable must be an Interface because it defines what a class that implements Movable can do (can move up, move down, move...) and not how to do it (Circle dosn't move like Rectangle). While your MovableCircle could be an abstract class because we can define methods like : calculateArea(), getRadius(), calculateCircumference(), ... Which is a default behavior for classes that will inherit from it like MovableWheel.

.

Answer 8

Let you are trying to give as set of similar property to some unrelated classes. Then you may use interface. For example -

       <Bounceable>
        /     \
      Ball    Tire 

Here Ball and Tire (of a car) are totally unrelated. But both of them are Bounceable. If you want two unrelated class to have the same property then you can use interface.

There is another important use of interface - giving the flavor of multiple inheritance but with more efficiently than multiple inheritance (where there is a common Deadly Diamond of Death problem.). For example you are expecting a Ball should be both Bouncable and Serializeable. Here Bouncable and Serializeable are totally unrelated of each other. Then you can use interface here. Abstract class need to be extended/inherited and in java multiple inheritance is not possible. So we can provide completely unrelated property to a class by using interface.

Answer 9

IMO while it's correct when people explain interface as a contract i.e. an obligation to implement method signature, i find that they often forget to mention the use of interface as type for the whole group of objects that implement that same interface, and i believe that to be important piece of the puzzle, understanding the usefulness of interface.

Here is a code example (C#) with Cat and Dog classes that uses both interface and absctract class, which hopefully should higlight differences between them.

Assumption 1: both animals say sounds, but these are different sounds (different methods needed) Assumption 2: both animals can eat, if they are not full (here one method is needed for both animals)

static void Main(string[] args)
    {
        IanimalBehavior pluto = new Dog();
        IanimalBehavior simba = new Cat();

        Program.makeAnimals_say_and_eat(pluto);
        Program.makeAnimals_say_and_eat(simba);

        Program.makeAnimals_say_and_eat(pluto);
        Program.makeAnimals_say_and_eat(simba);
        Console.ReadLine();
    }

    static void makeAnimals_say_and_eat(IanimalBehavior animalObject)
    {
        Console.WriteLine(animalObject.makeSound());
        Console.WriteLine(animalObject.eat());
    }

    interface IanimalBehavior {
       string makeSound();
       string eat();
    } 

    class Dog : Animal, IanimalBehavior {            

        public string makeSound() {
            return this.GetType().Name + " says: wuf";
        }
    }

    class Cat : Animal, IanimalBehavior {

        public string makeSound()
        {
            return this.GetType().Name + " says: miauw";
        }
    }

    abstract class Animal {

        bool _isFull = false;
        public string eat()
        {
            if (_isFull == false)
            {
                _isFull = true;
                return this.GetType().Name + " is now eating";
            }
            else
            {
                return this.GetType().Name + " is now too full to eat!";
            }
        }
    }

Notice that animals are declared as interface types:

IanimalBehavior pluto = new Dog();

This will ensure that the method makeAnimals_say_and_eat() can take a parameter type that targets both types of objects (Cat & Dog), so only one method is needed for all animals which is what we want.

static void makeAnimals_say_and_eat(IanimalBehavior animalObject)
    {
        Console.WriteLine(animalObject.makeSound());
        Console.WriteLine(animalObject.eat());
    }

The method calls .makeSound() and .eat() from any object that is passed as parameter. Compiler is happy because it knows that any IanimalBehavior type must include both methods because it says so in the contract:

interface IanimalBehavior {
       string makeSound();
       string eat();
    } 

on .makeSound() the return value depends on the class type while .eat() is the same for both classes because eat() is declared in absctract class Animal that all animals inherit from.

the ouput of these instructions:

Program.makeAnimals_say_and_eat(pluto);
Program.makeAnimals_say_and_eat(simba);

Program.makeAnimals_say_and_eat(pluto);
Program.makeAnimals_say_and_eat(simba);

are:

Dog says: wuf
Dog is now eating
Cat says: miauw
Cat is now eating
Dog says: wuf
Dog is now too full to eat!
Cat says: miauw
Cat is now too full to eat!

Interface types also gives you the option of storing different objects of similar nature (same interface implemetation) in a single array which you then can iterate.

IanimalBehavior[] animal_list = { new Dog(), new Cat()};

foreach (IanimalBehavior animal in animal_list)
       {
           Console.WriteLine(animal.eat());
           Console.WriteLine(animal.makeSound());
       }