web-dev-qa-db-fra.com

Classe abstraite vs interface

J'ai cherché autour de SO ainsi que le reste du Web pour trouver une bonne réponse, mais je n’en ai pas trouvé une que je comprenne vraiment. Je vais présenter ceci d’une manière différente et, espérons-le. les réponses aideront également les autres.

Autant que je sache, les deux concepts ont les mêmes règles, sauf qu'une classe abstraite est plus flexible en raison de la capacité d'implémentation de la méthode. De plus, je suis conscient que vous pouvez implémenter plusieurs interfaces et n’étendre que la même classe, mais je suis sûr qu’il existe plus de différences que les deux que j’ai mentionnées.

Veuillez regarder les deux extraits de code et donnez-moi un exemple de ce que je peux faire avec chacun de mes exemples pour que je veuille ou non utiliser l'autre.

Classe abstraite

abstract class Foo {
    abstract public function getValue();
    abstract public function setValue($value); 
}


class myObj extends Foo {
    function getValue() {

    }
    function setValue($value) {

    }
}

Interface

interface Foo {
    public function getValue();
    public function setValue($value);
}

class myObj implements Foo {
    function getValue() {

    }
    function setValue($value) {

    }
}
phpinterfaceabstract-classconceptual
57
nathanjosiah

Pour reprendre l'idée (globalement, pas en détail):

inheritance

est la notion de extend from something, et éventuellement ajouter une nouvelle fonctionnalité ou remplacer une fonctionnalité existante (pour procéder différemment). Mais en utilisant l'héritage, vous partagez une grande partie du code avec le parent. Vous êtes un parent + quelques autres choses.

interface

représente certaines capacités (nous disons qu'une classe est implémentant une interface pour dire qu'elle possède ces capacités). Une interface peut être implémentée par 2 classes complètement différentes et ne partageant pas leur code (à l'exception des méthodes qu'elles implémentent). Lorsque A et B implémentent l'interface C, A n'est pas un B et B n'est pas un A.

Et l'une des raisons de interface est en effet de permettre aux programmeurs de faire comme ils pourraient le faire avec plusieurs héritages, mais sans problèmes de plusieurs héritages.

Cette notion est utilisée dans certains langages de programmation tels que Java, PHP ...

29
MatRt

Résumé

Les classes abstraites se concentrent sur une sorte de similitude.

Les personnes sont considérées comme du type mammal et, en tant que telles, ne seraient pas considérées comme du type vehicle.

Interface

Les interfaces se concentrent sur la compilation de fonctions similaires.

Par exemple: Vous êtes un être humain et êtes de type mammal. Si vous voulez voler, vous devrez implémenter un flying Interface. Si vous voulez tirer en volant, vous devez également implémenter le gun Interface.

Voir les exemples ci-dessous:

abstract class Mammal {
      protected $age_;
      //below are functions I think all mammals will have,including people
      abstract public function setAge($age);
      abstract public function getAge();
      abstract public function eat($food);
}
class Person extends Mammal {
      protected $job_; //Person's feature
      public function setAge($age){
        $this->age_ = $age;
      }

      public function getAge(){
        return $this->age_;
      }

      public function eat($food){
        echo 'I eat ' ,$food ,'today';
      }

      //People only attribute
      public function setJob($job){
         $this->job_ = $job;
      }
      public function getJob(){
         echo 'My job is ' , $this->job_;
      }

}

//Now a person wants to fly, but they are typically not able to do so.
//So we implement an interface
interface Plane{
  public function Fly(); 
}

//I also want shoot enemy
interface Gun{
  public function shoot();
}

class Person2 extends Mammal implements Plane,Gun{

      protected $job_;//Person feature
      public function setAge($age){
        $this->age_ = $age;
      }
      public function getAge(){
        return $this->age_;
      }
      public function eat($food){
        echo '<br/>I eat ' ,$food ,' today<br/>';
      }
      //Only a person has this feature.
      public function setJob($job){
         $this->job_ = $job;
      }
      public function getJob(){
         echo 'My job is ' , $this->job_;
      }

      //-----------------------------------------
      //below implementations from interfaces function. (features that humans do not have).
      //Person implements from other class
      public function fly(){
        echo '<br/>I use plane,so I can fly<br/>';
      }
      public function shoot(){
        echo 'I use gun,so I can shoot<br/>';
      }
}

$People = new Person();
echo '<pre>';
print_r( get_class_methods('People'));
echo '</pre>';

echo '<pre>';
print_r( get_class_methods('People2'));
echo '</pre>';

$People2 = new Person2();
$People2->setAge(24);
echo $People2->getAge();
$People2->eat('Egg');
$People2->setJob('PHP devepop');
echo $People2->getJob();

$People2->fly();
$People2->shoot();
148
Liuqing Hu

En résumé, interface consiste à normaliser un ensemble de fonctions ， tandis que classe abstraite consiste à définir un squelette de base à partir duquel les classes doivent dériver.

22
user655000

J'avais déjà pensé à cela auparavant, et le mieux que je pouvais en conclure était que les interfaces sont une abstraction logiquement pratique d'une classe abstraite pure (c ++).

Pour ce qui est de la raison pour laquelle vous choisiriez des interfaces plutôt que des classes abstraites, je cite ( ne source c ++ mais les concepts sont les mêmes):

Notez qu'il est très tentant d'ajouter des données et des fonctions de membre concrètes à des classes de base abstraites pures. Cela doit être évité, en général c'est un signe que l'interface n'est pas bien factorisée. Les données et les fonctions de membre concrètes impliquent généralement une implémentation particulière et peuvent donc hériter de l'interface, mais ne doivent pas être cette interface. Au lieu de cela, s'il y a des points communs entre les classes concrètes, la création d'une classe abstraite qui hérite de son interface de la classe abstraite pure et définit les données communes et les fonctions membres des classes concrètes fonctionne bien.

En réalité, lors de l’utilisation d’interfaces, la première chose qui me vient à l’esprit est le découplage . Lors de l'utilisation d'une interface, l'utilisateur et la classe d'implémentation sont totalement découplés. La même chose s'applique lorsque vous utilisez une classe abstraite pure , qui est essentiellement une interface.

3
Mohamed Tarek