Connaissance pratique de base de PHP orienté 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.
par 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.

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

②Encapsulation d'attribut + méthode set/get
Afin de contrôler le paramétrage et la lecture des attributs , vous pouvez privatiser les attributs et demander aux utilisateurs de les définir via les méthodes set/get que nous fournissons

 private $age;
 //set方法
 function setAge($age){
     $this->age=$age;
 }
 //get方法
 function getAge(){
     return $this->age;
 }

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

③Encapsulation d'attribut + méthode magique

private $age;
function __get($key){
return $this->$key;
}
function __set($key,$value){
$this->$key=$value;
}

$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 à _ _get () méthode;
$object->age=12; //Lors de la définition des attributs privés de l'objet, la méthode magique __set() est automatiquement appelée, et le nom et l'attribut définis les valeurs sont transmises Give __set() method;

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

4. Concernant la méthode magique d'encapsulation :
①__set($key,$value) : Lors de l'attribution de valeurs pour classer les 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 propriétés privées, qui ne sont pas détectées 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.

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

Lorsqu'il est détecté en externe à l'aide d'isset($object name->private property);, le __isset() ci-dessus sera automatiquement appelé Résultats retournés !

④__unset($key) : automatiquement appelé lorsque la fonction unset() est utilisée en externe pour supprimer des attributs privés
1 fonction __unset($key){ 2 unset($this -> ; $key); 3 }
Lorsque non défini($object name->private attribut); pour supprimer un attribut, transmettez automatiquement le nom de l'attribut à __unset() et remettez-le à cette méthode magique pour traitement.

继承的基础知识：

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::方法名();
所以，当子类继承父类时，需在子类的构造中的第一步，首先调用父类构造进行复制。

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

 

三、PHP关键字

 

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

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

 class Person{
     static $sex = "nan";
     function say(){
         echo self::$sex;
     }
 }

⑥静态属性是共享的，也就是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()函数返回的字符串；

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

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

 

二__antoload()

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

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

 

TroisSérialisation et désérialisation orientées objet (sérialisation et désérialisation)

1. Sérialisation : Le processus de conversion d'un objet en chaîne via une série d'opérations est appelé sérialisation.

　　　　　　　　　　　　　　　　　

2. Sérialisation inverse : Le processus de conversion l'insertion d'une chaîne sérialisée dans un objet est appelée désérialisation 3. Quand utiliser la sérialisation ?
①Quand des objets doivent être transmis sur le réseau
②Quand des objets doivent être conservés dans des fichiers ou des bases de données
4. implémenter la sérialisation et la désérialisation
Sérialisation : $str=serialize($zhangsan);
Désérialisation : $duixiang=unserialize ($str);
5. Méthode magique __sleep() :
① Lorsque l'objet est sérialisé, la fonction __sleep() sera automatiquement exécutée
②__sleep() ; nécessite de renvoyer un tableau. Les valeurs du tableau sont des attributs qui peuvent être sérialisés ; les attributs qui ne sont pas dans le tableau ne peuvent pas être sérialisés ; return array("name","age"); //Seuls les deux attributs nom/âge peuvent être sérialisés.
}

6. Méthode magique __wakeup()
① Appelée automatiquement lors de la désérialisation d'une méthode object_ _wakeup() ;
②Lorsqu'il est automatiquement appelé, il est utilisé pour réaffecter les nouveaux attributs d'objet générés par la désérialisation.

1 fonction
__wakeup(){
2 $this -> ; nom = "李思"; 3 } 四Contraintes de type

1. Contraintes de type : fait référence à l'ajout d'un type de données à une variable pour contraindre que la variable ne puisse être stockée que type de données correspondant.

(Cette opération est courante dans les langages fortement typés. En PHP, seules les contraintes de type pour les tableaux et les objets peuvent être implémentées)

2, Si la contrainte de type est une certaine classe, les objets de cette classe et les sous-classes de cette classe peuvent passer.
3.
En PHP, les contraintes de type ne peuvent apparaître que dans les paramètres formels des fonctions.

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

func(new Person()); √
func(new Student()); √
func("111"); ×

形如new Person();的形式，我们称其为"匿名对象";

※※※基类：父类    
※※※派生类：子类

五魔术方法小总结

1、__construct():构造函数，new一个对象时，自动调用。
2、__destruct():析构函数，当一个对象被销毁前，自动调用。
3、__get():访问类中私有属性时，自动调用。传递读取的属性名，返回$this->属性名
4、__set():给类的私有属性赋值时，自动调用。传递需要设置的属性名和属性值；
5、__isset():使用isset()检测对象私有属性时，自动调用。传递检测的属性名，返回isset($this -> 属性名);
6、__unset():使用unset()删除对象私有属性时，自动调用。传递删除的属性名，方法中执行unset($this -> 属性名);
7、__toString():使用echo打印对象时，自动调用。返回想要在打印对象时，显示的内容；返回必须是字符串；
8、__call():调用一个类中未定义或未公开的方法时，自动调用。传递被调用的函数名，和参数列表数组；
9、__clone():当使用clone关键字，克隆一个对象时，自动调用。作用是为新克隆的对象进行初始化赋值；
10、__sleep():对象序列化时，自动调用。返回一个数组，数组中的值就是可以序列化的属性；
11、__wakeup():对象反序列化时，自动调用。为反序列化新产生的对象，进行初始化赋值；
12、__autoload():需要在类外部声明函数。当实例化一个未声明的类时，自动调用。传递实例化的类名，可以使用类名自动加载对应的类文件。

 

六、抽象类和抽象方法

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

七、接口与多态

UneInterface

1. Est-ce une interface ?
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. ! !

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 la clé est utilisée Word, 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.

deuxPolymorphe

2. 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 remplace la méthode de la classe parent ; >③ La référence de la classe parent pointe vers l'objet de la 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!