Detaillierte Erläuterung der objektorientierten abstrakten PHP-Klassen (Codebeispiele)

Ziele dieses Artikels:

1. Die Definition abstrakter Klassen in PHP verstehen

3 Funktionen abstrakter Klassen in PHP-Nutzungsszenarien

4. Beherrschen Sie die spezifische Implementierung abstrakter Klassen in PHP

Wir werden weiterhin dem vorherigen konsistenten Denken folgen und durch die 3W1H-Methode lernen, also lernen wir zuerst darüber

(1) Verstehen Sie die Definition abstrakter Klassen in PHP (Was)

Abstrakte Klassen werden häufig zur Charakterisierung der Analyse und verwendet Gestaltung von Problembereichen. Zusammenfassung Konzept ist eine Zusammenfassung für eine Reihe spezifischer Konzepte, die unterschiedlich aussehen, aber im Wesentlichen gleich sind. Die in Programmieranweisungen normalerweise mit Abstract modifizierten Klassen sind abstrakte Klassen. Der Unterschied zwischen

und einer Schnittstelle besteht darin, dass die Methoden in der Schnittstelle nicht implementiert, sondern einfach definiert sind, die Methoden in der abstrakten Klasse jedoch implementiert werden können von.

(2) Verstehen Sie die Rolle abstrakter Klassen in PHP (Warum)

Unter den Klassen in PHP werden viele Klassen ständig neu geschrieben. Dies können wir manchmal verwenden abstrakte Klassen, wie geht das? Das heißt, dass wir zuerst eine öffentliche Klasse schreiben und diese dann nach der Instanziierung wiederholt aufrufen können. Dies kann die Wiederverwendbarkeit des Codes verbessern

(3) Verstehen Sie die Verwendungsszenarien abstrakter Klassen in PHP (Wo)

1 Wenn Sie feststellen, dass es viele Klassen im Code gibt Wenn wir ähnliche oder allgemeine Methoden verwenden, können wir dieselben oder ähnliche Methoden extrahieren und in abstrakte Klassen kapseln.

Abstrakte Klassen und Schnittstellen sind etwas ähnlich. Man kann sagen, dass die Schnittstelle eine spezielle abstrakte Klasse ist, aber die Schnittstelle ist voller abstrakter Methoden (die sogenannte Zusammenfassung bedeutet, dass es keine spezifische Implementierung gibt). aber in der abstrakten Klasse können einige Methoden implementiert werden,

(4) Beherrschen Sie die spezifische Implementierung abstrakter Klassen in PHP (Wie)

Zusammenfassung:

1 Die Definition wird durch eine Zusammenfassung definiert, z. B. durch den abstrakten Klassennamen {}

2. Die Definition der Methode der abstrakten Klasse wird ebenfalls durch eine Zusammenfassung definiert, z. B. durch den abstrakten öffentlichen Funktionsmethodennamen (){}

3. Abstrakte Klassen können nicht instanziiert werden

4. Um eine abstrakte Klasse zu erben, verwenden Sie das Schlüsselwort „extends“

5. Unterklassen abstrakter Klassen müssen Dinge implementieren, die nicht instanziiert sind In der abstrakten Klasse implementiert Alle Methoden, das heißt, alle abstrakten Methoden in der abstrakten Klasse neu schreiben

6. Obwohl die Unterklassen der abstrakten Klasse die in der abstrakten Klasse implementierten Methoden nicht implementieren, Sie können diese Methoden immer noch aufrufen, kombiniert mit Vererbung.

Jede Zusammenfassung wird durch Übung erhalten, um die Zusammenfassung zu demonstrieren Verstehen und jede Zusammenfassung verständlicher machen (5), spezifischer Code

Fall 1,

Praktisches Ziel:

1. Die Definition einer abstrakten Klasse wird durch Zusammenfassung definiert, z. B. durch den Klassennamen einer abstrakten Klasse Definiert durch Zusammenfassung, z. B. abstrakter öffentlicher Funktionsmethodenname (){}

Der spezifische Code lautet wie folgt:

<?php
abstract class Animal{
    abstract public function eat();//抽象方法
    //呼吸
    public function breath(){
        //所有动物的呼吸方法都是一样的，就不需要使用多态了
        echo "呼吸<br/>";
    }
}
?>

Fall 2,

Praktische Ziele: 1. Abstrakte Klassen können nicht instanziiert werden. Der spezifische Code von

lautet wie folgt:

<?php
abstract class Animal{
    abstract public function eat();//抽象方法
    //呼吸
    public function breath(){
        //所有动物的呼吸方法都是一样的，就不需要使用多态了
        echo "呼吸<br/>";
    }
}
$animal = new Animal();
?>

Das laufende Ergebnis ist:

Fatal error: Uncaught Error: Cannot instantiate abstract class Animal in D:\E-class\class-code\classing\index.php:10 Stack trace: #0 {main} thrown in D:\E-class\class-code\classing\index.php on line 10

案例四、

实践目标：

1、要继承一个抽象类，通过关键字extends

2、抽象类的子类必须要实现抽象类中未实现的所有方法，也就是说要重写抽象类中所有abstract的方法

具体代码如下：

<?php
abstract class Animal{
    abstract public function eat();//抽象方法
    //呼吸
    public function breath(){
        //所有动物的呼吸方法都是一样的，就不需要使用多态了
        echo "呼吸<br/>";
    }
}
//定义猴子
class Monkey extends Animal{
    
}
?>

如果Monkey类继承了抽象类，但不实现里面的abstract方法，那么运行结果为：

Fatal error: Class Monkey contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (Animal::eat) in D:\E-class\class-code\classing\index.php on line 13

接下来我们来实现abstract方法

具体代码如下：

<?php
abstract class Animal{
    abstract public function eat();//抽象方法
    //呼吸
    public function breath(){
        //所有动物的呼吸方法都是一样的，就不需要使用多态了
        echo "呼吸<br/>";
    }
}
//定义猴子
class Monkey extends Animal{
    //实现抽象类中的抽象方法
    public function eat(){
        echo "我是猴子类中的eat方法<br/>";
    }
}
$monkey = new Monkey();
$monkey->eat();

?>

运行结果如下：

我是猴子类中的eat方法

案例五、

实践目标：

1、抽象类的子类虽然没有实现抽象类中的已经实现的方法，一样可以调用这些方法，其实结合继承我们可以很好理解这点

具体代码如下：

<?php
abstract class Animal{
    abstract public function eat();//抽象方法
    //呼吸
    public function breath(){
        //所有动物的呼吸方法都是一样的，就不需要使用多态了
        echo "抽象类中的呼吸方法<br/>";
    }
}
//定义猴子
class Monkey extends Animal{
    //实现抽象类中的抽象方法
    public function eat(){
        echo "我是猴子类中的eat<br/>";
    }
}
$monkey = new Monkey();
$monkey->eat();
$monkey->breath();
?>

运行结果如下：

我是猴子类中的eat
抽象类中的呼吸方法

（六）、学以致用

问题：将以下真实场景，用抽象类还原出来

小芳放学回到家中，一进家门，只见心爱的小狗“小爱”马上就对主人摇起了尾巴，小芳笑了笑，走过去，抱起了小狗，最后，小芳和小狗亲了一口

思路分析：

1、对象分析：学生，小狗

2、对象属性分析：结合（现实世界+具体场景）

学生：名称

狗：名称

3、对象方法分析：结合（现实世界+具体场景）

学生：

（1）、放学

（2）、回到家中

（3）、走路

（4）、看

（5）、笑

（6）、抱东西

（7）、亲嘴

狗：

（1）、看

（2）、摇尾巴

（3）、亲嘴

4、我们发现这2个对象都有相似的方法，看，亲嘴，所以我们可以把它们封装到抽象类中，并且这2个方法不需要子类去重写，因为都是一样的

具体代码如下：

<?php
abstract class Animal{
    //看
    public function look($obj){
        //所有动物的呼吸方法都是一样的，就不需要使用多态了
        echo "看见了".$obj->name."<br/>";
    }
    //亲嘴
    public function kiss($fromobj,$toobj){
        echo $fromobj->name."亲了".$toobj->name."一口<br/>";
    }
    
}
//学生
class Student extends Animal{
   public $name = "";
   public function __construct( $name ){
       $this->name = $name;
   }
    // 1、放学
   public function offschool(){
       echo $this->name."放学了<br/>";
   }
   //回家
   public function goHome(){
    echo $this->name."回到家中<br/>";
   }
    // 2、走路
    public function walk(){
        echo $this->name."走了过去<br/>";
    }
    // 3、看

    // 4、笑
    public function smile(){
        echo $this->name."微笑了<br/>";
    }
    // 5、抱东西
    public function hug($obj){
        echo $this->name."抱起了".$obj->name."<br/>";
    }
    // 6、亲嘴
   
}
//狗
class Dog extends Animal{
   public $name = "";
   public function __construct( $name ){
       $this->name = $name;
   }
    //1、看

    //2、摇尾巴
    public function wagTail(){
        echo $this->name."摇了尾巴<br/>";
    }

    //3、亲嘴
}
//创建对象
$xf = new Student("小芳");
$dog = new Dog("小爱");
//小芳放学了
$xf->offschool();
//小芳放学回到家中，一进家门，只见心爱的小狗“小爱”马上就对主人摇起了尾巴，小芳笑了笑，走过去，
//抱起了小狗，最后，小芳和小狗亲了一口
//小芳回答家中
$xf->goHome();
//小芳看见小狗
$xf->look($dog);
//小狗摇尾巴
$dog->wagTail();
//小芳笑了笑
$xf->smile();
//小芳走过去
$xf->walk();
//抱起小狗
$xf->hug($dog);
//小芳亲了小狗
$xf->kiss($xf,$dog);
//小狗也亲了小芳
$dog->kiss($dog,$xf);
?>

运行结果为：

Xiaofang hat die Schule verlassen
Xiaofang kehrt nach Hause zurück
Ich sehe Xiao Ai
Xiao Ai Ai wedelte mit dem Schwanz
Xiaofang lächelte
Xiaofang ging hinüber
Xiaofang umarmte Xiaoai
Xiao Fang küsste Xiao Ai
Xiao Ai küsste Xiao Fang

(7), Zusammenfassung

1. Dieser Artikel erklärt hauptsächlich die Definition und Funktion und spezifische Implementierung abstrakter Klassen in PHP

Ich hoffe, dieser Artikel kann Ihnen etwas helfen, danke! ! !

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der objektorientierten abstrakten PHP-Klassen (Codebeispiele). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!