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.

Classes abstraites en PHP

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.

1.1. Méthode abstraite

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 :

Lors de l'héritage d'une classe abstraite, la sous-classe doit définir toutes les méthodes abstraites de la classe parent en plus, le

abstract public function prototypeName($protoParam);

contrôle d'accès de celles-ci ; méthodes

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 méthodes déclarées comme abstraites doivent contenir le même ou un inférieur niveau d'accès.

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

<🎜. >2.

<?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.

Une interface est définie via le mot-clé interface, tout comme la définition d'une classe standard, mais toutes les méthodes qui y sont définies sont vides.

Toutes les méthodes définies dans l'interface doivent être publiques. C'est une caractéristique de l'interface.

Une interface est une structure de type classe qui peut être utilisée pour déclarer les méthodes qui doivent être déclarées pour implémenter une classe. Par exemple, les interfaces sont souvent utilisées pour déclarer une API sans définir comment implémenter l'API.

La plupart des développeurs choisissent de préfixer le nom de l'interface avec une lettre majuscule I pour la distinguer de la classe dans le code et la documentation générée.

2.1 Implémentation de l'interface (impléments)

Pour implémenter une interface, utilisez l'opérateur Implements (l'héritage d'une classe abstraite nécessite l'utilisation de différents mots-clés extends), et la classe doit implémenter toutes les méthodes définies dans l'interface . Sinon, une erreur fatale sera signalée. Une classe peut implémenter plusieurs interfaces. Utilisez des virgules pour séparer les noms de plusieurs interfaces.

Lors de l'implémentation de plusieurs interfaces, les méthodes des interfaces ne peuvent pas avoir le même nom.

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

Pour implémenter une interface, une classe doit utiliser des méthodes exactement les mêmes que celles définies dans l'interface. Sinon, une erreur fatale en résultera.

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]
 *
 */
?>

Type d'opérateur

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.

Déterminer si une variable PHP appartient à une instance d'une certaine classe CLASS

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

Vérifier si l'objet appartient à une instance d'une certaine classe

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


4.

Programmation contractuelle

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

. Le « contrat » ou « contrat » utilisé dans le nom de cette méthode est une métaphore car il s'apparente quelque peu à la situation d'un contrat commercial.

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!