Vous guide de manière complète pour comprendre et apprendre les trois fonctionnalités de base de l'encapsulation orientée objet PHP, de l'héritage et du polymorphisme.

La programmation orientée objet (POO) est une compétence de base dans notre programmation, et PHP5 offre 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.

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.

Ci-dessous, notre site Web php chinois vous amènera à bien comprendre les trois fonctionnalités de base du PHP orienté objet  : l'encapsulation, l'héritage et le polymorphisme.

Vous pouvez regarder les cours vidéo pertinents sur notre site Web PHP chinois : Chapitre 10 Classes et objets en PHPConférence approfondie : Cette temps ce sera un incontournable Si vous voulez comprendre

vous pouvez aussi lire le manuel PHP chinois : Tutoriels sur les cours et objets

Les trois caractéristiques majeures du PHP orienté objet : l'héritage, l'encapsulation, le polymorphisme

La soi-disant encapsulation, également, consiste à encapsuler des éléments objectifs dans des classes abstraites, et la classe ne peut permettre qu'à des classes ou des objets de confiance d'exploiter ses propres données et méthodes, et de cacher des informations à des objets non fiables.

L'encapsulation est l'une des caractéristiques de l'orientation objet et constitue la principale caractéristique des concepts d'objet et de classe. En termes simples, une classe est une entité logique qui encapsule des données et du code qui opère sur ces données. Au sein d'un objet, certains codes ou certaines données peuvent être privés et inaccessibles au monde extérieur. De cette manière, les objets offrent différents niveaux de protection pour les données internes afin d'empêcher des parties non liées du programme de modifier accidentellement ou d'utiliser incorrectement les parties privées de l'objet.

Le soi-disant héritage fait référence à une méthode qui permet à un objet d'un certain type d'obtenir les propriétés d'un objet d'un autre type. Il prend en charge le concept de classification hiérarchique.

L'héritage fait référence à la possibilité d'utiliser toutes les fonctionnalités d'une classe existante et d'étendre ces fonctionnalités sans avoir à réécrire la classe d'origine. La nouvelle classe créée par héritage est appelée « sous-classe » ou « classe dérivée », et la classe héritée est appelée « classe de base », « classe parent » ou « super classe ». Le processus d'héritage est le processus du général au spécial. Pour obtenir l'héritage, vous pouvez y parvenir via « Héritage » et « Composition ». Il existe deux types de manières d'implémenter le concept d'héritage : l'héritage d'implémentation et l'héritage d'interface. L'héritage d'implémentation fait référence à la possibilité d'utiliser directement les propriétés et méthodes d'une classe de base sans codage supplémentaire ; l'héritage d'interface fait référence à la possibilité d'utiliser uniquement les noms des propriétés et des méthodes, mais les sous-classes doivent fournir des implémentations

Le soi-disant polymorphisme signifie que la même méthode d'une instance de classe a différentes manifestations dans différentes situations.

Le polymorphisme permet à des objets ayant des structures internes différentes de partager la même interface externe. Cela signifie que même si les opérations spécifiques sur différents objets sont différentes, elles (ces opérations) peuvent être appelées de la même manière via une classe commune.

1. L'héritage

1.

Utilisez le mot-clé extends pour la sous-classe pour permettre à la sous-classe d'hériter de la classe parent

class Student extends Person{}

2. Choses à noter lors de la mise en œuvre de l'héritage ?

① Les sous-classes ne peuvent hériter que des propriétés non privées de la classe parent.

②Après qu'une sous-classe hérite d'une classe parent, cela équivaut à copier les

attributs et méthodes de la classe parent dans la sous-classe, qui peut être appelée directement en utilisant $this.

③ PHP ne prend en charge que l'héritage unique et ne prend pas en charge une classe héritant de plusieurs classes. Mais une classe effectue un héritage à plusieurs niveaux ;

class Person{}

class Chengnian extends Person{}

class Student extends Chengnian{}

//Student类就同时具有了Chengnian类和Person类的属性和方法

3. Remplacement de méthode (réécriture de méthode)

Condition ① La sous-classe hérite du parent. gentil.

Condition ② La sous-classe remplace la méthode existante de la classe parent.

remplit les deux conditions ci-dessus et est appelé couverture de méthode. Après le remplacement, lorsqu'une sous-classe appelle une méthode, la propre méthode de la sous-classe sera appelée.

De même, en plus du remplacement de méthode, les sous-classes peuvent également avoir des attributs portant le même nom que la classe parent pour le remplacement d'attributs.

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

partent::方法名();

所以，当子类继承父类时，需在子类的构造中的第一步，首先调用父类构造进行复制。

function construct($name,$sex,$school){

  parent::construct($name,$sex);

  $this->school = $school;

}

实例一枚：

class Student extends Person{      //子类继承父类
  public $school;           function construct($name,$sex,$school){   //子类的构造函数
   parent::construct($name,$sex);  //调用父类构造进行复制
   $this->school = $school;
  }
  
  function program(){
   echo "PHP真好玩！我爱PHP！PHP是世界上最好用的编程语言！<br>";
  }
  
  function say(){
   parent::say();      //重写父类的同名方法
   echo "我是{$this->school}的";
  }
 }
 
 $zhangsan = new Student("张三","男","起航");
 $zhangsan->say();
 $zhangsan->program();

二、封装

1、什么是封装？

通过访问修饰符，将类中不需要外部访问的属性和方法进行私有化处理，以实现访问控制。

【注意】：是实现访问控制，而不是拒绝访问。 也就是说，我们私有化属性之后，需要提供对应的方法，让用户通过我们提供的方法处理属性。

2、封装的作用？

①使用者只关心类能够提供的功能，而不必关心功能实现的细节！(封装方法)

②对用户的数据进行控制，防止设置不合法数据，控制返回给用户的数据(属性封装+set/get方法)

3、实现封装操作？

① 方法的封装

对于一些只在类内部使用的方法，而不像对外部提供使用。那么，这样的方法我们可以使用private进行私有化处理。
private function formatName(){} //这个方法仅仅能在类内部使用$this调用
function showName(){
$this -> formatName();
}

②属性的封装+set/get方法

为了控制属性的设置以及读取，可以将属性进行私有化处理，并要求用户通过我们提供的set/get方法进行设置
private $age;
function setAge($age){
$this->age = $age;
}
function getAge(){
return $this->age;
}
$对象 -> getAge();
$对象 -> setAge(12);

③ 属性的封装+魔术方法

private $age;
function get($key){
return $this->$key;
}
function set($key,$value){
$this->$key=$value;
}
$对象->age; // 访问对象私有属性时，自动调用get()魔术方法，并且将访问的属性名传给get()方法；
$对象->age=12; // 设置对象私有属性时，自动调用set()魔术方法，并且将设置的属性名以及属性值传给set()方法；

【 注意】：在魔术方法中，可以使用分支结构，判断$key的不同，进行不同操作。

4、关于封装的魔术方法：

① set($key,$value):给类私有属性赋值时自动调用，调用时给方法传递两个参数：需要设置的属性名、属性值；

② get($key):读取类私有属性时自动调用，调用时给方法传递一个参数：需要读取的属性名；

③ isset($key):外部使用isset()函数检测私有属性时，自动调用。

>>> 类外部使用isset();检测私有属性，默认是检测不到的。false

>>> 所以，我们可以使用isset();函数，在自动调用时，返回内部检测结果。

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

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

④ unset($key):外部使用unset()函数删除私有属性时，自动调用；

function unset($key){
  unset($this->$key);
}

当外部使用unset($对象名->私有属性);删除属性时，自动将属性名传给unset(),并交由这个魔术方法处理。

实例一枚

class Person{
  public $name;
  public $age;
  public $sex;
  function construct($name, $age,$sex){
   $this->name=$name;
   $this->setAge($age);
   $this->setSex($sex);
  }
  function setAge($age){
   if($age>=0&&$age<=120){
   return $this->age=$age;
   }else{
    die("年龄输入有误！！！");
   }
  }
  function setSex($sex){
   if($sex=="女"||$sex=="男"){
   return $this->sex=$sex;
   }else{
    die("性别输入有误！！！");
   }
  }
  function say(){
   echo "我的名字叫{$this->name},我的年龄{$this->age},我的性别是{$this->sex}<br>";
  }
 }
class Work extends Person{private $position;
  function construct($name, $age,$sex,$position){
   parent::construct($name, $age,$sex);
   $this->job=$job;
   $this->setPosition($position);
  }
  function setPosition($position){
   $arr=[&#39;总监&#39;,&#39;董事长&#39;,&#39;程序员&#39;,&#39;清洁工&#39;];
   if(in_array($position, $arr)){
    return $this->position=$position;
   }else{
    die("不存在该职位");
   }
  }  
  function set($key,$value){
   if($key=="age"){
    return parent::setAge($value);
   }
   elseif($key=="sex"){
    return parent::setSex($value);
   }
   elseif($key=="position"){
    return $this->setPosition($value);
   }
   return $this->$key=$value;
  }
  
  function say(){
   parent::say();
   echo "我的职位是{$this->position}";
  }
  }
  
 $zhangsan=new Work("张三",22,"男","总监");
 $zhangsan->setSex("女");
 $zhangsan->setAge(30);
// $zhangsan->setPosition("董事长");
 $zhangsan->position="董事长";
 $zhangsan->name="lisi";
 $zhangsan->say();

三.多态

3.1、什么是多态？

多态实现多态的前提是实现继承。

1.一个类被多个子类继承，如果这个类的某个方法在多个子类中表现出不同的功能，我们称这种行为为多态。在PHP中的方法重写，

2.实现多态的必要途径：

⑴子类继承父类；

⑵重写父类方法；

⑶父类引用指向子类对象；

class Computer{
 function fangfa(InkBox $a,Paper $b){  //父类引用
 echo "即将开始打印····<br>"; 
 $a->color();
 $b->sizes();
 echo "打印结束···<br>"; 
 
 }
}

class Color implements InkBox{
 function color(){
 echo "正在装载彩色墨盒<br>";
 echo "实现彩色墨盒<br>";
 }
}
class White implements InkBox{
 function color(){
 echo "正在装载黑白墨盒<br>"; 
 echo "实现黑白墨盒<br>";
 }
}
class A4 implements Paper{
 function sizes(){
 echo "正在加载A4纸张<br>";
 echo "实现A4纸张<br>";
 }
}
class A5 implements Paper{
 function sizes(){
 echo "实现A5纸张<br>";
 }
}

$com=new Computer();//创建对象
$com->fangfa(new Color(),new A4());//子类对象

相关课程推荐：

视频教程： 韩顺平 2016年 最新PHP面向对象编程视频教程

视频教程： PHP面向对象编程视频教程