PHP-Grundlagen-Tutorial neun Klassen und Objekte

Inhalt in diesem Abschnitt erklärt

• Klassen und Objekte

• Die Zusammensetzung von Klassen

• Erstellung von Objekten

• PHP-Garbage-Collection-Mechanismus

• $diese Erklärung

Vorwort

PHP ist eine objektorientierte Programmiersprache. Was ist also objektorientiert? Warum sollten wir objektorientiert sein? Es gibt viele Dinge in unserem Leben, die Gegenstände sind, wie zum Beispiel eine Tasse, eine Schachtel usw. Sie alle haben ihre eigenen einzigartigen Eigenschaften und sind alle Gegenstände. Und auch unsere Entwicklung in der Entwicklung basiert auf objektorientierter Programmierung. Ein Objekt ist alles, was Menschen studieren möchten, von den einfachsten ganzen Zahlen bis hin zu komplexen Flugzeugen. Unsere Verwendung der objektorientierten Programmierung kann es uns ermöglichen, das Problem umfassend zu betrachten, und sie ist auch förderlich für die Verwaltung und Pflege von Daten. In PHP kann die objektorientierte Programmierung in zwei Kategorien unterteilt werden: Die eine sind Modelle, die Objekte erstellen zum Gebrauch, und das andere sind Objekte, die mithilfe von Modellen erstellt wurden. Welche Beziehung besteht also zwischen den beiden?

Klassen und Objekte

Klassen und Objekte: Die Abstraktion von Objekten mit gleichen Eigenschaften (Datenelementen) und Verhalten (Funktionen) ist eine Klasse. Daher ist die Abstraktion eines Objekts eine Klasse und die Konkretisierung einer Klasse ein Objekt. Man kann auch sagen, dass eine Instanz einer Klasse ein Objekt ist und eine Klasse tatsächlich ein Datentyp ist.

Das heißt, das Extrahieren der Funktionen und Eigenschaften des Objekts zur Bildung einer Klasse ähnelt dem Extrahieren des Modells einer Tasse, und wir können basierend auf diesem Modell (das) verschiedene Tassen (auch als Tassen bezeichnet) erstellen ist die Klasse) ist das Objekt).
Wie werden also Klassen definiert? Wie entstehen Objekte?

Zusammensetzung einer Klasse

<?php

    class Cat{ //定义一个猫类
        public $name; //猫的名字
        public $age;//猫的名字
        public $color;//猫的颜色
        //猫的构造方法
        public function __construct(){

        }

        public function sleep(){
            echo &#39;猫睡觉&#39;;
        }

        public function eat(){
            echo &#39;猫吃饭&#39;;
        }

    }

Das Obige ist die Grundstruktur einer Klasse. Nachfolgend erklären wir die Bedeutung jedes Teils im Detail.

• class ist ein Schlüsselwort und kann nicht geändert werden, was darauf hinweist, dass es sich um eine Klasse handelt.

• Katze ist der Klassenname. Der Klassenname wird mit einem Großbuchstaben geschrieben und in Kamelbuchstaben benannt.

Klassenattribute

Attribute: Mitgliedsattribute sind eine Komponente der Klasse, im Allgemeinen grundlegende Datentypen (Ganzzahlen, Zeichenfolgen usw.). Es kann sich auch um einen zusammengesetzten Typ (Objekt, Array) oder Ressourcentyp handeln. Beispielsweise ist das öffentliche $age der zuvor definierten Klasse cat ein Mitgliedsattribut.

Man kann sagen, dass die Attribute einer Klasse die Merkmale einer Klasse sind. Beispielsweise kann eine Katze einen Namen, ein Alter, eine Farbe usw. haben, die gemeinsame Merkmale sind Katzen. Wir nennen dieses Feature in einer Klasse ein Attribut. Natürlich müssen wir kein Attribut definieren. Dies hängt von Ihren Bedürfnissen ab.

Die Öffentlichkeit vor dem Attribut ist ein Berechtigungsmodifikator, der später erläutert wird.

Member-Methode (Funktion)

Im obigen Code können Sie sehen, dass es in der Klasse mehrere Funktionen gibt. Sie sind mit den vorherigen Funktionen identisch, aber Davor befindet sich ein zusätzliches Berechtigungskontrollzeichen. Es kann auch als Mitgliedsmethode bezeichnet werden. Die obige Klasse hat beispielsweise das Verhalten „Schlafen“ und „Fressen“.

Syntax der Mitgliedsmethode:

访问修饰符  function  函数名(形式参数){
    //函数体;
    //return 返回值;
}

• Zugriffsmodifikator, es gibt drei Typen (öffentlich, geschützt, privat), der Standardwert ist öffentlich, wir werden ihn in erklären Details später

• Andere Teile sind die gleichen wie die Funktionen, die wir gelernt haben, einschließlich des Aufrufmechanismus

• Die Parameterliste kann mehrere haben und kann sein jeglicher Art

• Der Rückgabewert der Methode kann von den spezifischen Anforderungen abhängen.

• Member-Methoden werden in der Klasse definiert. Wenn sie außerhalb der Klasse definiert werden, entsprechen sie nicht dem Verhalten dieser Klasse.

Konstruktor

In der obigen Cat-Klasse gibt es eine Methode, der Methodenname ist -__construct(), das ist also ein Konstruktor Was ist es ein Konstruktor? Der Konstruktor ist eine Methode zum Initialisieren von Daten beim Erstellen eines Objekts. Wenn wir beispielsweise beim Erstellen eines Objekts direkt den Namen, das Alter und die Farbe der Katze angeben möchten, können wir den Konstruktor verwenden.

public function __construct($name,$age,$color){
            $this-> name = $name;
            $this-> age = $age;
            $this-> color = $color;
}

Die Syntax des Konstruktors lautet:

public  function  __construct(形式参数){  
    //函数体
}

Der Methodenname des Konstruktors __construct() ist eine magische Methode, die später vorgestellt wird Tatsächlich ist der Konstruktor auch Es gibt eine Möglichkeit, den Methodennamen des Konstruktors als Namen der Klasse zu schreiben:

public function Cat($name,$age,$color){

}

Die obige Methode zum Definieren der Konstruktormethode ist ebenfalls korrekt, wird jedoch empfohlen Verwenden Sie die magische Methode (__construct ()) und denken Sie so: Wenn sich unser Klassenname ändert, müssen Sie ihn nicht ändern.

HinweisDie Namen von Klassen in PHP unterscheiden nicht zwischen Groß- und Kleinschreibung, wir müssen sie aber trotzdem in Groß- und Kleinschreibung schreiben. Gleichzeitig hat der Konstruktor keinen Rückgabewert.

Konstrukteure müssen Folgendes beachten:

• In einer Klasse kann es nur einen Konstruktor geben, dies ist eine zwingende Voraussetzung

• Der

  -Konstruktor wird automatisch vom System aufgerufen, sodass wir ihn nicht selbst anpassen müssen.

• Wenn wir keinen Konstruktor definieren, verwendet das System einen Standardkonstruktor mit der folgenden Form: öffentliche Funktion

• __construct(){ }, also unabhängig davon, ob wir einen Konstruktor definiert haben oder nicht, es hat einen Konstruktor.

上面的三种情况就是类中大致的内容，在后续我们还会降类中的其他情况。

对象的创建

在上面创建对象的类已经有了，那么怎么创建对象呢？

对象创建方法

$cat = new Cat();

创建对象的语法是：

$对象名 = new 类名(参数1,参数2);

类名后面的括号里的参数是传递给类的构造函数的，如果构造函数没有参数，可以不写。

• 对象的命名规范和普通变量一样，使用驼峰法或者下划线法均可

• new也是一个关键字，不能修改，表示新创建对象

我们创建对象的目的就是需要操作对象，而操作对象，就是操作对象里面的属性和方法。

在上面的类下面写如下代码：

//创建对象，传递三个参数到构造函数。
$cat = new Cat('小花',12,'black');
//通过对象来访问对象的属性
echo $cat -> name;
echo &#39;<br>&#39;;
echo $cat -> age;
echo &#39;<br>&#39;;
echo $cat -> color;
echo &#39;<br>&#39;;
$cat-> sleep();
$cat-> eat();
.....结果......
小花
12
black
猫睡觉
猫吃饭

上面的对象通过->访问属性和方法。注意属性的前面没有$符号。

$对象名->属性名= 值；
echo  $对象名->属性名;
'-> ' 称为对象运算符.

上面的就是对象的创建和最基本的应用

对象的传递类型

当我们把对象的值赋给另外一个变量是，是值传递还是引用传递？

    //创建一个对象
    $cat = new Cat('小花',12,'black');
    $cat1 = $cat; // 把$cat这个对象赋给$cat1;
    $cat1 -> name = '小白';//利用$cat1这个对象修改对象的名字。
    echo $cat1 -> name; //输出$cat1对象的名字。
    echo &#39;<br>&#39;;
    echo $cat -> name; //输出$cat对象的名字。
.....结果......
小白
小白

看到这里可能有点蒙，不是值传递吗？怎么修改一个对象的属性，另外一也变了？，

上面的代码当中 $cat1=$cat也是值传递,但是这个值是对象的引用(可以理解对象标识符)，即每个包含对象的变量都持有对象的引（reference），而不是整个对象的拷贝。

在上面的图中可以看到，当$cat赋值给$cat1时，也就是对象标识符(#1)复制了一份，赋给$cat1，其实他们还是指向同一块数据区，所以只要其中一个修改了值，另外一个也会变。

对象的销毁

我们使用完对象后，已经确定在以后不会使用这个对象了，这个时候我们可以手动的销毁对象，那么我们怎么让对象销毁呢？

1. 当没有任何变量指向对象时，会销毁，因此我们可以把对象引用置为null

2. 使用unset()函数来销毁对象。

   //创建一个对象
   $cat = new Cat('小花',12,'black');
   $cat -> sleep();
   unset($cat);
   $cat -> sleep();
   .....结果.....
   
   猫睡觉
   Notice: Undefined variable: cat in D:\mywamp\Apache24\htdocs\zendstudio\yunsuanfu\object.php on line 27
   
   Fatal error: Call to a member function sleep() on null in D:\mywamp\Apache24\htdocs\zendstudio\yunsuanfu\object.php on line 27

   其实在一个文件运行完的时候，PHP会启动垃圾回收机制，自动的进行垃圾回收。这时候在里面创建的对象就自动销毁了，那么什么是PHP的垃圾回收机制？

PHP垃圾回收机制

垃圾回收，顾名思义，回收垃圾的，在程序中启动垃圾回收机制的时机：

• 在php中，当一个对象没有任何引用指向它的时候，就会成为一个垃圾对象，php将启动垃圾回收器将对象销毁。

• 当程序退出前，php也将启用垃圾回收器，销毁对象。

那么什么是垃圾回收机制？

垃圾回收机制是php5之后才有的，php5.3之前使用的垃圾回收机制是单纯的“引用计数”，也就是每个内存对象都分配一个计数器，当内存对象被变量引用时，计数器+1；当变量引用撤掉后，计数器-1；当计数器=0时，表明内存对象没有被使用，该内存对象则进行销毁，垃圾回收完成。但是PHP5.3开始，使用了新的垃圾回收机制，在引用计数基础上，实现了一种复杂的算法，来检测内存对象中引用环的存在(对象的相互引用)，以避免内存泄漏。

$this说明

在上面写类的构造函数的时候，可以看到在函数中使用到了$this，那么在面向对象中$this是什么？

$this是在类中使用的访问自身的一种机制。系统会给每个对象分配$this,代表当前对象。通俗的说就是在当前环境下，谁调用，$this就代表哪个对象。

<?php

    class Cat{ //定义一个猫类
        public $name; //猫的名字
        public $age;//猫的名字
        public $color;//猫的颜色
        //猫的定义方法
        public function Cat($name,$age,$color){
            $this-> name = $name;
            $this-> age = $age;
            $this-> color = $color;
        }

        public function sleep(){
            echo &#39;猫睡觉<br>&#39;;
        }

        public function eat(){
            echo &#39;猫吃饭<br>&#39;;
        }
        //输出猫的信息
        public function info(){
            echo &#39;猫的名字是&#39; . $this -> name . &#39; 年龄是&#39; . $this-> age . &#39; 颜色是&#39; . $this-> color;
        }

    }
    //创建一个对象
    $cat = new Cat(&#39;小花&#39;,12,&#39;black&#39;);
    $cat -> info();
    echo &#39;<br>&#39;;
    //创建另一个对象，传进不同的属性
    $cat1 = new Cat(&#39;小白&#39;,6,&#39;white&#39;);
    $cat1 -> info();
    .....结果.....
猫的名字是小花 年龄是12 颜色是black
猫的名字是小白 年龄是6 颜色是white

在上面的类中的info()函数中使用$this，不同的对象输出不同的结果，因为在不同的环境下，谁调用，$this就代表哪个对象。

类的析构函数

在上面我们提到过，对象的销毁，其实在类中有一个方法，就是在对象销毁的时候由系统自动执行的。我们称之为析构函数。

public function __destruct(){
        echo $this->name . &#39;被销毁了<br>&#39;;
}

在PHP5中引入了析构函数的概念，析构函数会在某个对象的所有引用被删除（没有变量指向对象，要被销毁了），对象销毁前执行。

析构函数的主要作用是去释放对象分配的相关资源，比如数据库连接或打开的文件等。

它的语法是：

function  __destruct(){
    //函数体[释放资源，比如数据库连接，或者打开文件等等]
}

析构函数也是系统自动调用的，我们不用自己调。但是当我们没有写析构函数的时候，系统不会执行析构函数。

<?php

class Cat{ //定义一个猫类
    public $name; //猫的名字
    public $age;//猫的名字
    public $color;//猫的颜色
    //猫的定义方法
    public function Cat($name,$age,$color){
        $this-> name = $name;
        $this-> age = $age;
        $this-> color = $color;
    }

    public function sleep(){
        echo &#39;猫睡觉<br>&#39;;
    }

    public function eat(){
        echo &#39;猫吃饭<br>&#39;;
    }
    //输出猫的信息
    public function info(){
        echo &#39;猫的名字是&#39; . $this -> name . &#39; 年龄是&#39; . $this-> age . &#39; 颜色是&#39; . $this-> color;
    }

    public function __destruct(){
        echo $this->name . &#39;被销毁了<br>&#39;;
    }

}
//创建一个对象
$cat = new Cat(&#39;小花&#39;,12,&#39;black&#39;);
echo $cat -> name; //输出对象的名字
echo &#39;<br>&#39;;
unset($cat); //销毁对象，系统自动调用析构函数。
.....结果......
小花
小花被销毁了

当我们销毁对象$cat时，析构函数自动执行。

• Der Destruktor wird automatisch ausgeführt, bevor das Objekt zerstört wird, und er hat keinen Rückgabewert. Es kann nur einen Destruktor in einer Klasse geben.

• Der Destruktor zerstört die vom Objekt erstellten Ressourcen, nicht das Objekt selbst, das durch den Garbage-Collection-Mechanismus zerstört wird.

Wenn wir mehrere Objekte in einer Datei erstellen und die Datei ausgeführt wird, werden die zuerst erstellten Objekte zuerst und die später erstellten Objekte zuerst zerstört Das Prinzip und das Stack-Prinzip sind sehr ähnlich: First In, Last Out, Last In, First Out.

Zusammenfassung

Durch die obige Erklärung von Klassen und Objekten können wir die Unterschiede und Verbindungen zwischen Klassen und Objekten erkennen. Klassen sind abstrakt und stellen eine Art von Dingen dar, beispielsweise Katzen. Objekte sind konkret und repräsentieren eine bestimmte Sache. Eine Klasse ist eine Vorlage für ein Objekt und ein Objekt ist eine Instanz einer Klasse. Gleichzeitig muss die grundlegende Zusammensetzung der Klasse beherrscht werden.

Das Obige ist der Inhalt des PHP-Basis-Tutorials neun und der Objekte. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!