Explication détaillée des classes abstraites orientées objet PHP (exemples de code)

Objectifs de cet article :

1. Comprendre la définition des classes abstraites en PHP

2 Comprendre le rôle des classes abstraites en PHP

3. fonctions des classes abstraites en PHP Scénarios d'utilisation

4. Maîtriser l'implémentation spécifique des classes abstraites en PHP

Toujours en suivant la réflexion cohérente précédente, nous apprendrons à travers la méthode 3W1H, alors apprenons d'abord à ce sujet

(1) Comprendre la définition des classes abstraites en PHP (Quoi)

Les classes abstraites sont souvent utilisées pour caractériser l'analyse et conception des zones à problèmes. Résumé Le concept est un résumé pour une série de concepts spécifiques qui semblent différents mais sont essentiellement les mêmes. Les classes généralement modifiées avec abstract dans les instructions de programmation sont des classes abstraites. La différence entre

et une interface est que les méthodes de l'interface ne sont pas implémentées, elles sont simplement définies, mais les méthodes de la classe abstraite peuvent être implémentées de.

(2) Comprendre le rôle des classes abstraites en PHP (Pourquoi)

Parmi les classes en PHP, de nombreuses classes seront constamment réécrites. Ceci Parfois, nous pouvons utiliser. cours abstraits, comment faire ? Cela consiste à écrire d'abord une classe publique, puis nous pouvons l'appeler à plusieurs reprises après l'avoir instanciée. Cela peut améliorer la réutilisabilité du code

(3) Comprendre les scénarios d'utilisation des classes abstraites en PHP (Où)

1 Si vous constatez que de nombreuses classes dans le code sont. méthodes similaires ou communes, nous pouvons extraire ces méthodes identiques ou similaires et les encapsuler dans des classes abstraites.

Les classes abstraites et les interfaces sont quelque peu similaires. On peut dire que l'interface est une classe abstraite spéciale, mais l'interface est pleine de méthodes abstraites (ce qu'on appelle abstrait signifie qu'il n'y a pas d'implémentation spécifique), mais dans la classe abstraite Certaines méthodes peuvent être implémentées,

(4) Maîtriser l'implémentation spécifique des classes abstraites en PHP (Comment)

Résumé :

1. La définition est définie par un résumé, tel que le nom de la classe abstraite {}

2. La définition de la méthode de la classe abstraite est également définie par un résumé, tel que le nom de la méthode de la fonction publique abstraite (){}

3. Les classes abstraites ne peuvent pas être instanciées

4. Pour hériter d'une classe abstraite, utilisez le mot-clé extends

5. Les sous-classes de classes abstraites doivent implémenter des choses qui ne le sont pas. implémenté dans la classe abstraite Toutes les méthodes, c'est-à-dire réécrire toutes les méthodes abstraites dans la classe abstraite

6. Bien que les sous-classes de la classe abstraite n'implémentent pas les méthodes qui ont été implémentées dans la classe abstraite, ils peuvent encore appeler ces méthodes. En fait, combinés avec l'héritage Nous pouvons très bien comprendre cela

Chaque résumé est obtenu par la pratique. Nous utilisons maintenant la pratique pour démontrer le résumé, ce qui peut promouvoir. compréhension et rendre chaque résumé plus compréhensible

(5), code spécifique

Cas 1,

Objectif pratique :

1. La définition d'une classe abstraite est définie par un résumé, tel que le nom de la classe abstraite {}

2. défini par un résumé, tel que le nom de la méthode de fonction publique abstraite (){}

Le code spécifique est le suivant :

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

Cas 2,

Objectifs pratiques :

1. Les classes abstraites ne peuvent pas être instanciées. Le code spécifique de

est le suivant :

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

Le résultat courant est :

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 n'est pas scolarisé
Xiaofang rentre chez lui
Je vois Xiao Ai
Xiao Ai Ai remua la queue
Xiaofang sourit
Xiaofang s'approcha
Xiaofang serra Xiaoai dans ses bras
Xiao Fang a embrassé Xiao Ai
Xiao Ai a embrassé Xiao Fang

(7), Résumé

Cet article explique principalement la définition, la fonction. et implémentation spécifique de classes abstraites en PHP

J'espère que cet article pourra vous apporter un peu d'aide, merci ! ! !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!