Sprechen Sie über mein Verständnis von Objektorientierung in PHP

Heute möchte ich Ihnen die objektorientierte Natur von PHP vorstellen. Apropos objektorientiert, ich muss prozessorientiert erwähnen, denn als ich gerade lernte, konnte ich oft nicht zwischen objektorientierter und prozessorientierter Programmierung unterscheiden Eine grundlegende Fähigkeit in unserer Programmierung. PHP5 bietet eine 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. Im Folgenden veranschaulichen wir anhand von Beispielen die praktische Bedeutung und Anwendungsmöglichkeiten des Einsatzes von PHPs OOP für die Programmierung.

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.

Lassen Sie mich Ihnen ihre Unterschiede vorstellen:

Objektorientiert konzentriert sich darauf, welches Objekt ein Problem löst.

Sein größtes Merkmal besteht darin, dass es aus Klassen mit Attributen und Funktionen besteht und aus den Klassen Objekte abgerufen werden können, um Probleme zu lösen.

Prozessorientiert konzentriert sich auf den Prozess der Lösung eines Problems. Das größte Merkmal besteht darin, dass eine Reihe von Prozessen verwendet werden, um dieses Problem nacheinander zu lösen.

1. Objektorientierte Grundlagen

一Objektorientiert

1 eine Klasse?
Eine Sammlung einer Reihe von Individuen mit denselben Attributen (Eigenschaften) und Methoden (Verhalten). Eine Klasse ist ein abstraktes Konzept.

2. Was ist ein Objekt?
Das Individuum mit bestimmten Attributwerten, die aus der Klasse erhalten werden, wird als Objekt bezeichnet. Das Objekt ist eine bestimmte Person.
zB: Mensch; Zhang San

3. Welche Beziehung besteht zwischen Klassen und Objekten?
Eine Klasse ist eine Abstraktion eines Objekts! Objekte sind die Verdinglichung von Klassen!
Die Klasse gibt nur an, welche Attribute dieser Objekttyp hat, sie kann jedoch keine spezifischen Werte haben, daher ist die Klasse abstrakt.
Das Objekt ist eine bestimmte Person, nachdem alle Attribute der Klasse zugewiesen wurden. Alle Objekte sind spezifisch.

2Deklaration und Instanziierung von Klassen

1. So deklarieren Sie eine Klasse:

Klasse Klassenname {
Zugriffsmodifikator $property[=Standardwert];
[Zugriffsmodifikator] Funktionsmethode (){}
}

2. Hinweise zum Deklarieren einer Klasse:
①Der Klassenname darf nur aus Buchstaben, Zahlen und Unterstrichen bestehen. Er darf nicht mit einer Zahl beginnen und muss der Groß-/Kleinschreibung entsprechen.
②Der Klassenname muss geändert werden mit Klasse, gefolgt vom Klassennamen Es darf kein ();
③Attribute müssen Zugriffsmodifikatoren haben, und Methoden dürfen keine Zugriffsmodifikatoren haben.

3. Aufrufen von instanziierten Objekten und Objektattributmethoden:
$object name = new class name(); //() Sie können Rufen Sie Attribute und Methoden von außerhalb der Klasse auf, ohne

:
$object name-> $property name; //Verwenden -> Beim Aufruf von Attributen darf der Attributname nicht das $-Symbol enthalten

Aufruf von Attributen und Methoden innerhalb der Klasse:
$this - > $ Attributname;

DreiKonstruktor

1. Was ist ein Konstruktor?
Der Konstruktor ist eine spezielle Funktion in einer Klasse. Wenn wir das Schlüsselwort new verwenden, um ein Objekt zu instanziieren, entspricht dies dem Aufruf des Konstruktors der Klasse.

2. Welche Funktion hat der Konstruktor?
Beim Instanziieren eines Objekts wird es automatisch aufgerufen und verwendet, um den Eigenschaften des Objekts Anfangswerte zuzuweisen!

3. So schreiben Sie den Konstruktor:
①Der Name des Konstruktors muss mit dem Klassennamen identisch sein
[public] function Person($name){
$this -> name = $name;
}
②Verwenden magische Methode __construct
[public] function __construct($name){
$this -> name = $name;
}
4. Hinweise zu Konstruktoren:
① Die erste Schreibweise: Der Name des Konstruktors muss mit dem der Klasse identisch sein! ! ! !
②Wenn eine Klasse keinen handgeschriebenen Konstruktor hat, verfügt das System standardmäßig über einen leeren Parameterkonstruktor, sodass Sie new Person(); verwenden können
Wenn wir Schreiben Sie einen Konstruktor mit Parameterkonstruktor, es wird keinen leeren Parameterkonstruktor mehr geben, das heißt, new Person() kann nicht direkt verwendet werden
Die Parameterliste in () nach Person muss die Anforderungen erfüllen des Konstrukteurs ! ! ! !
③Wenn beide Konstruktoren gleichzeitig existieren, wird __construct verwendet.

5. Destruktor: __destruct():
①Der Destruktor wird automatisch aufgerufen, bevor das Objekt zerstört und freigegeben wird
②Der Destruktor kann keine Parameter annehmen.
③Der Destruktor wird häufig verwendet, um Ressourcen freizugeben, Ressourcen zu schließen usw., nachdem das Objekt verwendet wurde.

6. Magische Methode:
PHP stellt uns eine Reihe von Funktionen bereit, die mit __ beginnen. Diese Funktionen müssen nicht manuell aufgerufen werden,
wird automatisch zum richtigen Zeitpunkt aufgerufen. Diese Art von Funktion wird als Magie bezeichnet und als magische Funktion bezeichnet.
Beispiel: Funktion __construct(){} wird automatisch aufgerufen, wenn ein neues Objekt erstellt wird
Funktion __destruct(){} wird automatisch aufgerufen, wenn das Objekt zerstört wird

Wir verlangen, dass benutzerdefinierte Funktionen und Methoden mit Ausnahme von magischen Methoden nicht mit __ beginnen dürfen.

Abschließend schreiben wir im Allgemeinen Klassen mit komplexeren Funktionen in eine separate Klassendatei.

Die Klassendatei wird mit der Methode „Klassenname Kleinbuchstaben.class.php“ im gleichen Kleinbuchstaben benannt.
Wenn Sie diese Klasse in anderen Dateien verwenden, können Sie include verwenden, um diese „.class.php“-Datei zu importieren.

二、封装和继承

1. Was ist Kapselung?
Verwenden Sie Zugriffsmodifikatoren, um die Eigenschaften und Methoden in der Klasse zu privatisieren, die keinen externen Zugriff erfordern, um eine Zugriffskontrolle zu erreichen.

*Hinweis: Dies dient der Implementierung der Zugriffskontrolle und nicht der Verweigerung des Zugriffs. Mit anderen Worten: Nachdem wir die Attribute privatisiert haben, müssen wir entsprechende Methoden bereitstellen, damit Benutzer die Attribute über die von uns bereitgestellten Methoden verarbeiten können.

2. Welche Rolle spielt die Kapselung?
① Benutzer kümmern sich nur um die Funktionen, die die Klasse bereitstellen kann, und kümmern sich nicht um die Details der Funktionsimplementierung! (Kapselungsmethode)
② Kontrollieren Sie die Daten des Benutzers, verhindern Sie das Festlegen illegaler Daten und steuern Sie die an den Benutzer zurückgegebenen Daten (Attributkapselung + Set/Get-Methode)

3. Kapselungsvorgang implementieren?
①Methodenkapselung
Für einige Methoden, die nur innerhalb der Klasse verwendet werden und nicht für die externe Verwendung bereitgestellt werden, können wir für solche Methoden den Privatisierungsprozess verwenden.

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

②Attributkapselung + Set/Get-Methode
Um das Setzen und Lesen von Attributen zu steuern, können Sie Die Attribute sind privatisiert und der Benutzer muss sie über die von uns bereitgestellten Set/Get-Methoden festlegen

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);

③Attributkapselung + magische Methode

    __get(  ->   __set(, ->= }

$Object->age; //Beim Zugriff auf die privaten Eigenschaften des Objekts wird die magische Methode __get() automatisch aufgerufen und der Name der aufgerufenen Eigenschaft wird an die Methode __get() übergeben 🎜>
$Object->age=12; // Rufen Sie beim Festlegen der privaten Attribute des Objekts automatisch die magische Methode __set() auf und übergeben Sie den festgelegten Attributnamen und den Attributwert an __set( )-Methode;

Hinweis: Bei der Magic-Methode können Sie die Verzweigungsstruktur verwenden, um den Unterschied in $key zu ermitteln und verschiedene Operationen auszuführen.

4. Magische Methoden zur Kapselung:
①__set($key,$value): Beim Zuweisen von Werten zur Klasse private Attribute Rufen Sie die Methode automatisch auf und übergeben Sie beim Aufruf zwei Parameter an die Methode: den Attributnamen, der festgelegt werden muss, und den Attributwert.
②__get($key,$value): Wird beim Lesen der privaten Attribute der Klasse automatisch aufgerufen. Übergeben Sie beim Aufruf einen Parameter an die Methode, den Namen des Attributs, das gelesen werden muss.
③__isset($key): Wird automatisch aufgerufen, wenn die isset()-Funktion extern verwendet wird, um private Attribute zu erkennen.
>>> Verwenden Sie isset(); außerhalb der Klasse, um private Eigenschaften zu erkennen, die standardmäßig nicht erkannt werden. false
>>>Wir können also die Funktion __isset(); verwenden, um das interne Erkennungsergebnis zurückzugeben, wenn sie automatisch aufgerufen wird.

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)调用类中的静态属性，静态方法，以及常量。

 

四、单例

Der Singleton-Modus wird auch als monomorpher Modus bezeichnet. Es ist garantiert, dass eine Klasse nur eine Objektinstanz haben kann.

Implementierungspunkte:
① Der Konstruktor ist privat und das neue Schlüsselwort darf nicht zum Erstellen von Objekten verwendet werden.
② Stellen Sie externe Methoden zum Abrufen von Objekten bereit und bestimmen Sie, ob das Objekt in der Methode leer ist.
Wenn es leer ist, erstellen Sie das Objekt und geben Sie es zurück. Wenn es nicht leer ist, geben Sie es direkt zurück.
③Die Attribute des Instanzobjekts und die Methode zum Abrufen des Objekts müssen statisch sein.
④ Danach können Objekte nur noch mit den von uns bereitgestellten statischen Methoden erstellt werden.
eg:$s1 = Singleton::getSingle();

5. Objektserialisierung und magische Methoden

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

 

***关键词：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(new Person()); √
func(new Student()); √
func("111"); 🎜>

※※※Basisklasse: Elternklasse

※※※ Abgeleitete Klasse : Unterklasse

Fünf

Kleine Zusammenfassung magischer Methoden 1. __construct(): Konstruktor, wird automatisch aufgerufen, wenn ein Objekt neu ist.

2. __destruct(): Destruktor, wird automatisch aufgerufen, wenn ein Objekt zerstört wird.
3. __get(): Wird automatisch aufgerufen, wenn auf private Eigenschaften in der Klasse zugegriffen wird. Übergeben Sie den gelesenen Attributnamen und geben Sie $this->Attribute name
4 zurück: Wird automatisch aufgerufen, wenn einem privaten Attribut der Klasse ein Wert zugewiesen wird. Übergeben Sie den Attributnamen und den Attributwert, die festgelegt werden müssen.
5. __isset(): Wird automatisch aufgerufen, wenn isset() verwendet wird, um die privaten Attribute des Objekts zu erkennen. Übergeben Sie den erkannten Attributnamen und geben Sie isset($this -> attribute name);
zurück. __unset(): Wird automatisch aufgerufen, wenn unset() zum Löschen der privaten Attribute des Objekts verwendet wird. Übergeben Sie den gelöschten Attributnamen und führen Sie unset($this -> attribute name);
7 aus: Wird automatisch aufgerufen, wenn echo zum Drucken des Objekts verwendet wird. Geben Sie den Inhalt zurück, den Sie beim Drucken des Objekts anzeigen möchten. Die Rückgabe muss eine Zeichenfolge sein.
8: Wird automatisch aufgerufen, wenn eine undefinierte oder nicht veröffentlichte Methode aufgerufen wird. Übergeben Sie den aufgerufenen Funktionsnamen und das Parameterlisten-Array.
9: Wird beim Klonen eines Objekts mit dem Schlüsselwort clone automatisch aufgerufen. Die Funktion besteht darin, das neu geklonte Objekt zu initialisieren und ihm Werte zuzuweisen.
10: wird automatisch aufgerufen, wenn das Objekt serialisiert wird. Gibt ein Array zurück, und die Werte im Array sind Attribute, die serialisiert werden können.
11: Wird automatisch aufgerufen, wenn das Objekt deserialisiert wird. Um das neu generierte Objekt zu deserialisieren, führen Sie eine Initialisierungszuweisung durch.
12: Die Funktion muss außerhalb der Klasse deklariert werden. Wird automatisch aufgerufen, wenn eine nicht deklarierte Klasse instanziiert wird. Durch Übergabe des instanziierten Klassennamens kann die entsprechende Klassendatei automatisch unter Verwendung des Klassennamens geladen werden.

6. Abstrakte Klassen und abstrakte Methoden

1. Was ist eine abstrakte Methode?
Methoden ohne Methodenkörper {} müssen mit dem Schlüsselwort abstract geändert werden. Solche Methoden werden abstrakte Methoden genannt.
Abstrakte Funktion say(); //Abstrakte Methode

2. Was ist eine abstrakte Klasse?
Eine mit dem Schlüsselwort abstract geänderte Klasse ist eine abstrakte Klasse.
abstrakte Klasse Person{}

3. Hinweise zu abstrakten Klassen:
① Abstrakte Klassen können nicht abstrakte Klassen enthalten Klassen Methode;
② Die Klasse, die die abstrakte Methode enthält, muss eine abstrakte Klasse sein, und die abstrakte Klasse muss nicht unbedingt eine abstrakte Klasse enthalten instanziiert. (Abstrakte Klassen können abstrakte Methoden enthalten. Abstrakte Methoden haben keinen Methodenkörper und Instanziierungsaufrufe sind bedeutungslos.)
Der Zweck der Verwendung abstrakter Klassen besteht darin, die Instanziierung einzuschränken! ! !

4. Wenn eine Unterklasse eine abstrakte Klasse erbt, muss die Unterklasse alle abstrakten Methoden der übergeordneten Klasse überschreiben, es sei denn, die Unterklasse ist ebenfalls eine abstrakte Klasse.

5. Welche Rolle spielt die Verwendung abstrakter Klassen?

① Instanziierung begrenzen. (Eine abstrakte Klasse ist eine unvollständige Klasse. Die darin enthaltene abstrakte Methode hat keinen Methodenkörper und kann daher nicht instanziiert werden.)
② Die abstrakte Klasse bietet eine Spezifikation für die Vererbung von Unterklassen, und Unterklassen erben eine Abstraktion Die Klasse muss die in der abstrakten Klasse definierten abstrakten Methoden enthalten und implementieren.

Tabelle >

一Schnittstelle

1. Was ist eine Schnittstelle? ?
Eine Schnittstelle ist eine Spezifikation, die eine Reihe von Methodenkombinationen bereitstellt, die von einer Klasse implementiert werden müssen, die die Schnittstelle implementiert.
Die Schnittstelle wird mit dem Schlüsselwort „interface“ deklariert;

2 >Schnittstelle Alle Methoden in müssen abstrakte Methoden sein.

Abstrakte Methoden in Schnittstellen benötigen keine Zusammenfassung und können auch nicht mit dieser geändert werden.
3.Variablen können nicht in der Schnittstelle deklariert werden und es können keine Attribute verwendet werden. ! !

4. Schnittstellen können Schnittstellen erben, indem sie das Schlüsselwort „extends“ verwenden! Die

-Schnittstelle verwendet Erweiterungen, um die Schnittstelle zu erben, wodurch eine Mehrfachvererbung erreicht werden kann. interface int1 erweitert Inter,Inter2{}

5. Die -Klasse kann die Schnittstelle implementieren, verwenden Sie das Schlüsselwort „implements“!

Die Klasse verwendet Implementierungen, um mehrere Schnittstellen gleichzeitig zu implementieren. Abstrakte Klasse Person implementiert Inter, Inter2{}
Eine Klasse implementiert eine oder mehrere Schnittstellen, dann muss diese Klasse alle abstrakten Methoden in allen Schnittstellen implementieren!
Es sei denn, diese Klasse ist eine abstrakte Klasse.
[Unterschied zwischen Schnittstelle und abstrakter Klasse]:
① In Bezug auf die Deklarationsmethode verwenden Schnittstellen das Schlüsselwort interface und abstrakte Klassen verwenden abstrakte Klassen.

②In Bezug auf Implementierung/Vererbung verwendet eine Klasse Extends, um eine abstrakte Klasse zu erben, und Implements, um die Schnittstelle zu implementieren.

③Abstrakte Klassen können nur einzeln vererbt werden, während Schnittstellen auf verschiedene Arten implementiert werden können. (Schnittstelle erweitert Schnittstelle), mehrere Implementierungen (Klasse implementiert Schnittstelle)

④ Abstrakte Klassen können nicht abstrakte Methoden haben, Schnittstellen können nur abstrakte Methoden haben, keine abstrakten Methoden. Abstrakte Methoden in abstrakten Klassen müssen mit dem Schlüsselwort abstract geändert werden, und abstrakte Methoden in Schnittstellen können nicht mit Modifikatoren geändert werden.

⑤Eine abstrakte Klasse ist eine Klasse, die Attribute und Variablen haben kann; eine Schnittstelle kann nur Konstanten haben.

IIPolymorphismus

Polymorphismus
1. Eine Klasse wird von mehreren Unterklassen geerbt.
Wenn eine Methode dieser Klasse unterschiedliche Funktionen in mehreren Unterklassen zeigt, nennen wir dieses Verhalten Polymorphismus.

2. Notwendige Wege, um Polymorphismus zu erreichen:
① Unterklasse erbt Elternklasse;
② Unterklasse neu schreiben Methode der übergeordneten Klasse;
③ Die Referenz der übergeordneten Klasse verweist auf das Unterklassenobjekt

7. Schnittstellen und Polymorphismus

Das obige ist der detaillierte Inhalt vonSprechen Sie über mein Verständnis von Objektorientierung in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!