Duplicata possible:
interface vs classe abstraite
Quel est l'avantage si j'utilise une classe abstraite en PHP?
Quel est le but si j'utilise une classe abstraite ou des interfaces?
Les deux créent simplement des noms de défenition sans corps
Quel est l'avantage si j'utilise une classe abstraite en PHP? je ne trouve rien de bon à ce sujet. Je pense que je peux facilement faire tout le travail sans utiliser la classe abstraite?
Vous pourriez, naturellement. Cependant, s'il existe de nombreux objets qui sont à peu près du même type, il peut être utile d'extraire des fonctionnalités communes dans une classe "de base", ce qui signifie que vous n'avez pas à dupliquer cette logique.
Il y a en fait deux raisons. La première raison, pour moi, serait que tous les descendants de votre classe abstraite ont le même type, et tous deux adhèrent exactement à la même interface. Cela signifie qu'un document PDF par exemple aura la même interface qu'un document docx, et le code client n'a pas à se soucier de l'objet qu'il manipule. Exemple court (en PHP).
<?php
abstract class Document {
protected $author;
public function __construct( $author ) {
$this->author = $author;
}
abstract public function render( );
public function author( ) {
return $this->author;
}
}
class PdfDocument extends Document {
public function render( ) {
// do something PDF specific here.
}
}
class DocxDocument extends Document {
public function render( ) {
// do something DOCX specific here.
}
}
class DocumentHandler {
public function handle( Document $document ) {
$this->log( 'Author has been read ' . $document->author( ) );
return $document->render( );
}
}
Tout d'abord; faites attention au fait que la classe DocumentHandler n'a aucune connaissance du type de document qu'elle gère réellement. Ça ne fait même pas attention. C'est ignorant. Cependant, il sait quelles méthodes peuvent être appelées, car l'interface entre les deux types de documents est la même. Ceci est appelé polymorphisme , et pourrait tout aussi facilement être réalisé avec l'implémentation d'une interface Document.
La deuxième partie est; si chaque document a un auteur, et que cet auteur est toujours demandé, vous pouvez copier la méthode dans le PdfDocument ainsi que dans le DocxDocument, mais vous vous dupliquez vous-même. Par exemple, si vous décidez que vous voulez que l'auteur écrive en majuscules et que vous changez return $ this-> author en ucwords ($ this-> author), vous devrez le faire autant de fois que vous ' J'ai copié cette méthode. En utilisant une classe abstraite, vous pouvez définir le comportement, tout en marquant la classe elle-même comme incomplète. Cela est très pratique.
J'espère que cela pourra aider.
Les classes abstraites vous aident lorsque vous avez de nombreuses classes qui ont les mêmes méthodes.
Exemple:
abstract class Foo {
public function foo1() {
//Do something
}
public abstract class foo2();
}
class Bar extends Foo {
public class foo2() {
//Do something
}
}
class Baz extends Foo {
}
Que va-t-il se passer:
new Foo();
, Foo
est abstrait.Bar.foo1()
et Baz.foo1()
, ils feront la même chose.Baz
n'implémente pas la méthode abstact foo2
.Exemple où c'est utile:
abstract class Shape {
public function display() { /* ... */ }
//...
}
class Circle extends Shape {
//...
}
class Rectangle extends Shape {
//...
}
//...
Vous voulez que chaque classe soit capable de display()
, mais il n'y a pas de "Shape" en soi.
Toutes les méthodes de la classe abstraite ne doivent pas être vides, il peut y avoir des méthodes de base (et des propriétés) avec lesquelles travailler. Par exemple - vous avez un e-shop et vous développez une classe abstraite pour importer des produits. La classe a un metod pour enregistrer les produits dans db, pour générer l'url du produit et une méthode abstraite pour récupérer les produits quelque part (qui doit donc être implémentée dans la classe étendue). L'interface n'a que des méthodes vides et aucune propriété (peut avoir des constantes cependant), donc il se peut qu'il n'y ait pas de logique réelle, juste des constantes de méthode, des noms de méthode et leurs modificateurs d'accès.
Comme son nom l'indique, le but d'une interface est de déclarer explicitement l'interface aux données et méthodes fournies par une classe et les instances, sans avoir besoin de coder ces méthodes tout de suite. L'exemple classique est celui des formes géométriques. Une telle interface pourrait définir une méthode qui produit l'aire d'une telle forme:
interface Shape {
public function getArea();
}
Il pourrait y avoir un certain nombre de classes différentes implémentant cette interface comme Circle
et Square
qui fourniraient différentes implémentations pour la méthode getArea()
. Vous pouvez alors implémenter une fonction qui affiche des informations sur n'importe quelle forme géométrique:
function displayInformation(Shape $shape) {
echo "The area of this shape is: " . $shape->getArea();
}
Vous pouvez passer n'importe quel objet implémenté l'interface Shape
à cette fonction, et l'interface garantit que la méthode getArea()
est présente.
Bien sûr, ces concepts pourraient être plus utiles dans les langages de programmation qui sont plus fortement typés que PHP.