Tutoriel de base PHP neuf classes et objets

Contenu expliqué dans cette section

• Classes et objets

• La composition de classes

• Création d'objets

• Mécanisme de récupération de place PHP

• $cette explication

Préface

PHP est un langage de programmation orienté objet, alors qu'est-ce que l'orienté objet ? Pourquoi devrions-nous être orientés objet ? Il y a beaucoup de choses dans nos vies qui sont des objets, comme une tasse, une boîte, etc. Elles ont toutes leurs propres caractéristiques et ce sont toutes des objets. Et notre développement en développement repose également sur la programmation orientée objet. Un objet est tout ce que les gens veulent étudier, depuis les entiers les plus simples jusqu'aux avions complexes. Notre utilisation de la programmation orientée objet peut nous permettre de voir le problème de manière globale, et elle est également propice à la gestion et à la maintenance des données. En PHP, la programmation orientée objet peut être divisée en deux catégories, l'une étant les modèles, qui créent des objets. à utiliser, et l'autre est constitué d'objets, créés à l'aide de modèles, alors quelle est la relation entre les deux ?

Classes et objets

Classes et objets : L'abstraction d'objets ayant les mêmes caractéristiques (éléments de données) et comportement (fonctions) est une classe. Par conséquent, l'abstraction d'un objet est une classe, et la concrétisation d'une classe est un objet. On peut également dire qu'une instance d'une classe est un objet et qu'une classe est en fait un type de données.

C'est-à-dire qu'extraire les fonctions et les caractéristiques de l'objet pour former une classe, c'est comme extraire le modèle d'une tasse, et on peut créer différentes tasses (également appelées tasses) basées sur ce modèle (qui c'est-à-dire la classe) est l'objet).
Alors, comment sont définies les classes ? Comment sont créés les objets ?

Composition d'une classe

<?php

    class Cat{ //定义一个猫类
        public $name; //猫的名字
        public $age;//猫的名字
        public $color;//猫的颜色
        //猫的构造方法
        public function __construct(){

        }

        public function sleep(){
            echo &#39;猫睡觉&#39;;
        }

        public function eat(){
            echo &#39;猫吃饭&#39;;
        }

    }

Ce qui précède est la structure de base d'une classe Ci-dessous, nous expliquerons la signification de chaque partie en détail.

• class est un mot-clé et ne peut pas être modifié, indiquant qu'il s'agit d'une classe.

• Cat est le nom de la classe. Le nom de la classe est écrit en commençant par une lettre majuscule et nommé en casse chameau.

Attributs de classe

Attributs : les attributs membres sont un composant de la classe, généralement des types de données de base (entiers, chaînes, etc.), il peut également s'agir d'un type composite (objet, tableau), de type ressource. Par exemple, le $age public de la classe Cat que nous avons définie précédemment est un attribut de membre.

On peut dire que chaque classe a des attributs. Les attributs d'une classe sont les caractéristiques d'une classe. Par exemple, un chat peut avoir un nom, un âge, une couleur, etc., qui sont des caractéristiques communes. les chats. Nous appelons cette fonctionnalité dans une classe un attribut. Bien entendu, nous n’avons pas besoin de définir un attribut. Cela dépend de vos propres besoins.

Le public devant l'attribut est un modificateur de permission, qui sera expliqué plus tard.

Méthode membre (fonction)

Dans le code ci-dessus, vous pouvez voir qu'il y a plusieurs fonctions dans la classe. Elles sont les mêmes que les fonctions précédentes, mais. Il y a un caractère de contrôle d'autorisation supplémentaire devant. Cela peut également être appelé méthodes membres. Ces méthodes membres sont les comportements de la classe. Par exemple, la classe cat ci-dessus a le comportement de dormir et de manger. Bien sûr, vous pouvez écrire son propre comportement.

Syntaxe de la méthode membre :

访问修饰符  function  函数名(形式参数){
    //函数体;
    //return 返回值;
}

• Modificateur d'accès, il existe trois types (public, protégé, privé), la valeur par défaut est publique, nous l'expliquerons dans détailler plus tard

• Les autres parties sont les mêmes que les fonctions que nous avons apprises, y compris le mécanisme d'appel

• La liste des paramètres peut en avoir plusieurs et peut être de tout type

• Quant à la valeur de retour de la méthode, elle peut dépendre des exigences spécifiques.

• Les méthodes membres sont définies dans la classe Si elles sont définies en dehors de la classe, elles ne seront pas le comportement de cette classe.

Constructeur

Il y a une méthode dans la classe cat ci-dessus, le nom de la méthode est -__construct(), c'est un constructeur, donc qu'est-ce que c'est un constructeur ? Le constructeur est une méthode pour initialiser les données lors de la création d'un objet. Par exemple, si l'on souhaite lui donner directement le nom, l'âge et la couleur du chat lors de la création d'un objet, on peut utiliser le constructeur.

public function __construct($name,$age,$color){
            $this-> name = $name;
            $this-> age = $age;
            $this-> color = $color;
}

La syntaxe du constructeur est :

public  function  __construct(形式参数){  
    //函数体
}

Pour le nom de méthode du constructeur __construct(), c'est une méthode magique, qui sera introduite plus tard. , le constructeur est également Il existe un moyen d'écrire le nom de la méthode du constructeur est le nom de la classe :

public function Cat($name,$age,$color){

}

La manière ci-dessus de définir la méthode du constructeur est également correcte, mais il est recommandé de utilisez la méthode magique (__construct()), en pensant de cette façon. Lorsque le nom de notre classe change, il n'est pas nécessaire de le modifier.

RemarqueLes noms des classes en PHP ne sont pas sensibles à la casse, mais il faut quand même les écrire en majuscules et minuscules. En même temps, le constructeur n’a aucune valeur de retour.

Les constructeurs doivent faire attention à :

• Dans une classe, il ne peut y avoir qu'un seul constructeur, c'est une exigence obligatoire

• Le constructeur

  est automatiquement appelé par le système , nous n'avons donc pas à l'ajuster nous-mêmes.

• Si nous ne définissons pas de constructeur, le système utilisera un constructeur par défaut avec la forme suivante : fonction publique

• __construct(){ }, donc que nous ayons défini un constructeur ou non, il a un constructeur.

上面的三种情况就是类中大致的内容，在后续我们还会降类中的其他情况。

对象的创建

在上面创建对象的类已经有了，那么怎么创建对象呢？

对象创建方法

$cat = new Cat();

创建对象的语法是：

$对象名 = new 类名(参数1,参数2);

类名后面的括号里的参数是传递给类的构造函数的，如果构造函数没有参数，可以不写。

• 对象的命名规范和普通变量一样，使用驼峰法或者下划线法均可

• new也是一个关键字，不能修改，表示新创建对象

我们创建对象的目的就是需要操作对象，而操作对象，就是操作对象里面的属性和方法。

在上面的类下面写如下代码：

//创建对象，传递三个参数到构造函数。
$cat = new Cat('小花',12,'black');
//通过对象来访问对象的属性
echo $cat -> name;
echo &#39;<br>&#39;;
echo $cat -> age;
echo &#39;<br>&#39;;
echo $cat -> color;
echo &#39;<br>&#39;;
$cat-> sleep();
$cat-> eat();
.....结果......
小花
12
black
猫睡觉
猫吃饭

上面的对象通过->访问属性和方法。注意属性的前面没有$符号。

$对象名->属性名= 值；
echo  $对象名->属性名;
'-> ' 称为对象运算符.

上面的就是对象的创建和最基本的应用

对象的传递类型

当我们把对象的值赋给另外一个变量是，是值传递还是引用传递？

    //创建一个对象
    $cat = new Cat('小花',12,'black');
    $cat1 = $cat; // 把$cat这个对象赋给$cat1;
    $cat1 -> name = '小白';//利用$cat1这个对象修改对象的名字。
    echo $cat1 -> name; //输出$cat1对象的名字。
    echo &#39;<br>&#39;;
    echo $cat -> name; //输出$cat对象的名字。
.....结果......
小白
小白

看到这里可能有点蒙，不是值传递吗？怎么修改一个对象的属性，另外一也变了？，

上面的代码当中 $cat1=$cat也是值传递,但是这个值是对象的引用(可以理解对象标识符)，即每个包含对象的变量都持有对象的引（reference），而不是整个对象的拷贝。

在上面的图中可以看到，当$cat赋值给$cat1时，也就是对象标识符(#1)复制了一份，赋给$cat1，其实他们还是指向同一块数据区，所以只要其中一个修改了值，另外一个也会变。

对象的销毁

我们使用完对象后，已经确定在以后不会使用这个对象了，这个时候我们可以手动的销毁对象，那么我们怎么让对象销毁呢？

1. 当没有任何变量指向对象时，会销毁，因此我们可以把对象引用置为null

2. 使用unset()函数来销毁对象。

   //创建一个对象
   $cat = new Cat('小花',12,'black');
   $cat -> sleep();
   unset($cat);
   $cat -> sleep();
   .....结果.....
   
   猫睡觉
   Notice: Undefined variable: cat in D:\mywamp\Apache24\htdocs\zendstudio\yunsuanfu\object.php on line 27
   
   Fatal error: Call to a member function sleep() on null in D:\mywamp\Apache24\htdocs\zendstudio\yunsuanfu\object.php on line 27

   其实在一个文件运行完的时候，PHP会启动垃圾回收机制，自动的进行垃圾回收。这时候在里面创建的对象就自动销毁了，那么什么是PHP的垃圾回收机制？

PHP垃圾回收机制

垃圾回收，顾名思义，回收垃圾的，在程序中启动垃圾回收机制的时机：

• 在php中，当一个对象没有任何引用指向它的时候，就会成为一个垃圾对象，php将启动垃圾回收器将对象销毁。

• 当程序退出前，php也将启用垃圾回收器，销毁对象。

那么什么是垃圾回收机制？

垃圾回收机制是php5之后才有的，php5.3之前使用的垃圾回收机制是单纯的“引用计数”，也就是每个内存对象都分配一个计数器，当内存对象被变量引用时，计数器+1；当变量引用撤掉后，计数器-1；当计数器=0时，表明内存对象没有被使用，该内存对象则进行销毁，垃圾回收完成。但是PHP5.3开始，使用了新的垃圾回收机制，在引用计数基础上，实现了一种复杂的算法，来检测内存对象中引用环的存在(对象的相互引用)，以避免内存泄漏。

$this说明

在上面写类的构造函数的时候，可以看到在函数中使用到了$this，那么在面向对象中$this是什么？

$this是在类中使用的访问自身的一种机制。系统会给每个对象分配$this,代表当前对象。通俗的说就是在当前环境下，谁调用，$this就代表哪个对象。

<?php

    class Cat{ //定义一个猫类
        public $name; //猫的名字
        public $age;//猫的名字
        public $color;//猫的颜色
        //猫的定义方法
        public function Cat($name,$age,$color){
            $this-> name = $name;
            $this-> age = $age;
            $this-> color = $color;
        }

        public function sleep(){
            echo &#39;猫睡觉<br>&#39;;
        }

        public function eat(){
            echo &#39;猫吃饭<br>&#39;;
        }
        //输出猫的信息
        public function info(){
            echo &#39;猫的名字是&#39; . $this -> name . &#39; 年龄是&#39; . $this-> age . &#39; 颜色是&#39; . $this-> color;
        }

    }
    //创建一个对象
    $cat = new Cat(&#39;小花&#39;,12,&#39;black&#39;);
    $cat -> info();
    echo &#39;<br>&#39;;
    //创建另一个对象，传进不同的属性
    $cat1 = new Cat(&#39;小白&#39;,6,&#39;white&#39;);
    $cat1 -> info();
    .....结果.....
猫的名字是小花 年龄是12 颜色是black
猫的名字是小白 年龄是6 颜色是white

在上面的类中的info()函数中使用$this，不同的对象输出不同的结果，因为在不同的环境下，谁调用，$this就代表哪个对象。

类的析构函数

在上面我们提到过，对象的销毁，其实在类中有一个方法，就是在对象销毁的时候由系统自动执行的。我们称之为析构函数。

public function __destruct(){
        echo $this->name . &#39;被销毁了<br>&#39;;
}

在PHP5中引入了析构函数的概念，析构函数会在某个对象的所有引用被删除（没有变量指向对象，要被销毁了），对象销毁前执行。

析构函数的主要作用是去释放对象分配的相关资源，比如数据库连接或打开的文件等。

它的语法是：

function  __destruct(){
    //函数体[释放资源，比如数据库连接，或者打开文件等等]
}

析构函数也是系统自动调用的，我们不用自己调。但是当我们没有写析构函数的时候，系统不会执行析构函数。

<?php

class Cat{ //定义一个猫类
    public $name; //猫的名字
    public $age;//猫的名字
    public $color;//猫的颜色
    //猫的定义方法
    public function Cat($name,$age,$color){
        $this-> name = $name;
        $this-> age = $age;
        $this-> color = $color;
    }

    public function sleep(){
        echo &#39;猫睡觉<br>&#39;;
    }

    public function eat(){
        echo &#39;猫吃饭<br>&#39;;
    }
    //输出猫的信息
    public function info(){
        echo &#39;猫的名字是&#39; . $this -> name . &#39; 年龄是&#39; . $this-> age . &#39; 颜色是&#39; . $this-> color;
    }

    public function __destruct(){
        echo $this->name . &#39;被销毁了<br>&#39;;
    }

}
//创建一个对象
$cat = new Cat(&#39;小花&#39;,12,&#39;black&#39;);
echo $cat -> name; //输出对象的名字
echo &#39;<br>&#39;;
unset($cat); //销毁对象，系统自动调用析构函数。
.....结果......
小花
小花被销毁了

当我们销毁对象$cat时，析构函数自动执行。

• Le destructeur est automatiquement exécuté avant la destruction de l'objet et il n'a aucune valeur de retour. Il ne peut y avoir qu'un seul destructeur par classe.

• Le destructeur détruit les ressources créées par l'objet, pas l'objet lui-même, qui est détruit par le mécanisme de garbage collection.

Lorsque nous créons plusieurs objets dans un fichier, lorsque le fichier est exécuté et que les objets sont détruits, les objets créés en premier sont détruits en premier, et les objets créés plus tard sont détruits en premier. Le principe et le principe de stack sont très similaires, premier entré, dernier sorti, dernier entré, premier sorti.

Résumé

Grâce à l'explication ci-dessus des classes et des objets, nous pouvons connaître les différences et les connexions entre les classes et les objets. Les cours sont abstraits et représentent un type de chose, comme des chats. Les objets sont concrets et représentent une chose spécifique. Une classe est un modèle pour un objet et un objet est une instance d'une classe. Parallèlement, la composition de base de la classe doit être maîtrisée.

Ce qui précède est le contenu du didacticiel de base PHP neuf et des objets. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !