Interface VS de classe 100% abstraite

Le seul cas où une "classe 100% abstraite" peut être avantageuse sur une interface est dans des endroits où la stabilité de l'API est une préoccupation clé.

Si vous écrivez une API où d'autres personnes devraient implémenter votre interface, vous devez vous tenir à l'interface. Vous ne pouvez pas ajouter de méthodes à l'interface plus tard, car cela briserait tous les clients (vous devrez contourner cela en implémentant une deuxième interface et laisser votre code vérifier l'utilisation de l'utilisation avec l'instance de chèque et fournir une relèvement).

Si vous réalisez la même chose avec une classe, vous pouvez ajouter des méthodes (non abstraites) plus tard sans casser le client.

Je ne suis pas tout à fait sûr de savoir comment répondre à ce conceptuellement, mais dans la pratique, j'utilise des interfaces pour les raisons suivantes:

• Pour indiquer que différentes classes ont une interface partagée: que vous pouvez les manipuler / les utiliser de la même manière
• Vous pouvez implémenter plusieurs interfaces, mais n'élargir que une classe

  raisons d'utiliser des classes abstraites:

  • Pour partager la fonctionnalité entre des objets similaires. Par exemple, Porshe911 pourrait prolonger la voiture, écraser quelques méthodes et garder le reste.
  • Pour écrire des cadres que les gens peuvent s'adapter. Par exemple, en laissant quelques méthodes cruciales sans image et écrivant le reste de la classe à être cohérente en interne, vous devez mettre en œuvre ces quelques méthodes. Un exemple serait une classe de menus avec une seule méthode abstraite getMenuitems ()

    Votre exemple de la classe 100% abstrait semble insensé pour moi. Pour autant que je sache, cela en ferait une interface, avec la restriction supplémentaire que vous ne pouvez en avoir qu'un.

Voici un exemple simple qui peut être réalisé par interface uniquement.

interface P {
    void p();
}

interface Q {
    void q();
}       

interface R {
    void r();
}

class PQR implements P, Q, R {
    @Override
    public void p() {
        System.out.println("P");
    }

    @Override
    public void q() {
        System.out.println("Q");
    }

    @Override
    public void r() {
        System.out.println("R");
    }
}

class A {
    public void a(P pRef) {
        pRef.p();
    }
}

class B {
    public void b(Q qRef) {
        qRef.q();
    }
}

class C {
    public void c(R rRef) {
        rRef.r();
    }
}

public class InterfaceDemo {
    public static void main(String[] args) {
        P p = new PQR();
        A ainvoker = new A();
        ainvoker.a(p);

        Q q = new PQR();
        B binvoker = new B();
        binvoker.b(q);

        R r = new PQR();
        C cinvoker = new C();
        cinvoker.c(r);
    }
}