Parlez de ma compréhension de l'orientation objet en php

Aujourd'hui, j'aimerais vous présenter la nature orientée objet de PHP. En parlant d'orientation objet, je dois mentionner l'orientation processus, car lorsque j'apprenais, je ne parvenais souvent pas à faire la distinction entre l'orientation objet et l'orientation processus.

La programmation orientée objet (POO) est. une compétence de base dans notre programmation. PHP5 fournit un bon support pour la POO. Comment utiliser les idées POO pour effectuer une programmation avancée de PHP est très utile pour améliorer les capacités de programmation PHP et planifier une bonne architecture de développement Web. Ci-dessous, nous utiliserons des exemples pour illustrer l'importance pratique et les méthodes d'application de l'utilisation de la POO de PHP pour la programmation.

Lorsque nous construisons habituellement un site Web avec un backend de base de données, nous considérerons que le programme doit être adapté à différents environnements d'application. Ce qui diffère des autres langages de programmation, c'est qu'en PHP, une série de fonctions spécifiques sont utilisées pour faire fonctionner la base de données (si vous n'utilisez pas l'interface ODBC). Bien que cela soit très efficace, l’encapsulation ne suffit pas. S'il existe une interface de base de données unifiée, nous pouvons l'appliquer à une variété de bases de données sans apporter aucune modification au programme, améliorant ainsi considérablement la portabilité et les capacités multiplateformes du programme.

Permettez-moi de vous présenter leurs différences :

L'orientation objet se concentre sur quel objet gère un problème.

Sa plus grande caractéristique est qu'il se compose de classes avec des attributs et des fonctions, et que des objets peuvent être obtenus à partir des classes pour résoudre des problèmes.

L'orientation processus se concentre sur le processus de résolution d'un problème. Sa plus grande caractéristique est qu’une série de processus sont utilisés pour résoudre ce problème un par un.

一、面向对象基础

1. Bases orientées objet

一Orienté objet

1. un cours ?
Une collection d'une série d'individus ayant les mêmes attributs (caractéristiques) et méthodes (comportement). Une classe est un concept abstrait.

2. Qu'est-ce qu'un objet ?
L'individu avec des valeurs d'attribut spécifiques obtenues à partir de la classe est appelé un objet. L'objet est un individu spécifique.
par exemple : humain Zhang San

3. Quelle est la relation entre les classes et les objets ?
Une classe est une abstraction d'un objet ! Les objets sont la réification des classes !
La classe indique uniquement les attributs de ce type d'objet, mais elle ne peut pas avoir de valeurs spécifiques, la classe est donc abstraite.
L'objet est un individu spécifique après avoir attribué tous les attributs de la classe.

2Déclaration et instanciation des classes

1. Comment déclarer une classe :

class nom de la classe {
modificateur d'accès $property[=valeur par défaut];
Méthode de fonction [Modificateur d'accès] (){}
}

2. Remarques sur la déclaration d'une classe :
①Le nom de la classe ne peut être composé que de lettres, de chiffres et de traits de soulignement. Il ne peut pas commencer par un chiffre et doit respecter la règle du gros chameau ;
②Le nom de la classe doit être modifié. avec classe, suivi du nom de la classe Il ne doit pas y avoir ();
③Les attributs doivent avoir des modificateurs d'accès et les méthodes ne peuvent pas avoir de modificateurs d'accès.

3. Appel d'objets instanciés et de méthodes d'attribut d'objet :
$object name = new class name(); //() Vous pouvez appeler des attributs et des méthodes depuis l'extérieur de la classe sans

 :
$object name-> $property name; //Utiliser -> Lors de l'appel d'attributs, le nom de l'attribut ne peut pas contenir le symbole $

Appel d'attributs et de méthodes au sein de la classe :
$this - > $ Nom de l'attribut ;

TroisConstructeur

1. Qu'est-ce qu'un constructeur ?
Le constructeur est une fonction spéciale dans une classe. Lorsque l'on utilise le mot-clé new pour instancier un objet, cela équivaut à appeler le constructeur de la classe.

2. Quelle est la fonction du constructeur ?
Lors de l'instanciation d'un objet, celui-ci est automatiquement appelé et utilisé pour attribuer des valeurs initiales aux propriétés de l'objet !

3. Comment écrire le constructeur :
①Le nom du constructeur doit être le même que le nom de la classe
[public] function Person($name){
$this -> name = $name;
}
②Utiliser méthode magique __construct
[public] function __construct($name){
$this -> >
4. Notes sur les constructeurs :
① La première façon d'écrire, le nom du constructeur doit être le même que la classe ! ! ! !
②Si une classe n'a pas de constructeur manuscrit, le système aura un constructeur de paramètre vide par défaut, vous pouvez donc utiliser new Person();
Si nous écrivez un constructeur avec Parameter constructor, il n'y aura plus de constructeur de paramètres vide, c'est-à-dire que new Person() ne peut pas être utilisé directement
La liste de paramètres dans () après Person doit répondre aux exigences ; du constructeur ! ! ! !
③Si les deux constructeurs existent en même temps, __construct sera utilisé.
5. Destructeur : __destruct() :

①Le destructeur est automatiquement appelé avant que l'objet ne soit détruit et libéré
②Le destructeur ne peut prendre aucun paramètre ;
③Le destructeur est souvent utilisé pour libérer des ressources, fermer des ressources, etc. après l'utilisation de l'objet.
6. Méthode magique :

PHP nous fournit une série de fonctions commençant par __. Ces fonctions n'ont pas besoin d'être appelées manuellement, sera automatiquement appelé au bon moment. Ce type de fonction est appelé magie et s'appelle une fonction magique.
exemple : la fonction __construct(){} est automatiquement appelée lorsqu'un nouvel objet est créé
la fonction __destruct(){} est automatiquement appelée lorsque l'objet est détruit
🎜>

Nous exigeons que, à l'exception des méthodes magiques, les fonctions et méthodes personnalisées ne puissent pas commencer par __.

Enfin, généralement pour les classes avec des fonctions plus complexes, nous les écrirons dans un fichier de classe séparé.

Le fichier de classe est nommé dans la même minuscule, en utilisant la méthode "nom de classe lowercase.class.php".

Lorsque vous utilisez cette classe dans d'autres fichiers, vous pouvez utiliser include pour importer ce fichier ".class.php".

二、封装和继承

1. Qu'est-ce que l'encapsulation ?
Utilisez des modificateurs d'accès pour privatiser les propriétés et les méthodes de la classe qui ne nécessitent pas d'accès externe pour réaliser le contrôle d'accès.

*Remarque : Il s'agit de mettre en œuvre le contrôle d'accès, et non de refuser l'accès. En d'autres termes, après avoir privatisé les attributs, nous devons fournir les méthodes correspondantes afin que les utilisateurs puissent traiter les attributs via les méthodes que nous fournissons.

2. Quel est le rôle de l'encapsulation ?
① Les utilisateurs ne se soucient que des fonctions que la classe peut fournir et ne se soucient pas des détails de l'implémentation des fonctions ! (Méthode d'encapsulation)
② Contrôlez les données de l'utilisateur, empêchez la définition de données illégales et contrôlez les données renvoyées à l'utilisateur (encapsulation d'attribut + méthode set/get)

3. Mettre en œuvre l'opération d'encapsulation ?
①Encapsulation de méthode
Pour certaines méthodes qui ne sont utilisées qu'à l'intérieur de la classe et ne sont pas fournies pour un usage externe, nous pouvons alors utiliser private pour de telles méthodes Processus de privatisation.

1 private function formatName(){} //这个方法仅仅能在类内部使用$this调用2 function showName(){3 $this -> formatName();4 }

②Encapsulation d'attribut + méthode set/get
Afin de contrôler le paramétrage et la lecture des attributs, vous pouvez Les attributs sont privatisés et l'utilisateur doit les définir via les méthodes set/get que nous fournissons

1 private $age;2 //set方法3 function setAge($age){4 $this->age=$age;5 }6 //get方法7 function getAge(){8 return $this->age;9 }

$Object->getAge();
$Object->setAge(12);

③Encapsulation d'attribut + méthode magique

    __get(  ->   __set(, ->= }

$Object->age; //Lors de l'accès aux propriétés privées de l'objet, la méthode magique __get() est automatiquement appelée et le nom de la propriété accédée est transmis à la méthode __get()
$Object->age=12; //Lors de la définition des attributs privés de l'objet, appelez automatiquement la méthode magique __set() et transmettez le nom et la valeur de l'attribut définis au __set( ) méthode ;

Remarque : dans la méthode magique, vous pouvez utiliser la structure de branche pour déterminer la différence entre $key et effectuer différentes opérations.

4. Méthodes magiques sur l'encapsulation :
①__set($key,$value) : lors de l'attribution de valeurs à la classe attributs privés Appel automatique, transmettez deux paramètres à la méthode lors de l'appel : le nom de l'attribut qui doit être défini et la valeur de l'attribut.
②__get($key,$value) : Appelé automatiquement lors de la lecture des attributs privés de la classe lors de l'appel, passez un paramètre à la méthode, le nom de l'attribut qui doit être lu ;
③__isset($key) : automatiquement appelé lorsque la fonction isset() est utilisée en externe pour détecter des attributs privés.
>>> Utilisez isset(); en dehors de la classe pour détecter les attributs privés, qui ne sont pas détectés par défaut. false
>>>Nous pouvons donc utiliser la fonction __isset(); pour renvoyer le résultat de la détection interne lorsqu'elle est automatiquement appelée.

1 function __isset($key){2 return isset($this -> $key);3 }

当外部使用isset($对象名->私有属性);检测时，将自动调用上述__isset()返回的结果！

④__unset($key):外部使用unset()函数删除私有属性时，自动调用；
 1 function __unset($key){ 2 unset($this -> $key); 3 } 
当外部使用unset($对象名->私有属性);删除属性时，自动将属性名传给__unset(),并交由这个魔术方法处理。

 

继承的基础知识：

1、如何实现继承？
给子类使用extends关键字，让子类继承父类；
class Student extends Person{}

2、实现继承的注意事项？
①子类只能继承父类的非私有属性。
②子类继承父类后，相当于将父类的属性和方法copy到子类，可以直接使用$this调用。
③PHP只能单继承，不支持一个类继承多个类。但是一个类进行多层继承。
class Person{}
class Adult extends Person{}
class Student extends Adult{}
//Student 类就同时具有了Adult类和Person类的属性和方法

3、方法覆盖(方法重写)
条件一： 子类继承父类
条件二：子类重写父类已有方法

符合上述两个条件，称为方法覆盖。覆盖之后，子类调用方法，将调用子类自己的方法。
同样，除了方法覆盖，子类也可以具有与父类同名的属性，进行属性覆盖。

如果，子类重写了父类方法，如何在子类中调用父类同名方法？

partent::方法名();
所以，当子类继承父类时，需在子类的构造中的第一步，首先调用父类构造进行复制。

1 function __construct($name,$sex,$school){2 partent::__construct($name,$sex);3 $this -> school = $school;4 }

 

三、PHP关键字

 

1、final
①final修饰类，此类为最终类，不能被继承！
②final修饰方法，此方法为最终方法，不能被重写！
③final不能修饰属性。

2、static
①可以修饰属性和方法，分别称为静态属性和静态方法，也叫类属性，类方法；
②静态属性，静态方法，只能使用类名直接调用。
使用"类名::$静态属性" , "类名::静态方法()"
Person::$sex;   Person::say();
③静态属性和方法，在类装载时就会声明，先于对象产生。
④静态方法中，不能调用非静态属性或方法；
非静态方法，可以调用静态属性和方法。
（因为静态属性和方法在类装载时已经产生，而非静态的属性方法，此时还没有实例化诞生）
⑤在类中，可以使用self关键字，代指本类名。

1 class Person{2 static $sex = "nan";3 function say(){4 echo self::$sex;5 }6 }

⑥静态属性是共享的，也就是new出很多对象，也是共用一个属性。

3、const关键字：
在类中声明常量，不能是define()函数！必须使用const关键字。
与define()声明相似，const关键字声明常量不能带$，必须全部大写！
常量一旦声明，不能改变。调用时与static一样，使用类名调用Person::常量。

4、instanceof操作符：
检测一个对象，是否是某一个类的实例。（包括爹辈，爷爷辈,太爷爷辈……）

$zhangsan instanceof Person;

 

【小总结】几种特殊操作符：

① .  只能连接字符串； "".""
② => 声明数组时，关联键与值["key"=>"value"]
③ -> 对象($this new出的对象)调用成员属性，成员方法；
④ :: ①使用parent关键字，调用父类中的同名方法：parent::say();
      ②使用类名(和self)调用类中的静态属性，静态方法，以及常量。

 

四、单例

Le mode singleton est également appelé mode monomorphe. Il est garanti qu'une classe ne peut avoir qu'une seule instance d'objet.

Points d'implémentation :
① Le constructeur est privé et le nouveau mot-clé ne peut pas être utilisé pour créer des objets.
② Fournissez des méthodes externes pour obtenir des objets et déterminez si l'objet est vide dans la méthode.
S'il est vide, créez l'objet et renvoyez-le ; s'il n'est pas vide, renvoyez-le directement.
③Les attributs de l'objet instance et la méthode d'obtention de l'objet doivent être statiques.
④ Après cela, les objets ne peuvent être créés qu'en utilisant les méthodes statiques que nous fournissons.
par exemple :$s1 = Singleton::getSingle();

5. Sérialisation d'objets et méthodes magiques

五、对象串行化和魔术方法

 

***关键词：clone与__clone、__antoload()、串行化与反串行化（序列化与反序列化）、类型约束、魔术方法小总结（12个）

 

一clone与__clone

1、当使用=讲一个对象，赋值给另一个对象时，赋的实际是对象的地址。
两个对象指向同一地址，所以一个对象改变，另一个也会变化。
eg: $lisi = $zhangsan;
2、如果想要将一个对象完全克隆出另一个对象，两个对象是独立的，互不干扰的，
则需要使用clone关键字；
eg: $lisi = clone $zhangsan; //两个对象互不干扰
3、__clone():
①当使用clone关键字，克隆对象时，自动调用clone函数。
②__clone()函数，类似于克隆时使用的构造函数，可以给新克隆对象赋初值。
③__clone()函数里面的$this指的是新克隆的对象
某些版本中，可以用$that代指被克隆对象，绝大多数版本不支持。
4、__toString()
当使用echo等输出语句，直接打印对象时调用echo $zhangsan;
那么，可以指定__toString()函数返回的字符串；

1 function __toString(){2 return "haha";3 }4 echo $zhangsan; //结果为：haha

5、__call()
调用类中未定义或未公开的方法时，会自动执行__call()方法。
自动执行时，会给__call()方法传递两个参数；
参数一：调用的方法名
参数二：（数组）调用方法的参数列表。

 

二__antoload()

①这是唯一一个不在类中使用的魔术方法；
②当实例化一个不存在的类时，自动调用这个魔术方法；
③调用时，会自动给__autoload()传递一个参数：实例化的类名
所以可以使用这个方法实现自动加载文件的功能。

1 function __autoload($className){2 include    "class/".strtolower($className).".class.php";3 }4 $zhangsan=new Person();//本文件内没有Person类，会自动执行__autoload()加载person.class.php文件

 

三面向对象串行化与反串行化（序列化与反序列化）

1、串行化：将对象通过一系列操作，转化为一个字符串的过程，称为串行化。

　　　　　（对象通过写出描述自己状态的数值来记录自己）

2、反串行化：将串行化后的字符串，再转为对象的过程，称为反串行化；
3、什么时候使用串行化？
①对象需要在网络中传输的时候
② 对象需要在文件或数据库中持久保存的时候
4、怎样实现串行化与反串行化
串行化：  $str=serialize($zhangsan);
反串行化：$duixiang=unserialize($str);
5、__sleep()魔术方法：
①当执行对象串行化的时候，会自动执行__sleep()函数；
②__sleep()函数要求返回一个数组，数组中的值，就是可以串行化的属性；不在数组中的属性，不能被串行化；
function __sleep(){
return array("name","age"); //只有name/age两个属性可以串行化。
}

6、__wakeup()魔术方法
①当反串行化对象时，自动调用__wakeup()方法；
②自动调用时，用于给反串行化产生的新对象属性，进行重新赋值。
 1 function __wakeup(){ 2 $this -> name = "李四"; 3 } 

四类型约束

1、类型约束：是指在变量时，加上数据类型，用于约束此变量只能存放对应的数据类型。
（这种操作常见于强类型语言，在PHP中，只能实现数组和对象的类型约束）
2、如果类型约束为某一个类，则本类以及本类的子类对象，都可以通过。
3、在PHP中，类型约束，只能发生在函数的形参中。

1 class Person{}2 class Student extends Person{}3 function func(Person $p){ //约束函数的形参，只接受Person类及Person子类4 echo "1111";5 echo $p -> name;6 }

func(nouvelle personne()); √
func(nouvel étudiant()); √
func("111"); 🎜>

※※※Classe de base : classe parent

※※※ Classe dérivée : sous-classe

Cinq

Petit résumé des méthodes magiques 1. __construct() : Constructeur, lors de la création d'un objet, automatiquement appelé.

2. __destruct() : destructeur, appelé automatiquement avant la destruction d'un objet.
3. __get() : automatiquement appelé lors de l'accès aux propriétés privées de la classe. Passez le nom de l'attribut lu et renvoyez $this->Nom de l'attribut
4 __set() : automatiquement appelé lors de l'attribution d'une valeur à un attribut privé de la classe. Transmettez le nom de l'attribut et la valeur de l'attribut qui doivent être définis ;
5. __isset() : automatiquement appelé lors de l'utilisation d'isset() pour détecter les attributs privés de l'objet. Transmettez le nom de l'attribut détecté et retournez isset($this -> nom de l'attribut);
6. __unset() : automatiquement appelé lors de l'utilisation d'unset() pour supprimer les attributs privés de l'objet. Transmettez le nom de l'attribut supprimé et exécutez unset($this -> nom de l'attribut);
7 __toString() : automatiquement appelé lors de l'utilisation de echo pour imprimer l'objet. Renvoie le contenu que vous souhaitez afficher lors de l'impression de l'objet ; le retour doit être une chaîne
8. __call() : Appelé automatiquement lors de l'appel d'une méthode non définie ou non publiée dans une classe. Transmettez le nom de la fonction appelée et le tableau de la liste des paramètres ;
9. __clone() : automatiquement appelé lors du clonage d'un objet à l'aide du mot-clé clone. La fonction consiste à initialiser et à attribuer des valeurs à l'objet nouvellement cloné ;
10. __sleep() : automatiquement appelé lorsque l'objet est sérialisé. Renvoie un tableau, et les valeurs du tableau sont des attributs qui peuvent être sérialisés ;
11 __wakeup() : automatiquement appelé lorsque l'objet est désérialisé. Pour désérialiser l'objet nouvellement généré, effectuez une affectation d'initialisation ;
12. __autoload() : La fonction doit être déclarée en dehors de la classe. Appelé automatiquement lorsqu'une classe non déclarée est instanciée. En transmettant le nom de classe instancié, le fichier de classe correspondant peut être automatiquement chargé en utilisant le nom de classe.

6. Classes abstraites et méthodes abstraites

1. Qu'est-ce qu'une méthode abstraite ?
Les méthodes sans corps de méthode {} doivent être modifiées avec le mot-clé abstract. De telles méthodes sont appelées méthodes abstraites.
fonction abstraite say(); //Méthode abstraite

2.
Une classe modifiée avec le mot-clé abstract est une classe abstraite.
classe abstraite Personne{}

3. Notes sur les classes abstraites :
① Les classes abstraites peuvent contenir des éléments non abstraits. classes Méthode ;
② La classe contenant la méthode abstraite doit être une classe abstraite, et la classe abstraite ne doit pas nécessairement contenir une méthode abstraite
③ La classe abstraite ne peut pas être instancié. (Les classes abstraites peuvent contenir des méthodes abstraites. Les méthodes abstraites n'ont pas de corps de méthode et les appels d'instanciation n'ont aucun sens)
Le but de l'utilisation de classes abstraites est de limiter l'instanciation ! ! !

4. Si une sous-classe hérite d'une classe abstraite, alors la sous-classe doit remplacer toutes les méthodes abstraites de la classe parent, sauf si la sous-classe est également une classe abstraite.

5. Quel est le rôle de l'utilisation de classes abstraites ?
① Limiter l'instanciation. (Une classe abstraite est une classe incomplète. La méthode abstraite à l'intérieur n'a pas de corps de méthode, elle ne peut donc pas être instanciée)
② La classe abstraite fournit une spécification pour l'héritage des sous-classes, et les sous-classes héritent d'une abstraction La classe doit contenir et implémenter les méthodes abstraites définies dans la classe abstraite.

7. Interfaces et polymorphisme

七、接口与多态

table >

一Interface

1. ?
Une interface est une spécification qui fournit un ensemble de combinaisons de méthodes qui doivent être implémentées par une classe qui implémente l'interface.
L'interface est déclarée à l'aide du mot-clé interface
interface Inter{}

2. >Interface Toutes les méthodes doivent être des méthodes abstraites.
Les méthodes abstraites dans les interfaces n'ont pas besoin et ne peuvent pas être modifiées avec abstract.

3. Les variables ne peuvent pas être déclarées dans l'interface, et il ne peut pas y avoir d'attributs. Seules les constantes peuvent être utilisées ! ! !

4. Les interfaces peuvent hériter des interfaces, en utilisant le mot-clé extends ! L'interface
utilise l'interface extends pour implémenter l'héritage multiple.
interface int1 extends Inter,Inter2{}

5 La classe peut implémenter l'interface, utilisez le mot-clé Implements !
La classe utilise des implémentations pour implémenter l'interface, qui peut implémenter plusieurs interfaces en même temps. Plusieurs interfaces sont séparées par des virgules
classe abstraite Person implémente Inter, Inter2{}
Une classe implémente une ou plusieurs interfaces, alors cette classe doit implémenter toutes les méthodes abstraites dans toutes les interfaces !
À moins que cette classe soit une classe abstraite.

[Différence entre interface && classe abstraite] :

① En termes de méthode de déclaration, l'interface utilise le mot-clé interface et la classe abstraite utilise la classe abstraite . ②En termes d'implémentation/d'héritage, une classe utilise extends pour hériter d'une classe abstraite et implémente pour implémenter l'interface.
③Les classes abstraites ne peuvent être héritées qu'individuellement, tandis que les interfaces peuvent être implémentées de plusieurs manières. (L'interface étend l'interface), implémentations multiples (la classe implémente l'interface)
④ Les classes abstraites peuvent avoir des méthodes non abstraites, les interfaces ne peuvent avoir que des méthodes abstraites, pas des méthodes abstraites. Les méthodes abstraites des classes abstraites doivent être modifiées avec le mot-clé abstract, et les méthodes abstraites des interfaces ne peuvent pas être modifiées avec des modificateurs.
⑤Une classe abstraite est une classe qui peut avoir des attributs et des variables ; une interface ne peut avoir que des constantes.

IIPolymorphisme

II. Polymorphisme
1. Une classe est héritée par plusieurs sous-classes.
Si une méthode de cette classe affiche différentes fonctions dans plusieurs sous-classes, nous appelons cela polymorphisme de comportement.

2. Moyens nécessaires pour obtenir le polymorphisme :
① La sous-classe hérite de la classe parent
② La sous-classe réécrit la classe ; méthode de classe parent ;
③ La référence de la classe parent pointe vers l'objet de sous-classe

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!