Umfassende Anleitung zum Verstehen und Erlernen der drei Grundfunktionen der objektorientierten PHP-Kapselung, Vererbung und Polymorphie

Objektorientierte Programmierung (OOP) ist eine grundlegende Fähigkeit in unserer Programmierung und PHP5 bietet gute Unterstützung für OOP. Die Verwendung von OOP-Ideen zur Durchführung fortgeschrittener PHP-Programmierung ist für die Verbesserung der PHP-Programmierfunktionen und die Planung einer guten Webentwicklungsarchitektur von großer Bedeutung.

Wenn wir normalerweise eine Website mit einem Datenbank-Backend erstellen, berücksichtigen wir, dass das Programm für verschiedene Anwendungsumgebungen geeignet sein muss. Der Unterschied zu anderen Programmiersprachen besteht darin, dass in PHP die Datenbank über eine Reihe spezifischer Funktionen betrieben wird (sofern Sie nicht die ODBC-Schnittstelle verwenden). Obwohl dies sehr effizient ist, reicht die Kapselung nicht aus. Wenn es eine einheitliche Datenbankschnittstelle gibt, können wir sie auf eine Vielzahl von Datenbanken anwenden, ohne Änderungen am Programm vorzunehmen, wodurch die Portabilität und die plattformübergreifenden Fähigkeiten des Programms erheblich verbessert werden.

Unten führt Sie unsere chinesische PHP-Website dazu, die drei Grundfunktionen von PHP objektorientiert vollständig zu verstehen: Kapselung, Vererbung und Polymorphismus.

Sie können sich die relevanten Videokurse auf unserer PHP-Chinesisch-Website ansehen: Kapitel 10 Klassen und Objekte in PHPAusführliche Vorlesung: this Zeit wird es sicher sein. Wenn Sie

verstehen möchten, können Sie auch das PHP-Chinesisch-Handbuch lesen: Tutorials zu Klassen und Objekte

Die drei Hauptmerkmale von PHP objektorientiert: Vererbung, Kapselung, Polymorphismus

Die sogenannte Kapselung dient auch dazu, objektive Dinge in abstrakte Klassen zu kapseln, und die Klasse kann nur vertrauenswürdigen Klassen oder Objekten erlauben, ihre eigenen Daten und Methoden zu betreiben und Informationen vor nicht vertrauenswürdigen zu verbergen.

Kapselung ist eines der Merkmale der Objektorientierung und das Hauptmerkmal von Objekt- und Klassenkonzepten. Einfach ausgedrückt ist eine Klasse eine logische Einheit, die Daten und Code kapselt, der mit diesen Daten arbeitet. Innerhalb eines Objekts können einige Codes oder Daten privat sein und für die Außenwelt nicht zugänglich sein. Auf diese Weise bieten Objekte unterschiedliche Schutzniveaus für interne Daten, um zu verhindern, dass unabhängige Teile des Programms versehentlich die privaten Teile des Objekts ändern oder falsch verwenden.

Die sogenannte Vererbung bezieht sich auf eine Methode, die es einem Objekt eines bestimmten Typs ermöglicht, die Eigenschaften eines Objekts eines anderen Typs zu erhalten. Sie unterstützt das Konzept der hierarchischen Klassifizierung.

Vererbung bezieht sich auf die Fähigkeit, die gesamte Funktionalität einer vorhandenen Klasse zu nutzen und diese Funktionalität zu erweitern, ohne die ursprüngliche Klasse neu schreiben zu müssen. Die durch Vererbung erstellte neue Klasse wird als „Unterklasse“ oder „abgeleitete Klasse“ bezeichnet, und die geerbte Klasse wird als „Basisklasse“, „übergeordnete Klasse“ oder „Superklasse“ bezeichnet. Der Prozess der Vererbung ist der Prozess vom Allgemeinen zum Besonderen. Um eine Vererbung zu erreichen, können Sie dies über „Vererbung“ und „Zusammensetzung“ erreichen. Es gibt zwei Arten von Möglichkeiten, das Konzept der Vererbung zu implementieren: Implementierungsvererbung und Schnittstellenvererbung. Implementierungsvererbung bezieht sich auf die Möglichkeit, die Eigenschaften und Methoden einer Basisklasse ohne zusätzliche Codierung zu verwenden; Unterklassen müssen jedoch Implementierungen

Der sogenannte Polymorphismus bedeutet, dass dieselbe Methode einer Klasseninstanz in verschiedenen Situationen unterschiedliche Ausprägungen hat.

Polymorphismus ermöglicht es Objekten mit unterschiedlichen internen Strukturen, dieselbe externe Schnittstelle zu teilen. Dies bedeutet, dass die spezifischen Operationen an verschiedenen Objekten zwar unterschiedlich sind, sie (diese Operationen) jedoch auf die gleiche Weise über eine gemeinsame Klasse aufgerufen werden können.

1. Vererbung

1.

Verwenden Sie das Schlüsselwort „extends“ für die Unterklasse, damit die Unterklasse die übergeordnete Klasse erbt.

class Student erweitert Person{}

2. Was ist bei der Umsetzung einer Vererbung zu beachten?

① Unterklassen können nur nicht private Eigenschaften der übergeordneten Klasse erben.

②Nachdem eine Unterklasse eine übergeordnete Klasse geerbt hat, entspricht dies dem Kopieren der

Attribute und Methoden der übergeordneten Klasse in die Unterklasse, die direkt mit $this aufgerufen werden kann.

③ PHP unterstützt nur die Einzelvererbung und nicht die Vererbung mehrerer Klassen durch eine Klasse. Eine Klasse führt jedoch eine mehrstufige Vererbung durch Elternart.

Bedingung ② Die Unterklasse überschreibt die vorhandene Methode der übergeordneten Klasse.

class Person{}

class Chengnian extends Person{}

class Student extends Chengnian{}

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

erfüllt die beiden oben genannten Bedingungen und wird als Methodenabdeckung bezeichnet. Wenn eine Unterklasse nach dem Überschreiben eine Methode aufruft, wird die eigene Methode der Unterklasse aufgerufen. In ähnlicher Weise können Unterklassen zusätzlich zum Überschreiben von Methoden auch Attribute mit demselben Namen wie die übergeordnete Klasse zum Überschreiben von Attributen haben.

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面向对象编程视频教程