Explication détaillée des classes PHP et orienté objet

Cet article partage avec vous principalement les parties de base de PHP, des explications détaillées des classes PHP et orientées objet, il y a dix points au total, j'espère que cela pourra aider tout le monde.

1. Classes et objets PHP

<?php//定义一个类class Car {
    var $name = &#39;汽车&#39;;    function getName() {
        return $this->name;
    }
}//实例化一个car对象$car = new Car();$car->name = &#39;奥迪A6&#39;; 
//设置对象的属性值echo $car->getName();  //调用对象的方法 输出对象的名字

3. Attributs de classe

Les variables définies dans une classe sont appelées attributs, généralement les attributs sont les mêmes que les champs de la base de données. Il existe une certaine corrélation, on peut donc aussi l'appeler un « champ ». Une déclaration de propriété commence par les mots-clés public, protected ou private, suivis d'une déclaration de variable ordinaire. Les variables d'attribut peuvent être initialisées avec une valeur par défaut et la valeur par défaut doit être une constante.

La signification des mots-clés de contrôle d'accès est :

public：公开的 protected：受保护的 private：私有的
class Car {    //定义公共属性    public $name = '汽车';   
 //定义受保护的属性    protected $corlor = '白色';    
 //定义私有属性    private $price = '100000';}
默认都为public，外部可以访问。一般通过->对象操作符来访问对象的属性或者方法，对于静态属性则使用::双冒号进行访问。当在类成员方法内部调用的时候，可以使用$this伪变量调用当前对象的属性。
$car = new Car();echo $car->name;   
//调用对象的属性echo $car->color;  //错误 受保护的属性不允许外部调用echo $car->price;  //错误 私有属性不允许外部调用
受保护的属性与私有属性不允许外部调用，在类的成员方法内部是可以调用的。
class Car{    private $price = '1000';    public function getPrice() {        return $this->price; //内部访问私有属性    }}

4. Méthodes de classe

Les méthodes sont des fonctions dans la classe. Souvent, nous ne pouvons pas les distinguer. . Quelle est la différence entre une méthode et une fonction ? Dans la programmation orientée processus, la fonction est appelée une fonction, et dans la programmation orientée objet, la fonction est appelée une méthode.

Comme les attributs, les méthodes de classe ont également un contrôle d'accès public, protégé et privé.

La signification des mots-clés de contrôle d'accès est :
public : public
protected : protégé
private : privé

Nous pouvons définir la méthode comme ceci

class Car {    public function getName() {        return '汽车';    }}$car = new Car();echo $car->getName();
使用关键字static修饰的，称之为静态方法，静态方法不需要实例化对象，可以通过类名直接调用，操作符为双冒号::。
class Car {    public static function getName() {        return '汽车';    }}echo Car::getName(); //结果为“汽车”

5. Constructeur et destructeur

PHP5可以在类中使用__construct()定义一个构造函数，具有构造函数的类，会在每次对象创建的时候调用该函数，因此常用来在对象创建的时候进行一些初始化工作。
class Car {   function __construct() {       print "构造函数被调用\n";   }}$car = new Car(); 
//实例化的时候 会自动调用构造函数__construct，这里会输出一个字符串
在子类中如果定义了__construct则不会调用父类的__construct，如果需要同时调用父类的构造函数，需要使用parent::__construct()显式的调用。
class Car {   function __construct() {       print "父类构造函数被调用\n";   }}class Truck extends Car {   function __construct()
 {       print "子类构造函数被调用\n";       parent::__construct();   }}$car = new Truck();
同样，PHP5支持析构函数，使用__destruct()进行定义，析构函数指的是当某个对象的所有引用被删除，或者对象被显式的销毁时会执行的函数。
class Car {   function __construct() {       print "构造函数被调用 \n";   }   function __destruct()
 {       print "析构函数被调用 \n";   }}$car = new Car(); //实例化时会调用构造函数echo '使用后，准备销毁car对象 \n';unset($car); //销毁时会调用析构函数

Lorsque le code PHP est exécuté, l'objet sera automatiquement recyclé et détruit, donc dans des circonstances normales, il n'est pas nécessaire de le détruire explicitement.

6. Mot-clé statique

Les propriétés et méthodes statiques peuvent être appelées sans instancier la classe, et peuvent être appelées directement en utilisant le nom de la classe :: nom de la méthode. Les propriétés statiques ne permettent pas d'appeler des objets à l'aide de l'opérateur ->

class Car {    private static $speed = 10;    
public static function getSpeed() 
{        return self::$speed;    }}echo Car::getSpeed();  //调用静态方法
静态方法也可以通过变量来进行动态调用
$func = 'getSpeed';$className = 'Car';echo $className::$func();  //动态调用静态方法

Dans les méthodes statiques, la pseudo-variable $this n'est pas autorisée à être utilisée. Vous pouvez utiliser self, parent, static pour appeler des méthodes et propriétés statiques en interne.

class Car {
    private static $speed = 10;    public static function getSpeed() {
        return self::$speed;
    }    public static function speedUp() {
        return self::$speed+=10;
    }
}class BigCar extends Car {
    public static function start() {
        parent::speedUp();
    }
}
BigCar::start();echo BigCar::getSpeed();

7. Contrôle d'accès

Dans la section précédente, nous avons déjà abordé le contrôle d'accès est mis en œuvre à travers les mots-clés public, protégé et privé. Les membres de la classe définis comme publics sont accessibles de n’importe où. Un membre de classe défini comme protégé est accessible par lui-même ainsi que par ses sous-classes et classes parentes. Les membres de classe définis comme privés ne sont accessibles que par la classe dans laquelle ils sont définis.

Les attributs de classe doivent être définis comme étant publics, protégés ou privés. Pour des raisons de compatibilité avec les versions antérieures à PHP5, s'il est défini à l'aide de var, il est considéré comme public.

class Car {
   $speed = 10; //错误 属性必须定义访问控制
   public $name;   //定义共有属性}
类中的方法可以被定义为公有、私有或受保护。如果没有设置这些关键字，则该方法默认为公有
class Car {
   //默认为共有方法
   function turnLeft() {
   }
}
如果构造函数定义成了私有方法，则不允许直接实例化对象了，这时候一般通过静态方法进行实例化，在设计模式中会经常使用这样的方法来控制对象的创建，比如单例模式只允许有一个全局唯一的对象。
class Car {
   private function __construct() {
       echo 'object create';
   }    private static $_object = null;    public static function getInstance() {
       if (empty(self::$_object)) {            self::$_object = new Car(); //内部方法可以调用私有方法，因此这里可以创建对象
       }        return self::$_object;
   }
}//$car = new Car(); //这里不允许直接实例化对象$car = Car::getInstance(); //通过静态方法来获得一个实例

8. Héritage d'objets

L'héritage est une fonctionnalité couramment utilisée dans la programmation orientée objet. Car est une classe relativement grande. Nous pouvons également l'appeler une classe de base. De plus, les voitures sont également divisées en camions, voitures, Dongfeng, BMW, etc. Étant donné que ces sous-classes ont bon nombre des mêmes attributs et méthodes, vous pouvez hériter de la classe car pour partager ces attributs et méthodes afin de réaliser la réutilisation du code.

class Car {
    public $speed = 0; //汽车的起始速度是0
    public function speedUp() {
        $this->speed += 10;        return $this->speed;
    }
}//定义继承于Car的Truck类class Truck extends Car{
    public function speedUp(){
        $this->speed = parent::speedUp() + 50;
    }
}

9. Surcharge

La surcharge en PHP fait référence à la création dynamique de propriétés et de méthodes, qui est réalisée grâce à des méthodes magiques. La surcharge d'attributs utilise __set, __get, __isset et __unset pour implémenter respectivement l'affectation, la lecture, la détermination si l'attribut est défini et la destruction de l'attribut s'il n'existe pas.

class Car {
   private $ary = array();    public function __set($key, $val) {
       $this->ary[$key] = $val;
   }    public function __get($key) {
       if (isset($this->ary[$key])) {            return $this->ary[$key];
       }        return null;
   }    public function __isset($key) {
       if (isset($this->ary[$key])) {            return true;
       }        return false;
   }    public function __unset($key) {
       unset($this->ary[$key]);
   }
}$car = new Car();$car->name = '汽车';  //name属性动态创建并赋值echo $car->name;
方法的重载通过__call来实现，当调用不存在的方法的时候，将会转为参数调用__call方法，当调用不存在的静态方法时会使用__callStatic重载。
class Car {
   public $speed = 0;    public function __call($name, $args) {
       if ($name == 'speedUp') {            $this->speed += 10;
       }
   }
}$car = new Car();$car->speedUp(); //调用不存在的方法会使用重载echo $car->speed;

10. Caractéristiques avancées des objets Comparaison d'objets, lorsque tous les attributs de deux instances de la même classe sont égaux, vous pouvez utiliser l'opérateur de comparaison == pour juger. Lorsque vous devez juger si deux variables sont des références au même objet, vous pouvez utiliser l'opérateur de congruence = =. = Porter un jugement.

class Car {}$a = new Car();$b = new Car();if ($a == $b) echo '==';   //trueif ($a === $b) echo '==='; //false
对象复制，在一些特殊情况下，可以通过关键字clone来复制一个对象，这时__clone方法会被调用，通过这个魔术方法来设置属性的值。
class Car {
   public $name = 'car';    public function __clone() {
       $obj = new Car();        $obj->name = $this->name;
   }
}$a = new Car();$a->name = 'new car';$b = clone $a;
var_dump($b);
对象序列化，可以通过serialize方法将对象序列化为字符串，用于存储或者传递数据，然后在需要的时候通过unserialize将字符串反序列化成对象进行使用
class Car {
   public $name = 'car';
}$a = new Car();$str = serialize($a); //对象序列化成字符串echo $str.'
';$b = unserialize($str); //反序列化为对象var_dump($b);

Recommandations associées :

Méthode d'implémentation de chargement automatique de la classe PHP

Explication détaillée du processus de réflexion par injection de dépendances implémentation de la classe PHP

Principes du chargement automatique de la classe PHP et du fonctionnement de la chaîne PHP

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!