Quand dois-je utiliser les interfaces au lieu des classes abstraites ?

Question

Je me demandais quand je devais utiliser les interfaces.

Réfléchissons à ce qui suit :

public abstract class Vehicle {
   abstract float getSpeed();
}

et :

public interface IVehicle {
  float getSpeed();
}

Je peux facilement mettre en œuvre les deux, ils ont la même fonctionnalité... MAIS je peux aussi ajouter quelques variables à ma classe de véhicule, qui devraient probablement être utilisées dans un véhicule (maxSpeed, carType...)

Quelle est la raison d'utiliser des interfaces ?

Merci !

EDITAR: J'ai trouvé un lien intéressant à ce sujet dans un autre fil de discussion : http://www.thecoldsun.com/en/content/01-2009/abstract-classes-and-interfaces

Answer 1

Classe abstraite : Utilisez-le quand il y a une forte relation is-a entre la super classe et la sous-classe et que toutes les sous-classes partagent un comportement commun.

Interface : Il définit simplement le protocole que toutes les sous-classes doivent suivre.

Answer 2

Les interfaces et les classes abstraites semblent très similaires, mais il existe des différences importantes entre elles.

L'abstraction est basée sur un bon " est un relation ". Cela signifie que vous diriez qu'une voiture est une Honda, et qu'une Honda est une voiture. Utiliser l'abstraction sur une classe signifie que vous pouvez également avoir des méthodes abstraites. Cela signifie que toute sous-classe étendue à partir de cette classe doit obtenir les méthodes abstraites et les remplacer. Dans l'exemple ci-dessous, nous pouvons créer une méthode abstraite howToStart() ; qui devra être implémentée par chaque classe.

Grâce à l'abstraction, nous pouvons fournir des similitudes entre les codes, de sorte que nous aurons toujours une classe de base. En utilisant un exemple de l'idée de la classe Car, nous pourrions créer :

public abstract class Car{
    private String make;
    private String model

    protected Car() { }  // Default constructor

    protect Car(String make, String model){
        //Assign values to 
    }

    public abstract void howToStart();
}

Ensuite, avec la classe Honda, nous aurions :

public class Honda extends implements Engine {

    public Honda() { }  // Default constructor

    public Honda(String make, String model){
        //Assign values
    }

    @Override
    public static void howToStart(){
        // Code on how to start
    }

}

Les interfaces sont basées sur la relation "has-a". Cela signifie que vous pouvez dire qu'une voiture a un moteur, mais qu'un moteur n'est pas une voiture. Dans l'exemple ci-dessus, Honda a implements Engine .

Pour l'interface du moteur, nous pourrions créer :

public interface Engine {
    public void startup();
}

L'interface fournira une instance many-to-one. Nous pouvons donc appliquer l'interface Engine à n'importe quel type de voiture. Nous pouvons également l'étendre à d'autres objets. Par exemple, si nous devions créer une classe de bateau et avoir des sous classes de types de bateaux, nous pourrions étendre Engine et faire en sorte que les sous classes de bateaux requièrent l'interface startup(); méthode. Les interfaces permettent de créer un cadre pour différentes classes qui ont des similitudes. Nous pouvons également mettre en œuvre plusieurs instances dans une seule classe, par exemple :

public class Honda extends implements Engine, Transmission, List<Parts>

J'espère que cela vous aidera.