Interface ou une Classe Abstraite: lequel utiliser?

Utiliser une interface lorsque vous voulez forcer les développeurs à travailler dans votre système (vous inclus) pour mettre en œuvre un certain nombre de méthodes sur les classes qu'ils vont construire.

Utilisation d'une classe abstraite lorsque vous voulez forcer les développeurs à travailler dans votre système (vous inclus) pour mettre en œuvre un ensemble de numéros de méthodes et vous voulez fournir certaines méthodes de base qui leur permettront de développer leurs classes enfant.

Une autre chose à garder à l'esprit est client de classes ne peut étendre une classe abstraite, alors qu'elles peuvent implémenter plusieurs interfaces. Donc, si vous êtes de la définition de votre comportement contrats dans les classes abstraites, cela signifie que chaque enfant de la classe ne peut être conforme à un contrat unique. Parfois, c'est une bonne chose, quand vous voulez que vos utilisateurs-programmeurs, le long d'un chemin particulier. D'autres fois, il serait mauvais. Imaginez si PHP est Dénombrable et Itérateur interfaces ont été les classes abstraites au lieu d'interfaces.

Une approche commune lorsque vous ne savez pas où aller (comme mentionné par cletus ci-dessous) est de créer une interface, et ensuite votre classe abstraite à implémenter cette interface.

Pourquoi utiliser les classes abstraites? Ce qui suit est un exemple simple. Disons que nous avons le code suivant:

<?php 

class Fruit {
    private $color;

    public function eat() {
        //chew
    }

    public function setColor($c) {
        $this->color = $c;
    }
}

class Apple extends Fruit {
    public function eat() {
        //chew until core
    }
}

class Orange extends Fruit {
    public function eat() {
        //peeling
        //chew
    }
}

Maintenant je vous donne une pomme et que vous en mangez.
Quel est son goût? Elle a le goût d'une pomme.

<?php 
$apple = new Apple();
$apple->eat();

//Now I give you a fruit.
$fruit = new Fruit();
$fruit->eat();

Ce n'est que le goût? Eh bien, il n'a pas beaucoup de sens, de sorte que vous ne devriez pas être en mesure de le faire. Ceci est accompli en faisant le Fruit de la classe abstraite ainsi que de la manger méthode à l'intérieur d'elle.

<?php 
abstract class Fruit {
    private $color;

    abstract public function eat(){}

    public function setColor($c) {
        $this->color = $c;
    }
}
?>

Une classe abstraite est juste comme une interface, mais vous pouvez définir des méthodes dans une classe abstraite, tandis que dans une interface elles sont abstraites. Les classes abstraites peuvent avoir à la fois vide et de travail/méthodes concrètes. Dans les interfaces, les fonctions qui y sont définies ne peut pas avoir un corps. Dans les classes abstraites, ils le peuvent.

Un exemple réel:

<?php 
abstract class person {

    public $LastName;
    public $FirstName;
    public $BirthDate;

    abstract protected function write_info();
}

final class employee extends person{

    public $EmployeeNumber;
    public $DateHired;

    public function write_info(){
        //sql codes here
        echo "Writing ". $this->LastName . "'s info to emloyee dbase table <br>";   
    }
}

final class student extends person{

    public $StudentNumber;
    public $CourseName;

    public function write_info(){
        //sql codes here
        echo "Writing ". $this->LastName . "'s info to student dbase table <br>";
    }
}

///----------
$personA = new employee;
$personB = new student;

$personA->FirstName="Joe";
$personA->LastName="Sbody";

$personB->FirstName="Ben";
$personB->LastName="Dover";

$personA->write_info();
//Writing Sbody's info to emloyee dbase table
$personB->write_info();
//Writing Dover's info to student dbase table 

Juste pour jeter ce dans le mélange, mais que Cletus mentionné à l'aide d'une interface en collaboration avec une classe abstraite, j'ai souvent utiliser l'interface pour préciser ma pensée du design.

Par exemple:

<?php
class parser implements parserDecoratorPattern {
    //...
}

De cette façon, n'importe qui à la lecture de mon code (et qui sait ce qu'est un Décorateur Modèle est) va savoir tout de suite une) comment je construis mon analyseur et b) être en mesure de voir quelles sont les méthodes utilisées pour mettre en oeuvre le décorateur modèle.

Aussi, et je suis peut-être hors de la base, ici, n'étant pas un Java/C++/etc programmeur, mais des types de données peuvent entrer en jeu ici. Vos objets sont d'un type, et quand vous les transmettre, à travers le type de questions par programmation. Le déplacement de vos contractable des éléments dans l'interface uniquement dicte les types, les méthodes de retour, mais pas le type de base de la classe qui l'implémente.

Il est tard et je ne peux pas penser à une meilleure psudo-exemple de code, mais va ici:

<?php
interface TelevisionControls {};
class Remote implements TelevisionControls {};
class Spouse implements TelevisionControls {};
Spouse spouse = new Spouse();
Remote remote = new Remote();
isSameType = (bool)(remote == spouse)

Aussi, tiens à ajouter ici que tout simplement parce que de tout autre langage OO a une sorte d'interfaces et d'abstraction trop ne signifie pas qu'ils ont le même sens et le but, comme en PHP. L'utilisation de l'abstraction/interfaces est légèrement différent, alors que les interfaces en PHP n'ont pas en réalité une fonction réelle. Ils ne sont utilisés pour la sémantique et le régime des raisons. Le point est d'avoir un projet bien souple que possible, évolutif et sûr pour les extensions futures, indépendamment de savoir si le développeur plus tard, a un tout autre plan de l'utilisation ou pas.

Si votre anglais n'est pas natif, vous risquez de recherche qu'Abstraction et les Interfaces sont en réalité. Et rechercher les synonymes de trop.

Et ce qui pourrait vous aider comme une métaphore:

INTERFACE

Disons, vous faites cuire un nouveau genre de gâteau avec des fraises et vous avez une recette décrivant les ingrédients et les étapes.
Seulement vous savez pourquoi c'est la dégustation si bien et vos invités comme il.
Ensuite, vous décidez de publier votre recette afin que d'autres personnes peuvent essayer le gâteau ainsi.

Le point ici est

- pour la rendre droite

- être prudent

- pour éviter que les choses qui pourraient aller mal (comme trop de fraises ou de quelque chose)

à garder, il est facile pour les gens qui essayent de sortir

- vous dire combien de temps est ce qu'il faut faire (comme stiring)

- dire les choses que vous POUVEZ faire, mais n'ONT pas d'

C'est exactement CE que décrit interfaces. Il est un guide, un ensemble d'instructions qui observent le contenu de la recette.
Même que si vous créez un projet en PHP et vous souhaitez fournir le code sur GitHub ou avec vos potes ou quoi que ce soit.
Une interface est ce que les gens peuvent faire et ce que vous ne devriez pas. Les règles qui l' - si vous désobéissez à l'un, l'ensemble de la construction sera brisé.

ABSTRACTION

Pour poursuivre cette métaphore ici... imaginez, vous êtes l'invité de temps à manger le gâteau. Ensuite, vous essayez le gâteau à l'aide de la recette maintenant.
Mais vous voulez ajouter de nouveaux ingrédients ou modifier/sauter les étapes décrites dans la recette. Alors, quelle est la prochaine étape? Plan d'une autre version de ce gâteau.
Cette fois-ci avec des baies noires et pas de la paille de baies et de plus de crème à la vanille...miam.

C'est ce que vous pourriez envisager une extension de l'original gâteau. En gros, vous faites une abstraction, par la création d'une nouvelle recette parce que c'est un ptit différents. Il a un peu de nouvelles mesures et d'autres ingrédients. Cependant, le black berry version a certaines parties que vous avez pris au cours de l'original - ce sont les étapes de base que chaque type de gâteau doit avoir. Comme ingrédients comme le lait - c'est ce Que chaque classe dérivée de a de.

Maintenant, vous voulez échanger des ingrédients et les étapes qui DOIVENT être définis dans la nouvelle version de ce gâteau. Ce sont méthodes abstraites qui doivent être définies pour le nouveau gâteau, car il devrait être un fruit dans le gâteau, mais qui? Si on prend les baies noires cette fois. Fait.

Là vous allez, vous avez étendu le gâteau, suivie de l'interface et abstrait, les étapes et les ingrédients de lui.

À ajouter à certains déjà d'excellentes réponses:

• Les classes abstraites laissez vous fournir un certain degré de mise en œuvre, les interfaces sont de purs modèles. Une interface ne peut définir fonctionnalité, il peut ne jamais le mettre en œuvre.

• Toute classe qui implémente l'interface s'engage à mettre en œuvre toutes les méthodes qu'il définit ou il doit être déclarée abstraite.

• Interfaces peuvent aider à gérer le fait que, comme Java, PHP ne supporte pas l'héritage multiple. Une classe PHP ne peut étendre un seul parent. Cependant, vous pouvez faire une classe promesse de mettre en œuvre autant d'interfaces que vous le souhaitez.

• type: pour chaque interface, il met en œuvre, la classe a sur le type correspondant. Parce que toute classe peut implémenter une interface (ou plusieurs interfaces),
  interfaces efficacement les types de jointure qui ne sont pas liés.

• une classe peut à la fois d'étendre une super-classe et de mettre en œuvre un nombre quelconque d'interfaces:

  class SubClass extends ParentClass implements Interface1, Interface2 {
      //...
  }

Veuillez expliquer lorsque je dois utiliser une interface et quand je dois utiliser la classe abstraite?

Utiliser une interface lorsque vous avez besoin de fournir seulement un modèle sans mise en œuvre, afin que jamais, et vous voulez vous assurer que toute classe qui implémente cette interface aura les mêmes méthodes que toute autre classe qui l'implémente (au moins).

Utilisation d'une classe abstraite lorsque vous souhaitez créer une fondation pour les autres objets (une partie construite de la classe). La classe qui étend la classe abstraite allons utiliser quelques propriétés ou des méthodes définies et mises en œuvre:

<?php
//interface
class X implements Y { } //this is saying that "X" agrees to speak language "Y" with your code.

//abstract class
class X extends Y { } //this is saying that "X" is going to complete the partial class "Y".
?>

Comment je peux changer ma classe abstraite à une interface?

Ici est un cas simplifié/exemple. Retirer tous les détails de mise en œuvre de sortir. Par exemple, changer votre classe abstraite à partir de:

abstract class ClassToBuildUpon {
    public function doSomething() {
          echo 'Did something.';
    }
}

à:

interface ClassToBuildUpon {
    public function doSomething();
}

Voulais juste ajouter un exemple de quand vous pouvez avoir besoin d'utiliser les deux. Je suis en train d'écrire un gestionnaire de fichier lié à un modèle de base de données dans un ERP.

• J'ai plusieurs classes abstraites qui gèrent la norme crud et aussi un peu la spécialité des fonctionnalités comme la conversion et de streaming pour les différentes catégories de fichiers.
• Le fichier de l'interface d'accès définit un ensemble commun de méthodes qui sont nécessaires pour obtenir, de stocker et de supprimer un fichier.

De cette façon, j'arrive à avoir plusieurs modèles pour différents fichiers et un ensemble de méthodes d'interface avec distinction claire. L'interface donne la bonne analogie pour les méthodes d'accès plutôt que de ce qu'aurait été avec une base de classe abstraite.

Plus bas sur la ligne quand je vais faire des adaptateurs pour les différents services de stockage de fichiers, cette mise en œuvre permettra à l'interface pour être utilisées ailleurs dans différents contextes.