Résumé simple orienté objet PHP

Connaissances de base

Classe : Un ensemble de classes avec les mêmes attributs ou méthodes. Par exemple, les voitures Chevrolet sont une catégorie de voitures Chevrolet, les voitures Mercedes-Benz sont une catégorie de voitures Mercedes-Benz et les voitures BMW sont une catégorie de voitures BMW, et ces trois catégories sont des sous-catégories de la catégorie de voitures principale.
Objet : Une implémentation spécifique de la classe Par exemple, la BMW Q5 est une implémentation spécifique de la classe automobile BMW. Les objets sont stockés en mémoire. Jetons un coup d'œil à l'allocation des objets en mémoire.

Utiliser des moyens orientés objet pour utiliser les deux points de connaissance ci-dessus de manière flexible. Créons et utilisons des classes et des objets

<?php
    /**
    *新建一个类
    */
    class newClass{        public $a;        public $b;        public function funA(){            echo "I am function A";
        }        public function funB(){            echo "I am function B";
        }
    }    /**
    *使用类创建对象
    */
    $opt=new newClass();
    $opt->a="opt";//将opt对象中的a属性赋值为opt
    $opt->funA();//打印出"I am function A"?>

modificateurs : lors de la définition de classes et d'attributs dans les classes, nous pouvons utiliser les trois modificateurs suivants S'ils ne sont pas ajoutés, la valeur par défaut est public
public : maximum. permissions
protected : portée de l'autorisation en lui-même et ses sous-classes
private : portée de l'autorisation uniquement en lui-même
Constructeur et destructeur : Lorsque nous instancions une classe pour créer un objet, nous devons souvent initialiser l'objet. À ce stade, nous devons définir une méthode constructeur dans la classe. Lorsque nous avons fini d'utiliser l'objet, nous devons le libérer pour réduire l'utilisation de la mémoire. À ce stade, nous devons utiliser la méthode destructeur.
En php, nous utilisons la méthode __construct() et __destruct(), le code suivant

<?php
class newClass{
    public $a;
    public $b;
    public function __construct($a,$b){
        $this->a=$a;
        $this->b=$b;
        echo "我是构造函数";
    }
    public function __destruct(){
        echo "我是析构函数";
    }
}
?>

Encapsulation

Quand nous développons certains modules de programme importants, nous ne voulons souvent pas que d'autres puissent accéder facilement aux données de ces modules de programme, nous devons donc encapsuler les données. À l'heure actuelle, nous devons effectuer un contrôle d'accès aux données, souvent en utilisant private pour encapsuler ces propriétés et méthodes.
Comme suit :

<?php
class privateClass
{
    private $a;
    private $b;
    private function privateFun()
    {
        echo "我是封装的方法";
    }
} ?>

De cette façon, nous ne pouvons pas appeler de propriétés et de méthodes privées lorsque nous créons un objet. Mais nous pouvons accéder à ces propriétés et méthodes privées en utilisant des méthodes magiques.
L'utilisation de __set() et __get()
Grâce à la méthode __set(), nous pouvons directement définir les valeurs des attributs des membres via l'objet
Grâce à la méthode __get(), nous pouvons obtenir directement les valeurs d'attribut membre​​à travers l'objet

<?php
class setClass
{        
     private $a;        
    private $b="ww";        
    public function __set($oldValue,$newvalue){ 
        $this->$oldValue=$newvalue;
    }        
    public function __get($newvalue){            
        return $newvalue;
    }
}
    $opt= new setClass();
    $opt->a="sss";//直接设置私有属性值
    echo $opt->b;//直接读取私有属性值
?>

L'utilisation de __isset() et __unset()
Utilisez __isset() pour vérifier directement si les attributs privés de l'objet existent
Utiliser __unset() pour supprimer directement les attributs privés de l'objet

<?php
class issetClass
{
    private $a;
    private $b = &#39;www&#39;;
    function __isset($privateName)
    {
        if (isset($privateName)) {
            return 1;
        } else {
            return 0;
        }
    }
    function __unset($privateName)
    {
        echo "销毁" . $privateName;
    }
}
$opt = new issetClass();
echo isset($opt->$b);
var_dump(unset($opt->$b));?>

Héritage

Lorsque nous écrivons plusieurs classes, souvent plusieurs classes ont le même propriétés et méthodes. Afin de simplifier le code, nous introduisons l'héritage. Le concept de sous-classes peut hériter de certains attributs et méthodes de la classe parent, réduisant ainsi l'écriture de code redondante.

Comment écrire des classes héritées
Nous utilisons le mot-clé extends pour écrire des sous-classes

<?php
    class parentClass{
    }    
    class childClass extends parentClass{
    }    
?>

Comme ci-dessus, childClass est une sous-classe de parentClass PHP ne prend en charge que l'héritage unique, c'est-à-dire qu'il existe. une seule sous-classe. Classe parent, mais une classe parent peut avoir plusieurs sous-classes.

Réécrire la méthode de la classe parent
Lorsque la méthode de la classe parent ne peut pas satisfaire l'utilisation de la sous-classe, nous pouvons remplacer la méthode de la classe parent. Mais quand on veut utiliser la méthode de la classe parent dans la sous-classe, on peut utiliser la syntaxe suivante : parent:: nom de la méthode Plusieurs mots-clés importants

3.1 final

final peuvent modifier le. class Avec les méthodes, les attributs des membres ne peuvent pas être modifiés ;
Les classes modifiées par final ne peuvent pas être héritées et les méthodes modifiées avec final ne peuvent pas être remplacées dans les sous-classes

3.2 static

static peut modifier les propriétés des membres et les méthodes des membres, mais pas les classes ;
Les membres et les méthodes modifiés avec static peuvent être utilisés directement via la classe, en utilisant la syntaxe suivante : nom de la classe ::$nom de la propriété ou nom de la méthode (
 ); Lorsqu'il est utilisé dans une classe, utilisez la syntaxe suivante : self::$ nom d'attribut ou nom de méthode

3.3 const

Utilisez const pour déclarer des constantes dans une classe au lieu de définir (. );
Par exemple, const TT=90, lors de l'utilisation d'une constante, utilisez directement la syntaxe suivante self::constant name

3.4 instanceof

Utilisez ce mot-clé pour détecter si une instance est une certaine instance d'une classe.

3.5 trait

php ne peut effectuer qu'un seul héritage, mais il fournit également un moyen alternatif de réutiliser le code et de résoudre le problème de l'héritage unique.
Comme suit

<?php

trait testA
{
    function a()
    {
    }
}

trait testB
{
    function b()
    {
    }
}

class testC
{
    use testA, testB;

    function c()
    {
    }
} ?>

Technologie abstraite

Les méthodes et classes modifiées avec le mot-clé abstract sont appelées méthodes abstraites ou classes abstraites .
Déclaration de classes abstraites et de méthodes abstraites

<?php
abstract class testClass
{
$a;
$b;
    abstract function testFun();
    abstract function testFun1();
    public function optFun()
    {
        echo "抽象类中的抽象方法";
    }//抽象类可以有非抽象方法
}
class childClass extends testClass
{
    function testFun()
    {
        echo "子类中实现抽象方法";
    }
    function testFun1()
    {
        echo "子类实现抽象方法";
    }
}
abstract child1Class extends testClass
{
}//子类是抽象方法可以不实现父类的抽象方法?>

La technologie abstraite fournit une spécification pour la déclaration des sous-classes et limite l'instanciation de la classe (les classes abstraites ne peuvent pas être instanciées).

Technologie d'interface

L'interface est une classe abstraite spéciale Seules les classes abstraites et les constantes peuvent être déclarées dans l'interface
Déclaration de. interface d'utilisation de l'interface, implémentez l'interface à l'aide d'impléments, le modificateur ne peut être que le public par défaut
Une sous-classe peut hériter de plusieurs interfaces et hériter d'une classe parent en même temps

<?php
interface newInterface
{
    const V = 12;
    abstract function fun1();
    abstract function fun2();
}
interface newInterface1
{
    abstract function fun3();
    abstract function fun4();
}
class parentClass
{
    function fun5()
    {
        echo "fun5";
    }
}
class optClass extends parentClass implements newInterface, newINterface1
{
    function fun1()
    {
        echo "fun1";
    }
    function fun2()
    {
        echo "fun2";
    }
    function fun3()
    {
        echo "fun3";
    }
    function fun4()
    {
        echo "fun4";
    }
} ?>

Polymorphisme

Le polymorphisme en PHP nécessite qu'une classe soit héritée via plusieurs sous-classes. Si une méthode de classe est remplacée dans plusieurs sous-classes et implémente différentes fonctions, nous l'appelons polymorphisme.

Tutoriel recommandé : "Tutoriel PHP"

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!