PHP-Studiennotizen objektorientiert

public Öffentlich: Diese Klasse, Unterklassen und externe Objekte können alle aufgerufen werden.
protected Geschützt: Unterklassen dieser Klasse können ausgeführt werden, externe Objekte können nicht aufgerufen werden.
private: Nur diese Klasse wird ausgeführt. Unterklassen und externe Objekte können nicht aufgerufen werden genannt werden
Drei Hauptmerkmale der objektorientierten Programmierung

1) Schließung

Schließung, die auch als Informationsverbergung bezeichnet werden kann. Es geht darum, die Verwendung und Implementierung einer Klasse zu trennen, so dass nur begrenzte Schnittstellen (Methoden) für die Verbindung mit der Außenwelt übrig bleiben. Entwickler, die diese Klasse verwenden, müssen nur wissen, wie diese Klasse verwendet wird, und müssen sich nicht darum kümmern, wie diese Klasse implementiert wird. Dadurch können sich Entwickler besser auf andere Dinge konzentrieren und vermeiden gleichzeitig Unannehmlichkeiten, die durch gegenseitige Abhängigkeiten zwischen Programmen entstehen.

2) Vererbung

Vererbung bedeutet, dass eine abgeleitete Klasse (Unterklasse) automatisch die Attribute und Methoden in einer oder mehreren Basisklassen (Elternklassen) erbt und diese überschreiben oder neue Eigenschaften hinzufügen kann und Methoden. Vererbung vereinfacht die Erstellung von Objekten und Klassen und erhöht die Reproduzierbarkeit des Codes. Die Vererbung ist in Einzelvererbung und Mehrfachvererbung unterteilt. PHP unterstützt Einzelvererbung, das heißt, eine Unterklasse hat und hat nur eine übergeordnete Klasse.

3) Polymorphismus

Polymorphismus bedeutet, dass verschiedene Objekte derselben Klasse mit derselben Methode unterschiedliche Ergebnisse erzielen können. Diese Technologie wird Polymorphismus genannt. Polymorphismus erhöht die Flexibilität und Wiederverwendbarkeit der Software.

Definition einer Klasse

Eine Klasse kann ihre eigenen Konstanten, Variablen (genannt „Eigenschaften“) und Funktionen (genannt „Methoden“) enthalten.
Wie viele objektorientierte Sprachen definiert auch PHP Klassen über das Schlüsselwort class und den Klassennamen. Das Format der Klasse ist wie folgt:

Der Code lautet wie folgt:

<?php
  Class myobject{
    //……
    }
?>

Definition: Gleiche Vögel scharen sich zusammen und Objekte mit ähnlichen Eigenschaften werden in einer Klasse gruppiert. Die Klasse definiert dieselben Attribute und Attribute, die diese ähnlichen Objekte besitzen. Eine Klasse ist eine Beschreibung ähnlicher Objekte, die sogenannte Klassendefinition, die den Entwurf oder Prototyp des Objekts dieser Klasse darstellt.

Ein Objekt einer Klasse wird als Instanz der Klasse bezeichnet. Um eine Instanz einer Klasse zu erstellen, muss das Schlüsselwort new verwendet werden.

<?php
//类的定义以关键字class开始，类的命名通常以每个单词第一个字母大写
    class NbaPlayer{
        public $name = "Jordan"; //定义属性
        public $height = "198cm";
        public $team = "Bull";
        public $playerNumber = "23";
        //定义方法
    public function run(){
        echo "Running\n";
    }
    public function dribblr(){
        echo "Dribbling\n";
    }
    public function pass(){
        echo "Passing\n";
    }
}
    //类到对象的实例化
    //类的实例化为对象时使用关键字new，new之后紧跟类的名称和一对括号
    $jordan = new NbaPlayer(); 
    //对象中的属性成员可以通过"->"符号来访问
    echo $jordan->name."\n";
    //对象中的成员方法可以通过"->"符号来访问
    $jordan->dribble();
    $jordan->run();
?>

Member-Methoden

Funktionen in einer Klasse werden Member-Methoden genannt. Der einzige Unterschied zwischen Funktionen und Mitgliedsmethoden besteht darin, dass Funktionen eine unabhängige Funktion implementieren, während Mitgliedsmethoden ein Verhalten in der Klasse implementieren und Teil der Klasse sind.
Erweitern wir die obige Myobject-Klasse und fügen ihr eine Mitgliedsmethode hinzu. Der Code lautet wie folgt:

<?php
classmyobject{
   function getobjectname($name){
      echo "商品名称为：".$name;
   }
}
?>

Die Funktion dieser Methode besteht darin, den Produktnamen auszugeben, der über übergeben wird Parameter der Methode.
Eine Klasse ist eine abstrakte Beschreibung, eine Sammlung von Objekten mit ähnlichen Funktionen. Wenn Sie die Methoden und Variablen in der Klasse verwenden möchten, müssen Sie diese zunächst in eine Entität, also ein Objekt, implementieren.

Klassenkonstanten
Da es Variablen gibt, gibt es natürlich auch Konstanten. Eine Konstante ist eine Größe, die sich nicht ändert und ein konstanter Wert ist. Eine bekannte Konstante ist Pi. Um Konstanten zu definieren, verwenden Sie das Schlüsselwort const, wie zum Beispiel:
ConstPI=3.14159;

Constructor

PHP 5 ermöglicht Entwicklern, eine Methode als Konstruktor in einer Klasse zu definieren. Klassen mit einem Konstruktor rufen diese Methode jedes Mal auf, wenn ein neues Objekt erstellt wird. Sie eignet sich daher sehr gut für einige Initialisierungsarbeiten vor der Verwendung des Objekts.

Destruktor

<?php
//类的定义以关键字class开始，类的命名通常以每个单词第一个字母大写
    class NbaPlayer{
        public $name = "Jordan"; //定义属性
        public $height = "198cm";
        public $team = "Bull";
        public $playerNumber = "23";
        //构造函数，在对象被实例化的时候自动调用
        function __construct($name,$height,$weight,$team){
            echo "It is an  NbaPlayer constructor\n";
            $this->name = $name;
            //$this是PHP里面的伪变量，表示对象自身。可以通过$this->的方式访问对象的属性和方法
            $this->height = $height;
            $this->weight = $weight;
            $this->team = $team;
        }
        //定义方法
    public function run(){
        echo "Running\n";
    }
    public function dribblr(){
        echo "Dribbling\n";
    }
    public function pass(){
        echo "Passing\n";
    }
}
    //类到对象的实例化
    //类的实例化为对象时使用关键字new，new之后紧跟类的名称和一对括号
    $jordan = new NbaPlayer("Jordan","198cm","98kg","Bull");   
    //对象中的属性成员可以通过"->"符号来访问
    echo $jordan->name."\n";
    //对象中的成员方法可以通过"->"符号来访问
    $jordan->dribble();
    $jordan->run();
    //每一次用new实例化对象的时候，都会用类名后面的参数列表调用构造函数
    $james = new NbaPlayer("James","203cm","120kg","Heat")
    echo $james->name."\n";
?>

Ein Destruktor tritt auf, wenn alle Verweise auf ein Objekt gelöscht wurden oder wenn das Objekt explizit zerstört wird.

Referenz des Objekts

<?php
//类的定义以关键字class开始，类的命名通常以每个单词第一个字母大写
    class NbaPlayer{
        public $name = "Jordan"; //定义属性
        public $height = "198cm";
        public $team = "Bull";
        public $playerNumber = "23";

        //构造函数，在对象被实例化的时候自动调用
        function __construct($name,$height,$weight,$team){
            echo "It is an  NbaPlayer constructor\n";
            $this->name = $name;
            //$this是PHP里面的伪变量，表示对象自身。可以通过$this->的方式访问对象的属性和方法
            $this->height = $height;
            $this->weight = $weight;
            $this->team = $team;
        }
        //析构函数，在程序执行结束的时候会自动调用
        //析构函数通常被用于清理程序使用的资源。比如程序使用了打印机，那么可以再析构函数里面释放打印机资源
        function __destruct(){
            echo "Destroying".$this->name."\n";
        }
        //定义方法
    public function run(){
        echo "Running\n";
    }
    public function dribblr(){
        echo "Dribbling\n";
    }
    public function pass(){
        echo "Passing\n";
    }
}
    //类到对象的实例化
    //类的实例化为对象时使用关键字new，new之后紧跟类的名称和一对括号
    $jordan = new NbaPlayer("Jordan","198cm","98kg","Bull");   
    //对象中的属性成员可以通过"->"符号来访问
    echo $jordan->name."\n";
    //对象中的成员方法可以通过"->"符号来访问
    $jordan->dribble();
    $jordan->run();
    //每一次用new实例化对象的时候，都会用类名后面的参数列表调用构造函数
    $james = new NbaPlayer("James","203cm","120kg","Heat")
    echo $james->name."\n";
    //对象的引用用于访问对象的属性和方法，$james,$james1和$james2都是对象的引用
    //$james和$james1是对象的两个独立引用
    //$james2是$james的影子，使用对象的同一个引用，任何一个赋值为null相当于删除了同一个引用
    $james1 = $james;
    $james2 = &$james
    $james = null;
    echo "from now on James will not be used.\n"
?>