PHP Interface et Résumé des meilleures pratiques de classe pour l'héritage?

Lors de la définition de la structure et d'hériter de l'Interface et/ou Classe Abstraite, laquelle est la meilleure pratique? Et pourquoi? Voici 2 exemples:

Voici l'exemple pour [Interface] -> [Résumé] -> [Classe]

Interface DataInterface
{
    public function __construct($connection);
    public function connected();
    public function get();
}

Abstract class BaseData implements DataInterface
{
    protected $connection;

    public function __construct($connection)
    {
        $this->connection = $connection;
    }
}


class UserData extends BaseData
{
    public function exists()
    {
        return is_connected($this->connection);
    }

    public function get()
    {
        return get_data($this->connection);
    }
}

$oUserData = new UserData(new Connection());

Et voici l'exemple pour [Résumé] -> [Classe] sans l'Interface

Abstract class BaseData
{
    protected $connection;

    public function __construct($connection)
    {
        $this->connection = $connection;
    }

    abstract public function connected();
    abstract public function get();
}

class UserData extends BaseData
{
    public function exists()
    {
        return is_connected($this->connection);
    }

    public function get()
    {
        return get_data($this->connection);
    }
}

$oUserData = new UserData(new Connection());

Je suis en train de créer une petite application (peut grossir) et confus sur la façon de mettre en œuvre dans le début correctement.

Par ailleurs, c'est cette déclaration de __construct() avec le paramètre a de sens que dans l'Interface?

public function __construct($connection);

source d'informationauteur user702300 | 2013-12-06

9

Les classes abstraites définit une interface qui doit être mis en œuvre pour les héritiers de la classe abstraite. Une Interface de Construire définit une interface doit être implémentée par une classe qui implémente l'interface-la construction, la mise en œuvre de l'interface n'est pas limitée à une seule interface, alors que l'héritage de classe est couplé à une seule (résumé) de la classe.

Interfaces en PHP sont utilisées intentionnellement afin de permettre typehints d'un sous-ensemble limité de toute une classe d'interface. Il n'y a aucune raison pour qu'une interface sur les classes abstraites aslong leur récepteur de cas de leurs héritiers n'ont pas les utiliser ( avec typehinting ou logique d'identification sur instanceof /is_a ). Le plus précieux avantages de l'interface-les constructions sont la possibilité de remplacer une commune de mise en œuvre de l'une des interfaces avec une autre implémentation.

Dans le cas de votre BaseData-Exemple, je vous recommande de déposer l'idée abstraite et l'utilisation d'un trait et séparer les interfaces à la place.
```
trait connectionBrokerConstructor {
    protected $connection;

    public function isConnected()
    {
        return $this->connection instanceof Connection;
    }

    public function setConnection(Connection $connection)
    {
        $this->connection = $connection;
    }
}

interface connectable
{
    public function setConnection(Connection $connection);
    public function isConnected();
}

interface userDataRepositoryInterface
{
    public function get();
}

class UserData implements connectable, userDataRepositoryInterface
{
    use connectionBrokerConstructor;

    public function __construct(Connection $connect = null)
    {
        $this->setConnection($connection);
    }

    public function get()
    {
        return array('something');
    }
}
```
2

Vraiment les classes abstraites et les interfaces sont différentes.

Envisager une interface comme un contrat, il énonce les règles que les autres classes (mise en œuvre) doivent suivre.

Les classes abstraites d'autre part, sont plus comme des points de départ, d'autres classes peuvent construire, c'est pourquoi ils sont parfois appelés des classes de base.

------- Modifier avec un exemple

Je ne suis pas un expert sur ces choses, mais j'ai toujours tout fait interface -> class.

Par exemple, ici, est une interface simple:
```
interface AnimalInterface {

  public function all();

  public function findBySlug($slug);

}
```
Et ici, c'est la classe qui implémente cette interface (simplifié):
```
class AnimalEloquentRepository implements AnimalInterface {

  public function all()
  {
    return Animal::all();
  }

  public function findBySlug($slug)
  {
    return Animal::whereSlug($slug)->first();
  }

}
```
Je fais souvent avoir une classe de base, qui d'autres à s'étendre, mais je ne l'ai utilisé une fois une classe abstraite dans un monde réel de l'application, et qui a fini par être remplacé.

Je suis sûr qu'il ya de meilleures façons de faire les choses, mais cela a vraiment bien fonctionné pour moi dans le passé.
0

Ma réputation ne permet pas de commentaires, mais cette déclaration dans tr0y la réponse est trompeuse:

"Les classes abstraites définit une interface qui doit être mis en œuvre pour les héritiers de la classe abstraite."

L'une des principales différences entre une interface et une classe abstraite, c'est que vous êtes pas nécessaires pour mettre en œuvre tout des méthodes d'une classe abstraite une classe qui étend la classe. Il est assez commun pour la classe abstraite pour avoir des méthodes avec le comportement par défaut et ne fournirons à ces méthodes dans les héritiers si le comportement par défaut n'est pas ce que vous voulez.

D'autre part, vous sont besoin pour créer tous méthodes spécifiées dans une interface dans toute classe qui implémente cette interface.

Une autre différence est que les méthodes dans une interface ne peut pas avoir un corps, alors que les méthodes dans une classe abstraite doit avoir un corps.

Vous devez vous connecter pour publier un commentaire.