notes d'étude php orientées objet

public Public : cette classe, les sous-classes et les objets externes peuvent tous appeler
protected Protégé : les sous-classes de cette classe peuvent être exécutées, les objets externes ne peuvent pas appeler
private : seule cette classe Exécution, les sous-classes et les objets externes ne peuvent pas être appelé
Trois caractéristiques majeures de la programmation orientée objet

1) Fermeture

Fermeture, qui peut également être appelée masquage d'informations. Il s’agit de séparer l’utilisation et l’implémentation d’une classe, ne laissant que des interfaces (méthodes) limitées pour se connecter avec l’extérieur. Pour les développeurs qui utilisent cette classe, ils ont seulement besoin de savoir comment utiliser cette classe et n'ont pas besoin de se soucier de la façon dont cette classe est implémentée. Cela permet aux développeurs de mieux se concentrer sur autre chose, tout en évitant les désagréments causés par les interdépendances entre les programmes.

2) Héritage

L'héritage signifie qu'une classe dérivée (sous-classe) hérite automatiquement des attributs et des méthodes d'une ou plusieurs classes de base (classes parentes) et peut remplacer ou en ajouter de nouvelles. et les méthodes. L'héritage simplifie la création d'objets et de classes et augmente la reproductibilité du code. L'héritage est divisé en héritage unique et héritage multiple. PHP prend en charge l'héritage unique, c'est-à-dire qu'une sous-classe a et n'a qu'une seule classe parent.

3) Polymorphisme

Le polymorphisme signifie que différents objets d'une même classe peuvent obtenir des résultats différents en utilisant la même méthode. Cette technologie est appelée polymorphisme. Le polymorphisme améliore la flexibilité et la réutilisabilité des logiciels.

Définition de la classe

Une classe peut contenir ses propres constantes, variables (appelées « propriétés ») et fonctions (appelées « méthodes »).
Comme de nombreux langages orientés objet, PHP définit également les classes via le mot-clé class plus le nom de la classe. Le format de la classe est le suivant :

Le code est le suivant :

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

Définition : Les oiseaux d'une plume se rassemblent, et les objets ayant des caractéristiques similaires sont regroupés dans une classe. La classe définit les mêmes attributs et attributs que possèdent ces méthodes d'objets similaires. Une classe est une description d'objets similaires, appelée définition de la classe, qui est le modèle ou le prototype de l'objet de cette classe.

Un objet d'une classe est appelé une instance de la classe. Pour créer une instance d'une classe, le mot-clé new doit être utilisé.

<?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();
?>

Méthodes membres

Les fonctions d'une classe sont appelées méthodes membres. La seule différence entre les fonctions et les méthodes membres est que les fonctions implémentent une fonction indépendante, tandis que les méthodes membres implémentent un comportement dans la classe et font partie de la classe.
Développons la classe myobject ci-dessus et ajoutons-y une méthode membre. Le code est le suivant :

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

La fonction de cette méthode est de générer le nom du produit, qui est transmis via le. paramètres de la méthode.
Une classe est une description abstraite, une collection d'objets avec des fonctions similaires. Si vous souhaitez utiliser les méthodes et variables de la classe, vous devez d'abord les implémenter dans une entité, c'est-à-dire un objet.

Constantes de classe
Puisqu'il y a des variables, bien sûr il y a aussi des constantes. Une constante est une quantité qui ne change pas et qui est une valeur constante. Une constante bien connue est pi. Pour définir des constantes, utilisez le mot-clé const, tel que :
ConstPI=3.14159;

Constructeur

PHP 5 permet aux développeurs de définir une méthode en tant que constructeur dans une classe. Les classes avec un constructeur appelleront cette méthode à chaque fois qu'un nouvel objet est créé, elle est donc très appropriée pour effectuer un travail d'initialisation avant d'utiliser l'objet.

Destructeur

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

Un destructeur se produit lorsque toutes les références à un objet ont été supprimées ou lorsque l'objet est explicitement détruit.

Référence de l'objet

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