Classes abstraites, interfaces objet, tutoriels de programmation d'instances et de contrats en PHP orienté objet

La programmation orientée objet (POO) est une architecture de programmation informatique. L'un des principes de base de la POO est qu'un programme informatique est composé d'une seule unité ou d'un seul objet pouvant fonctionner comme un sous-programme. La POO atteint les trois objectifs principaux du génie logiciel : la réutilisabilité, la flexibilité et l'évolutivité. Afin de réaliser l'opération globale, chaque objet peut recevoir des informations, traiter des données et envoyer des informations à d'autres objets. 1.

PHP 5 prend en charge les classes abstraites et les méthodes abstraites. Les classes définies comme abstraites ne peuvent pas être instanciées. Toute classe doit être déclarée abstraite si au moins une méthode qu'elle contient est déclarée abstraite. Une méthode définie comme abstraite déclare uniquement sa méthode appelante (paramètres) et ne peut pas définir son implémentation de fonction spécifique. Une classe peut être déclarée abstraite en utilisant le modificateur abstract dans sa déclaration.

On peut comprendre qu'une classe abstraite sert de classe de base et laisse des détails spécifiques aux successeurs. En faisant abstraction des concepts, vous pouvez créer des architectures évolutives dans vos projets de développement.

abstract class AbstractClass
{
    code...
}

Utilisez le mot-clé abstract pour définir des méthodes abstraites. Les méthodes abstraites conservent uniquement le prototype de la méthode (la signature après le corps de la méthode est supprimée de la définition de la méthode), qui comprend les niveaux d'accès, les mots-clés de fonction, les noms de fonction et les paramètres. Il ne contient pas ({}) ni aucun code entre parenthèses. Par exemple, le code suivant est une définition de méthode abstraite :

abstract public function prototypeName($protoParam);

Doit être la même que dans la classe parent (ou plus détendue). De plus, les méthodes d'appel doivent correspondre, c'est-à-dire que le type et le nombre de paramètres requis doivent être cohérents. 1.2. À propos des classes abstraites

Tant qu'une classe contient au moins une méthode abstraite, elle doit être déclarée comme une classe abstraite

Les instances de classes abstraites ne peuvent pas être créées à l'aide du nouveau mot-clé.
Les méthodes déclarées comme abstraites ne peuvent pas contenir de corps de fonction.
Si la classe étendue est également déclarée comme classe abstraite, vous n'avez pas besoin d'implémenter toutes les méthodes abstraites lors de l'extension de la classe abstraite. (Si une classe hérite d'une classe abstraite, elle doit également être déclarée abstraite lorsqu'elle n'implémente pas toutes les méthodes abstraites déclarées dans la classe de base.)
1.3 Utiliser des classes abstraites

<?php
abstract class Car
{    
    abstract function getMaxSpeend();
}
class Roadster extends Car
{
    public $Speend;
    public function SetSpeend($speend = 0)
    {
        $this->Speend = $speend;
    }
    public function getMaxSpeend()
    {
        return $this->Speend;
    }
}
class Street
{
    public $Cars ;
    public $SpeendLimit ;
    function construct( $speendLimit = 200)
    {
        $this -> SpeendLimit = $speendLimit;
        $this -> Cars = array();
    }
    protected function IsStreetLegal($car)
    {
        if ($car->getMaxSpeend() < $this -> SpeendLimit)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    public function AddCar($car)
    {
        if($this->IsStreetLegal($car))
        {
            echo &#39;The Car was allowed on the road.&#39;;
            $this->Cars[] = $car;
        }
        else
        {
            echo &#39;The Car is too fast and was not allowed on the road.&#39;;
        }
    }
}
$Porsche911 = new Roadster();
$Porsche911->SetSpeend(340);
$FuWaiStreet = new Street(80);
$FuWaiStreet->AddCar($Porsche911);
/**
 *
 * @result
 * 
 * The Car is too fast and was not allowed on the road.[Finished in 0.1s]
 *
 */
?>

Interface d'objet
À l'aide de l'interface, vous pouvez spécifier quelles méthodes une classe doit implémenter, mais vous n'avez pas besoin de définir le contenu spécifique de ces méthodes.

Les interfaces peuvent également être héritées, en utilisant l'opérateur extends.

Les constantes peuvent également être définies dans les interfaces. Les constantes d'interface sont utilisées exactement de la même manière que les constantes de classe, mais elles ne peuvent pas être remplacées par des sous-classes ou des sous-interfaces.
2.2 Cas d'utilisation d'interfaces


3.

<?php
abstract class Car
{    
    abstract function SetSpeend($speend = 0);
}
interface ISpeendInfo
{
    function GetMaxSpeend();
}
class Roadster extends Car implements ISpeendInfo
{
    public $Speend;
    public function SetSpeend($speend = 0)
    {
        $this->Speend = $speend;
    }
    public function getMaxSpeend()
    {
        return $this->Speend;
    }
}
class Street
{
    public $Cars ;
    public $SpeendLimit ;
    function construct( $speendLimit = 200)
    {
        $this -> SpeendLimit = $speendLimit;
        $this -> Cars = array();
    }
    protected function IsStreetLegal($car)
    {
        if ($car->getMaxSpeend() < $this -> SpeendLimit)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    public function AddCar($car)
    {
        if($this->IsStreetLegal($car))
        {
            echo &#39;The Car was allowed on the road.&#39;;
            $this->Cars[] = $car;
        }
        else
        {
            echo &#39;The Car is too fast and was not allowed on the road.&#39;;
        }
    }
}
$Porsche911 = new Roadster();
$Porsche911->SetSpeend(340);
$FuWaiStreet = new Street(80);
$FuWaiStreet->AddCar($Porsche911);
/**
 *
 * @result
 * 
 * The Car is too fast and was not allowed on the road.[Finished in 0.1s]
 *
 */
?>

instanceof instanceof Operator est une comparaison dans l'opérateur PHP5. Il accepte les paramètres gauche et droit et renvoie une valeur booléenne.

Vérifier si l'objet hérite d'un certain type

Déterminer si une variable n'est pas une instance d'un objet qui implémente une interface


4.

echo $Porsche911 instanceof Car;
//result：1
echo $Porsche911 instanceof ISpeendInfo;
//result：1

Design by Contract ou Design by Contract (DbC) est une sorte de méthode de conception de logiciels informatiques. Cette approche nécessite que les concepteurs de logiciels définissent des interfaces formelles, précises et vérifiables pour les composants logiciels. De cette manière, des conditions a priori, des conditions a posteriori et des invariants sont ajoutés au type de données abstrait traditionnel

Une pratique de programmation consistant à implémenter une interface déclarée avant d'écrire une classe. Cette méthode est très utile pour assurer l’encapsulation des classes. Grâce à des techniques de programmation contractuelle, nous pouvons définir la fonctionnalité d'une vue avant de créer une application, un peu comme un architecte dessine un plan avant de construire un bâtiment.

5.Résumé

Les classes abstraites sont des classes déclarées à l'aide du mot-clé abstract. En marquant une classe comme abstraite, nous pouvons différer l'implémentation des méthodes déclarées. Pour déclarer une méthode comme abstraite, supprimez simplement l’entité méthode contenant toutes les accolades et terminez la ligne de code où la méthode est déclarée par un point-virgule.

Les classes abstraites ne peuvent pas être instanciées directement, elles doivent être héritées.

Si une classe hérite d'une classe abstraite, elle doit également être déclarée abstraite lorsqu'elle n'implémente pas toutes les méthodes abstraites déclarées dans la classe de base.

Dans une interface, on peut déclarer un prototype de méthode sans corps de méthode, ce qui est très similaire à une classe abstraite. La différence entre elles est que les interfaces ne peuvent déclarer aucune méthode avec des corps de méthode et que la syntaxe qu'elles utilisent est également différente. Afin de forcer la découverte des règles sur une classe, nous devons utiliser le mot-clé Implements au lieu du mot-clé extends.

Dans certains cas, nous devons déterminer si une classe est un type d'une classe spécifique ou si elle implémente une interface spécifique. instanceof convient à cette tâche. instanceof vérifie trois choses : si l'instance est d'un type spécifique, si l'instance hérite d'un type spécifique et si l'instance ou l'une de ses classes ancêtres implémente une interface spécifique à la classe.

Certains langages ont la capacité d'hériter de plusieurs classes, c'est ce qu'on appelle l'héritage multiple. PHP ne prend pas en charge l'héritage multiple. L'idée est qu'il fournit la fonction de déclarer plusieurs interfaces pour une classe.

Les interfaces sont utiles pour déclarer les règles qu'une classe doit suivre. La technologie de programmation contractuelle utilise cette fonctionnalité pour améliorer l'encapsulation et optimiser le flux de travail.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!