PHP-Klassen und Objekte

In diesem Tutorial werden Sie lernen, wie Sie in PHP objektorientiert programmieren.

Was ist objektorientierte Programmierung

Die objektorientierte Programmierung (OOP) ist ein Programmiermodell, das auf dem Konzept von Klassen und Objekten basiert. Im Gegensatz zur Prozessprogrammierung, bei der der Fokus auf das Schreiben von Prozessen oder Funktionen liegt, die Daten verarbeiten, liegt der Fokus in der objektorientierten Programmierung auf der Erstellung von Objekten, die sowohl Daten als auch Funktionen enthalten.

Im Vergleich zur konventionellen oder prozessorientierten Programmierung hat die objektorientierte Programmierung mehrere Vorteile. Die wichtigsten sind wie folgt aufgeführt:

• Es bietet der Programmierung klare Modulstruktur.

• Es hilft Ihnen, dem Prinzip "Don't Repeat Yourself" (DRY) zu entsprechen, was Ihre Code leichter zu warten, zu ändern und zu debuggen macht.

• Es ermöglicht die Erstellung komplexerer Verhaltensweisen mit weniger Code, kürzerer Entwicklungszeit und hoher Wiederverwendbarkeit.

Die folgenden Abschnitte beschreiben, wie Klassen und Objekte in PHP funktionieren.

Verständnis von Klassen und Objekten

Klassen und Objekte sind die beiden Hauptaspekte der objektorientierten Programmierung. Eine Klasse ist eine Sammlung unabhängiger Variablen und Funktionen, die zusammenarbeiten, um eine oder mehrere spezifische Aufgaben auszuführen, während ein Objekt eine einzelne Instanz einer Klasse ist.

Eine Klasse dient als Muster oder Bauplan, aus dem viele einzelne Objekte erstellt werden können. Beim Erstellen eines einzelnen Objekts können einige Attribute des einzelnen Objekts unterschiedliche Werte haben, aber sie erben die gleichen allgemeinen Attribute und Verhaltensweisen.

Beispielsweise kann man die Klasse als Bauplan für ein Haus betrachten. Der Plan selbst ist nicht das Haus, sondern der detaillierte Plan des Hauses. Und ein Objekt ist wie das tatsächliche Haus, das gemäß diesem Plan gebaut wird. Wir können mehrere gleiche Häuser basierend auf dem gleichen Plan bauen, aber jedes Haus könnte innen unterschiedliche Farben, Innenverkleidungen und Familien haben, wie im folgenden Bild gezeigt.

Eine Klasse kann mit dem Schlüsselwort class deklariert werden, gefolgt vom Namen der Klasse und einem Paar geschweiften Klammern ({ }), wie im folgenden Beispiel gezeigt.

Lassen Sie uns eine PHP-Datei mit dem Namen Recangle.php erstellen und den folgenden Beispielcode hinzufügen, um unsere Klassencode mit dem Rest des Programms zu trennen. Wir müssen dann nur die Datei Recangle.php einbinden, um sie an jedem benötigten Ort zu verwenden.

<?php
class Rectangle
{
　　　　//Eigenschaften erklären
　　　　public $length = 0;
　　　　public $width = 0;
　　　　
　　　　//求周长的方法
　　　　public function getPerimeter(){
　　　　　　　　return (2　*　($this->length　+　$this->width));
　　　　}
　　　　
　　　　//求面积的方法
　　　　public function getArea(){
　　　　　　　　return ($this->length　*　$this->width);
　　　　}
}
?>

Der Schlüsselwort public vor den Attributen und Methoden im obigen Beispiel ist einZugriffsmodifikatorbedeutet, dass das Attribut oder die Methode von überall aus erreicht werden kann. Wir werden später in diesem Kapitel mehr über dieses Thema erfahren.

Erstellen Sie eine weitere PHP-Datei mit dem Namen test.php und fügen Sie den folgenden Code hinzu.

<?php
//包含类定义
class Rectangle
{
　　　　//Eigenschaften erklären
　　　　public $length = 0;
　　　　public $width = 0;
　　　　
　　　　//求周长的方法
　　　　public function getPerimeter(){
　　　　　　　　return (2　*　($this->length　+　$this->width));
　　　　}
　　　　
　　　　//求面积的方法
　　　　public function getArea(){
　　　　　　　　return ($this->length　*　$this->width);
　　　　}
}
　
//Erstellen Sie ein neues Objekt aus der Klasse Rectangle
$obj = new Rectangle;
　
//Beschaffung der Objekteigenschaftswerte
echo $obj->length;　//　Ausgabe: 0
echo $obj->width;　//　Ausgabe: 0
　
//$obj = new Square;
>länge = $obj-Eigenschaftswerte des Objekts setzen　30;
>länge = $obj->breite = $obj　20;
　
//Lesen Sie erneut die Objekteigenschaftswerte, um die Änderungen anzuzeigen
echo $obj->length;　//　Ausgabe:　30
echo "<br>";
echo $obj->width;　//　Ausgabe:　20
　
　
//Aufruf eines Objektmethoden
echo $obj->getPerimeter();　//　Ausgabe:　100
echo "<br>";
echo $obj->getArea();　//　Ausgabe:　600
?>

Pfeilsymbol (-)> ist ein OOP-Konstrukteur, der den Zugriff auf die enthaltenen Attribute und Methoden eines bestimmten Objekts ermöglicht. Der Pseudovariable $this wird eine Referenz auf das aufgerufene Objekt (d.h. das Objekt, dem die Methode gehört) bereitgestellt.

Wenn mehrere Instanzen derselben Klasse verwendet werden, zeigt die wahre Stärke der objektorientierten Programmierung wie im folgenden Beispiel:

<?php
//包含类定义
class Rectangle
{
　　　　//Eigenschaften erklären
　　　　public $length = 0;
　　　　public $width = 0;
　　　　
　　　　//求周长的方法
　　　　public function getPerimeter(){
　　　　　　　　return (2　*　($this->length　+　$this->width));
　　　　}
　　　　
　　　　//求面积的方法
　　　　public function getArea(){
　　　　　　　　return ($this->length　*　$this->width);
　　　　}
}
　
//Erstellen Sie mehrere Objekte aus der Klasse Rectangle
>länge = $obj1　= new Rectangle;
>länge = $obj2　= new Rectangle;
　
//Rufen Sie die Methoden der beiden Objekte auf
echo $obj1->getArea();　//Ausgabe: 0
echo $obj2->getArea();　//Ausgabe: 0
　
//Setzen Sie $obj1Wert der Eigenschaft
>länge = $obj1-Eigenschaftswerte des Objekts setzen　30;
>länge = $obj1->breite = $obj　20;
　
//Setzen Sie $obj2Wert der Eigenschaft
>länge = $obj2-Eigenschaftswerte des Objekts setzen　35;
>länge = $obj2->breite = $obj　50;
　
//Rufen Sie erneut die Methoden der beiden Objekte auf
echo $obj1->getArea();　//Ausgabe:600
echo "<br>";
echo $obj2->getArea();　//Ausgabe:1750
?>

Wie im obigen Beispiel gezeigt, führt die Ausführung der Methode getArea() auf verschiedenen Objekten dazu, dass die Methode auf verschiedene Datensätze operiert. Jede Objekteinzelinstanz ist vollständig unabhängig und verfügt über eigene Attribute und Methoden, daher können sie, selbst wenn sie derselben Klasse angehören, unabhängig voneinander behandelt werden.

使用构造函数和析构函数

为了简化面向对象的编程，PHP提供了一些魔术方法，当对象中发生某些操作时，这些方法会自动执行。

例如，每当创建新对象时，魔术方法__construct()（称为构造函数）都会自动执行。同样，魔术方法__destruct()（称为析构函数）在对象被销毁时会自动执行。销毁对象后，析构函数将清除分配给该对象的所有资源。

<?php
class MyClass
{
　　　　//　Konstruktor
　　　　public function __construct(){
　　　　　　　　echo '　类　"' . __CLASS__ . '" 已启动<br>;
　　　　}
　　　　
　　　　//　析构函数
　　　　public function __destruct(){
　　　　　　　　echo '类 "' . __CLASS__ . '" 已销毁<br>';
　　　　}
}
　
//创建一个新对象
$obj = new MyClass;
　
//在文件末尾输出消息
echo "到达文件末尾。";
?>

Das PHP-Codebeispiel im obigen Beispiel erzeugt den folgenden Ausgabe:

类 "MyClass" 已启动
到达文件末尾。
类 "MyClass" 已销毁

脚本结束时将自动调用析构函数。但是，要显式触发析构函数，可以使用PHP unset()函数销毁对象，如下所示：

<?php
class MyClass
{
　　　　//　Konstruktor
　　　　public function __construct(){
　　　　　　　　echo '　类　"' . __CLASS__ . '" 已启动<br>;
　　　　}
　　　　
　　　　//　析构函数
　　　　public function __destruct(){
　　　　　　　　echo '类 "' . __CLASS__ . '" 已销毁<br>';
　　　　}
}
　
//创建一个新对象
$obj = new MyClass;
　
//　销毁对象
unset($obj);
　
//在文件末尾输出消息
echo "到达文件末尾。";
?>

现在，以上示例中的PHP代码将产生以下输出：

类 "MyClass" 已启动
类 "MyClass" 已销毁
到达文件末尾。

通过继承扩展类

类可以使用extends关键字继承另一个类的属性和方法。继承过程是面向对象编程模型中最强大的原因之一。

<?php
//包含类定义
class Rectangle
{
　　　　//Eigenschaften erklären
　　　　public $length = 0;
　　　　public $width = 0;
　　　　
　　　　//求周长的方法
　　　　public function getPerimeter(){
　　　　　　　　return (2　*　($this->length　+　$this->width));
　　　　}
　　　　
　　　　//求面积的方法
　　　　public function getArea(){
　　　　　　　　return ($this->length　*　$this->width);
　　　　}
}
　
//根据现有的类定义一个新的类
class Square extends Rectangle
{　　　
　　　　//此方法用于测试矩形是否也是正方形
　　　　public function isSquare(){
　　　　　　　　if($this->length == $this->width){
　　　　　　　　　　　　return true;　//　正方形
　　　　　　　　} else {
　　　　　　　　　　　　Quadrat　//return false;
　　　　　　　　}
　　　　}
}
　
//Nicht ein Quadrat
Ein neues Objekt aus der Klasse Square erstellen
　
//　$obj = new Square;
>länge = $obj-Eigenschaftswerte des Objekts setzen　20;
>länge = $obj->breite = $obj　20;
　
//　Aufruf eines Objektmethoden
if($obj->isSquare()){
　　　　echo "Der Flächeninhalt des Quadrats ist";
} else {
　　　　echo "Der Flächeninhalt des Rechtecks ist";
};
echo $obj->getArea();
?>

Das PHP-Codebeispiel im obigen Beispiel erzeugt den folgenden Ausgabe:

Der Flächeninhalt des Quadrats ist　400

Wie Sie im obigen Beispiel sehen können, enthält die Klassendefinition von Square weder den explizit enthaltenen getArea()-Methoden noch die explizit enthaltenen $length- und $width-Attribute, aber die Instanz der Square-Klasse kann auf sie zugreifen, weil sie von der übergeordneten Rectangle-Klasse vererbt werden.

Kontrolle der Sichtbarkeit von Eigenschaften und Methoden

Bei der Verwendung von Klassen können Sie auch Sichtbarkeitsklauseln verwenden, um den Zugriff auf ihre Eigenschaften und Methoden zu beschränken, um eine bessere Kontrolle zu erreichen. Es gibt drei Sichtbarkeitsklauseln (von am sichtbarsten bis am unsichtbarsten): public, protected, private, die bestimmen, wie und von wo auf Eigenschaften und Methoden zugegriffen und geändert wird.

• public - Eigenschaften oder Methoden können von jedem Ort innerhalb und außerhalb der Klasse erreicht werden. Dies ist die Standard-Sichtbarkeit aller Klassenmitglieder in PHP.
  

• protected - Geschützte Eigenschaften oder Methoden können nur aus der Klasse selbst oder aus Unterklassen oder vererbten Klassen (d.h. aus Klassen, die diese Klasse erweitern) erreicht werden.
  

• private - Private Eigenschaften oder Methoden können nur aus der Klasse, in der sie definiert sind, erreicht werden. Sogar Unterklassen oder vererbte Klassen können auf private Eigenschaften oder Methoden nicht zugreifen.

Der folgende Beispiel zeigt Ihnen, wie diese Sichtbarkeit tatsächlich funktioniert:

<?php
//Klassendefinition
class Automobile
{
　　　　//Eigenschaften erklären
　　　　public $kraftstoff;
　　　　protected $engine;
　　　　private $transmission;
}
class Car extends Automobile
{
　　　　//　Konstruktor
　　　　public function __construct(){
　　　　　　　　echo '　类　"' . __CLASS__ . '" 已启动<br>;
　　　　}
}
　
//Objekt aus der Klasse Automobile erstellen
$automobile = new Automobile;
　
//Versuchen Sie, die Eigenschaft des $automobile-Objekts zu setzen
$automobile->kraftstoff = 'Benzin';　//　ok
$automobile->engine = '1500 cc';　//　tödlicher Fehler
$automobile->transmission = 'Manual';　//　tödlicher Fehler
　
//Objekt von der Car-Klasse erstellen
$car = new Car;
　
//Versuchen Sie, die Eigenschaft des $car-Objekts zu setzen
$car->fuel = 'Diesel';　//　ok
$car->engine = '2200 cc';　//　tödlicher Fehler
$car->transmission = 'Automatic';　//　undefined
?>

Statische Eigenschaften und Methoden

Abgesehen von Sichtbarkeit können Eigenschaften und Methoden auch als static (statisch) erklärt werden, was bedeutet, dass sie ohne Instanz der Klasse erreicht werden können. Statische Eigenschaften und Methoden können wie folgt mit dem Range-Resolution-Operator (::) erreicht werden: ClassName::$property und ClassName::method().

Obwohl statische Methoden verwendet werden können, können statisch erklärte Eigenschaften, wie im folgenden Beispiel gezeigt, nicht über das Objekt der Klasse erreicht werden:

<?php
//Klassendefinition
class HelloClass
{
　　　　//Erklärung statischer Eigenschaften
　　　　public static $greeting = "Hello World!";
　　　　
　　　　//Erklärung statischer Methoden
　　　　public static function sayHello(){
　　　　　　　　echo self::$greeting;
　　　　}
}
//Versuchen Sie, statische Eigenschaften und Methoden direkt zu erreichen
echo HelloClass::$greeting;　//Ausgabe: Hello World!
HelloClass::sayHello();　//Ausgabe: Hello World!
　
//Versuchen Sie, statische Eigenschaften und Methoden über das Objekt zu erreichen
$hello = new HelloClass;
echo $hello->greeting;　//　Strikte Warnung
$hello->sayHello();　//Ausgabe: Hello World!
?>

Im obigen Beispiel bedeutet das Schlüsselwort self "aktuelle Klasse". Es darf niemals mit einem Dollarzeichen ($) beginnen und beginnt immer mit dem operator :: (z.B. self :: $ name).

Das Schlüsselwort self ist anders als das Schlüsselwort this, es bedeutet "aktuelles Objekt" oder "aktuelle Instanz der Klasse". Dieses Schlüsselwort beginnt immer mit einem Dollarzeichen ($) gefolgt von-> Operator (z.B. $ this-> name）。

Wir hoffen, dass Sie jetzt die Grundkonzepte der objektorientierten Programmierung verstanden haben. Sie finden weitere Beispiele zur OOP im PHP und MySQL Datenbankkapitel.