PHP-Studiennotizen – objektorientierte PHP-Grundlagen

Objektorientiert ist eine Computerprogrammierungsarchitektur, die flexibler und skalierbarer ist als prozedurale Bearbeitung. Ich möchte Anfänger hier daran erinnern: Wer auf dem Weg des Programmierens weiter vorankommen will als andere, muss die objektorientierte Programmiertechnologie beherrschen.

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 kann ausgeführt werden, und weder Unterklassen noch externe Objekte können aufgerufen 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:

Kopieren Sie den Code Der Code lautet wie folgt:

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

Definition: Wie ein Gleichgesinnter scharen sich Objekte mit ähnlichen Eigenschaften zusammen. In einer Klasse gruppiert, definiert eine Klasse dieselben Eigenschaften und Methoden wie diese ähnlichen Objekte. 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.
001ZpQGYty6MeYnSNUh25&690

Code kopieren Der Code lautet wie folgt:

<?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-Methode

In der Klasse werden Funktionen als Member-Methoden bezeichnet. 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:

Kopieren Sie den Code Der Code lautet wie folgt:

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

Die Funktion dieser Methode besteht darin, den Produktnamen auszugeben, der über die Parameter der Methode übergeben wird.
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. Daher eignet sie sich sehr gut für einige Initialisierungsarbeiten vor der Verwendung des Objekts.

Code kopieren Der Code lautet wie folgt:

<?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";
?>

Destruktor

Code kopieren Der Code lautet wie folgt:

<?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";
    
    //通过把变量设为null，可以触发析构函数的调用
    //当对象不再使用的时候会触发析构函数
    $james = null;
    echo "from now on James will not be used.\n"
?>

Der Destruktor wird ausgeführt, wenn alle Verweise auf ein Objekt gelöscht werden oder wenn das Objekt explizit zerstört wird.

Referenz des Objekts

Code kopieren Der Code lautet wie folgt:

<?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"
?>

Verwandte Empfehlungen:

PHP-objektorientierter Vererbungskonstruktor

Detaillierte Erläuterung der objektorientierten PHP-Bindung

Einige Schlüssel Punkte der objektorientierten Verwendung von PHP-Worten

Das obige ist der detaillierte Inhalt vonPHP-Studiennotizen – objektorientierte PHP-Grundlagen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!