Detaillierte Erklärung der PHP-Klassen und objektorientiert

Dieser Artikel teilt Ihnen hauptsächlich die grundlegenden Teile von PHP mit, detaillierte Erklärungen zu PHP-Klassen und objektorientiert, es gibt insgesamt zehn Punkte, ich hoffe, es kann jedem helfen.

1. PHP-Klassen und -Objekte

<?php//定义一个类class Car {
    var $name = &#39;汽车&#39;;    function getName() {
        return $this->name;
    }
}//实例化一个car对象$car = new Car();$car->name = &#39;奥迪A6&#39;; 
//设置对象的属性值echo $car->getName();  //调用对象的方法 输出对象的名字

3. In einer Klasse definierte Variablen werden Attribute genannt, normalerweise sind Attribute dieselben wie Felder in der Datenbank Da es eine gewisse Korrelation gibt, kann man es auch als „Feld“ bezeichnen. Eine Eigenschaftsdeklaration beginnt mit den Schlüsselwörtern public, protected oder private, gefolgt von einer gewöhnlichen Variablendeklaration. Attributvariablen können mit einem Standardwert initialisiert werden, und der Standardwert muss eine Konstante sein.

Die Bedeutung der Zugriffskontrollschlüsselwörter ist:

4. Klassenmethoden

public：公开的 protected：受保护的 private：私有的
class Car {    //定义公共属性    public $name = '汽车';   
 //定义受保护的属性    protected $corlor = '白色';    
 //定义私有属性    private $price = '100000';}
默认都为public，外部可以访问。一般通过->对象操作符来访问对象的属性或者方法，对于静态属性则使用::双冒号进行访问。当在类成员方法内部调用的时候，可以使用$this伪变量调用当前对象的属性。
$car = new Car();echo $car->name;   
//调用对象的属性echo $car->color;  //错误 受保护的属性不允许外部调用echo $car->price;  //错误 私有属性不允许外部调用
受保护的属性与私有属性不允许外部调用，在类的成员方法内部是可以调用的。
class Car{    private $price = '1000';    public function getPrice() {        return $this->price; //内部访问私有属性    }}

Methoden sind Funktionen in der Klasse . Was ist der Unterschied zwischen einer Methode und einer Funktion? In der prozessorientierten Programmierung wird eine Funktion als Funktion bezeichnet, und in der objektorientierten Programmierung wird eine Funktion als Methode bezeichnet.

Wie Attribute verfügen auch Klassenmethoden über eine öffentliche, geschützte und private Zugriffskontrolle.

Die Bedeutung von Zugriffskontrollschlüsselwörtern ist:

öffentlich: öffentlich

geschützt: geschützt
privat: privat

Wir können die Methode wie folgt definieren

5. Konstruktor und Destruktor

class Car {    public function getName() {        return '汽车';    }}$car = new Car();echo $car->getName();
使用关键字static修饰的，称之为静态方法，静态方法不需要实例化对象，可以通过类名直接调用，操作符为双冒号::。
class Car {    public static function getName() {        return '汽车';    }}echo Car::getName(); //结果为“汽车”

Wenn der PHP-Code ausgeführt wird, wird das Objekt automatisch recycelt und zerstört, sodass unter normalen Umständen keine Notwendigkeit besteht, das Objekt explizit zu zerstören.

PHP5可以在类中使用__construct()定义一个构造函数，具有构造函数的类，会在每次对象创建的时候调用该函数，因此常用来在对象创建的时候进行一些初始化工作。
class Car {   function __construct() {       print "构造函数被调用\n";   }}$car = new Car(); 
//实例化的时候 会自动调用构造函数__construct，这里会输出一个字符串
在子类中如果定义了__construct则不会调用父类的__construct，如果需要同时调用父类的构造函数，需要使用parent::__construct()显式的调用。
class Car {   function __construct() {       print "父类构造函数被调用\n";   }}class Truck extends Car {   function __construct()
 {       print "子类构造函数被调用\n";       parent::__construct();   }}$car = new Truck();
同样，PHP5支持析构函数，使用__destruct()进行定义，析构函数指的是当某个对象的所有引用被删除，或者对象被显式的销毁时会执行的函数。
class Car {   function __construct() {       print "构造函数被调用 \n";   }   function __destruct()
 {       print "析构函数被调用 \n";   }}$car = new Car(); //实例化时会调用构造函数echo '使用后，准备销毁car对象 \n';unset($car); //销毁时会调用析构函数

6. Statisches Schlüsselwort

Statische Eigenschaften und Methoden können ohne Instanziierung der Klasse aufgerufen werden und können direkt mit dem Klassennamen::Methodennamen aufgerufen werden. Statische Eigenschaften erlauben keinen Aufruf von Objekten mit dem ->-Operator.

In statischen Methoden darf die Pseudovariable $this nicht verwendet werden. Sie können self, parent und static verwenden, um statische Methoden und Eigenschaften intern aufzurufen.

class Car {    private static $speed = 10;    
public static function getSpeed() 
{        return self::$speed;    }}echo Car::getSpeed();  //调用静态方法
静态方法也可以通过变量来进行动态调用
$func = 'getSpeed';$className = 'Car';echo $className::$func();  //动态调用静态方法

7. Zugriffskontrolle

class Car {
    private static $speed = 10;    public static function getSpeed() {
        return self::$speed;
    }    public static function speedUp() {
        return self::$speed+=10;
    }
}class BigCar extends Car {
    public static function start() {
        parent::speedUp();
    }
}
BigCar::start();echo BigCar::getSpeed();

Im vorherigen Abschnitt haben wir die Zugriffskontrolle bereits durch die Schlüsselwörter public, protected und privat angesprochen. Auf Klassenmitglieder, die als öffentlich definiert sind, kann von überall aus zugegriffen werden. Auf ein als geschützt definiertes Klassenmitglied kann von ihm selbst, seinen Unterklassen und seiner übergeordneten Klasse zugegriffen werden. Als privat definierte Klassenmitglieder können nur von der Klasse aufgerufen werden, in der sie definiert sind.

Klassenattribute müssen als öffentlich, geschützt oder privat definiert werden. Aus Kompatibilitätsgründen mit Versionen vor PHP5 gilt es als öffentlich, wenn es mit var definiert wird.

8. Objektvererbung

class Car {
   $speed = 10; //错误 属性必须定义访问控制
   public $name;   //定义共有属性}
类中的方法可以被定义为公有、私有或受保护。如果没有设置这些关键字，则该方法默认为公有
class Car {
   //默认为共有方法
   function turnLeft() {
   }
}
如果构造函数定义成了私有方法，则不允许直接实例化对象了，这时候一般通过静态方法进行实例化，在设计模式中会经常使用这样的方法来控制对象的创建，比如单例模式只允许有一个全局唯一的对象。
class Car {
   private function __construct() {
       echo 'object create';
   }    private static $_object = null;    public static function getInstance() {
       if (empty(self::$_object)) {            self::$_object = new Car(); //内部方法可以调用私有方法，因此这里可以创建对象
       }        return self::$_object;
   }
}//$car = new Car(); //这里不允许直接实例化对象$car = Car::getInstance(); //通过静态方法来获得一个实例

Vererbung ist eine relativ große Klasse. Darüber hinaus können wir sie auch als Basisklasse bezeichnen Darüber hinaus werden Autos auch in Lastkraftwagen, Autos, Dongfeng, BMW usw. unterteilt. Da diese Unterklassen viele der gleichen Attribute und Methoden haben, können Sie die Autoklasse erben, um diese Attribute und Methoden gemeinsam zu nutzen und eine Wiederverwendung des Codes zu erreichen.

9. Überladen

class Car {
    public $speed = 0; //汽车的起始速度是0
    public function speedUp() {
        $this->speed += 10;        return $this->speed;
    }
}//定义继承于Car的Truck类class Truck extends Car{
    public function speedUp(){
        $this->speed = parent::speedUp() + 50;
    }
}

Überladen bezieht sich in PHP auf die dynamische Erstellung von Eigenschaften und Methoden, die durch magische Methoden erreicht wird. Beim Überladen von Attributen werden __set, __get, __isset und __unset verwendet, um die Zuweisung zu implementieren, zu lesen, zu bestimmen, ob das Attribut festgelegt ist, bzw. das Attribut zu zerstören, wenn es nicht vorhanden ist.

10. Erweiterte Eigenschaften von Objekten Objektvergleich: Wenn alle Attribute zweier Instanzen derselben Klasse gleich sind, können Sie den Vergleichsoperator == verwenden, um zu beurteilen. Wenn Sie beurteilen müssen, ob zwei Variablen auf dasselbe Objekt verweisen, können Sie den Kongruenzoperator == verwenden = Bilden Sie ein Urteil.

class Car {
   private $ary = array();    public function __set($key, $val) {
       $this->ary[$key] = $val;
   }    public function __get($key) {
       if (isset($this->ary[$key])) {            return $this->ary[$key];
       }        return null;
   }    public function __isset($key) {
       if (isset($this->ary[$key])) {            return true;
       }        return false;
   }    public function __unset($key) {
       unset($this->ary[$key]);
   }
}$car = new Car();$car->name = '汽车';  //name属性动态创建并赋值echo $car->name;
方法的重载通过__call来实现，当调用不存在的方法的时候，将会转为参数调用__call方法，当调用不存在的静态方法时会使用__callStatic重载。
class Car {
   public $speed = 0;    public function __call($name, $args) {
       if ($name == 'speedUp') {            $this->speed += 10;
       }
   }
}$car = new Car();$car->speedUp(); //调用不存在的方法会使用重载echo $car->speed;

Verwandte Empfehlungen:

class Car {}$a = new Car();$b = new Car();if ($a == $b) echo '==';   //trueif ($a === $b) echo '==='; //false
对象复制，在一些特殊情况下，可以通过关键字clone来复制一个对象，这时__clone方法会被调用，通过这个魔术方法来设置属性的值。
class Car {
   public $name = 'car';    public function __clone() {
       $obj = new Car();        $obj->name = $this->name;
   }
}$a = new Car();$a->name = 'new car';$b = clone $a;
var_dump($b);
对象序列化，可以通过serialize方法将对象序列化为字符串，用于存储或者传递数据，然后在需要的时候通过unserialize将字符串反序列化成对象进行使用
class Car {
   public $name = 'car';
}$a = new Car();$str = serialize($a); //对象序列化成字符串echo $str.'
';$b = unserialize($str); //反序列化为对象var_dump($b);

Auto-Loading-Implementierungsmethode der PHP-Klasse

Detaillierte Erläuterung des Abhängigkeitsinjektionsprozesses der Reflexion Implementierung der PHP-Klasse

Prinzipien des automatischen Ladens der PHP-Klasse und des PHP-Kettenbetriebs

Das obige ist der detaillierte Inhalt vonDetaillierte Erklärung der PHP-Klassen und objektorientiert. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!