Praktische Grundkenntnisse in PHP objektorientiert

一、面向对象基础

一Objektorientiert

1. Was ist 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.

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

②Attributkapselung + Set/Get-Methode
Um das Setzen und Lesen von Attributen zu steuern , können Sie die Attribute privatisieren und von Benutzern verlangen, sie über die von uns bereitgestellten Set/Get-Methoden festzulegen

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

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

③Attributkapselung + magische Methode

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

$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_ _get( ) method;
$object->age=12; //Beim Festlegen der privaten Attribute des Objekts wird automatisch die magische Methode __set() aufgerufen und der festgelegte Attributname und Attributwert übergeben Give __set() method;

Hinweis: In der Magic-Methode können Sie die Verzweigungsstruktur verwenden, um den Unterschied von $key zu beurteilen 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 zu lesenden Attributs.
③__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 Attribute 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.

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

Bei externer Erkennung mit isset($object name->private property); wird das obige __isset() automatisch aufgerufen Ergebnisse zurückgegeben!

④__unset($key): Wird automatisch aufgerufen, wenn die unset()-Funktion extern verwendet wird, um private Attribute zu löschen;
1 Funktion __unset($key){ 2 unset($this -> ; $key); 3 Wenn unset($object name->private attribute); Um ein Attribut zu löschen, übergeben Sie den Attributnamen automatisch an __unset() und übergeben Sie ihn zur Verarbeitung an diese magische Methode.

继承的基础知识：

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

 

四、单例

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()函数返回的字符串；

 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文件

 

DreiObjektorientierte Serialisierung und Deserialisierung (Serialisierung und Deserialisierung)

1. Serialisierung: Der Prozess der Konvertierung eines Objekts in eine Zeichenfolge durch eine Reihe von Vorgängen wird Serialisierung genannt.

　　　　　　　　　　　　　　　　　　　

2. Inverse Serialisierung: Der Prozess von Das Konvertieren einer serialisierten Zeichenfolge in ein Objekt wird als Deserialisierung bezeichnet 🎜>3. Wann sollte die Serialisierung verwendet werden?
①Wenn Objekte über das Netzwerk übertragen werden müssen
②Wenn Objekte in Dateien oder Datenbanken gespeichert werden müssen
4 Serialisierung und Deserialisierung implementieren
Serialisierung: $str=serialize($zhangsan);
Deserialisierung: $duixiang=unserialize ($str);
5. __sleep() magische Methode:
① Wenn das Objekt serialisiert wird, wird die __sleep()-Funktion automatisch ausgeführt
②__sleep()-Funktion erfordert die Rückgabe eines Arrays. Die Werte im Array sind Attribute, die nicht im Array enthalten sind.
Funktion __sleep(){
return array("name","age"); //Nur die Namens-/Altersattribute können serialisiert werden.
}
6. __wakeup() magische Methode

① Wird beim Deserialisieren eines Objekts automatisch aufgerufen_ _wakeup() Methode;
②Wenn es automatisch aufgerufen wird, wird es verwendet, um die durch Deserialisierung generierten neuen Objektattribute neu zuzuweisen.
1
Funktion __wakeup(){ 2 $this -> ; name = "李思"; 3 }

四

Typbeschränkungen

1. Typeinschränkungen:
bezieht sich auf das Hinzufügen eines Datentyps beim Hinzufügen einer Variablen, um einzuschränken, dass die Variable nur gespeichert werden kann Der entsprechende Datentyp. (Dieser Vorgang ist in stark typisierten Sprachen üblich. In PHP können nur Typbeschränkungen für Arrays und Objekte implementiert werden)
2,
Wenn es sich bei der Typbeschränkung um eine bestimmte Klasse handelt, können Objekte dieser Klasse und Unterklassen dieser Klasse übergeben werden. 3.
In PHP können Typbeschränkungen nur in den formalen Parametern von Funktionen auftreten.

 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. 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.
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 eine abstrakte Methode enthält, muss eine abstrakte Klasse sein, und eine abstrakte Klasse muss nicht unbedingt eine abstrakte Methode 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.

7. Schnittstellen und Polymorphismus

EineSchnittstelle

1 Handelt es sich um 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 ist die Schnittstelle Der Schlüssel wird in Word verwendet, die abstrakte Klasse verwendet die abstrakte Klasse.
②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.

zwei

Polymorph

2. Polymorphismus1. 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 übergeordnete Klasse;
② Unterklasse überschreibt übergeordnete Klassenmethode; >③ Die übergeordnete Klassenreferenz verweist auf das Unterklassenobjekt

Das obige ist der detaillierte Inhalt vonPraktische Grundkenntnisse in PHP objektorientiert. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!