Compréhension complète des classes et des objets PHP

Table des matières

PHP Classes et objets Analyse complète (1)

Analyse complète des classes et objets PHP (2)

PHP Analyse complète des classes et des objets (3)

1. Classes et objets

Objet : Un individu qui existe réellement dans chaque objet physique de ce type de chose. $a =new User(); La référence $a
instanciée : alias PHP, deux noms de variables différents pointent vers le même contenu

Encapsulation : Mettre les attributs et méthodes de l'objet Organisé dans une classe (unité logique)
Héritage : créer une nouvelle classe basée sur la classe d'origine à des fins de réutilisation du code
Polymorphisme : permet d'attribuer des pointeurs de types de sous-classes à un type de classe parent.
----------------------------------------

2 . Chargement automatique Objet :

Chargement automatique En définissant une fonction de chargement automatique spéciale, cette fonction sera automatiquement appelée lorsqu'une classe non définie dans le script est référencée.

[php] view plaincopyprint?
 function autoload($class){
   require_once("classes/$class.class.php");
 }

Pourquoi utiliser le chargement automatique

1. La première est que vous ne savez pas où ce fichier de classe est stocké
2. quand vous devez utiliser ce fichier.
3. Surtout lorsqu'il y a beaucoup de fichiers projet, il est impossible d'écrire une longue liste d'exigences au début de chaque fichier...

remplace un
require_once ("classes/ Books.class .php") ;
require_once ("classes/Employees.class.php" ) ;
require_once ("classes/Events.class.php") ;
require_once ("classes/Patrons. class.php ") ;

zend recommande l'une des méthodes les plus populaires, y compris le chemin dans le nom du fichier. Par exemple, dans l'exemple suivant :

[php] view plaincopyprint?

    view sourceprint?  
    // Main.class    
      
    function autoload($class_name) {     
         $path = str_replace('_', DIRECTORY_SEPARATOR, $class_name);     
         require_once $path.'.php';     
     }

temp = new Main_Super_Class();

Tous les traits de soulignement seront remplacés par des séparateurs dans le chemin. Dans l'exemple ci-dessus, Main/Super/. Fichier classe.php.

Inconvénients :

Dans le processus de codage, vous devez savoir clairement où le fichier de code doit être,

Et parce que le chemin du fichier est codé en dur dans le nom de la classe, si nous devons modifier la structure des dossiers, nous devons modifier manuellement tous les noms de classes.

Si vous êtes dans un environnement de développement et que vous ne vous souciez pas beaucoup de la vitesse, il est très pratique d'utiliser la méthode 'Inclure tout'.
En plaçant tous les fichiers de classe dans un ou plusieurs dossiers spécifiques, puis en les recherchant et en les chargeant via traversal.
Par exemple

   <?php     
      
    $arr = array (     
         &#39;Project/Classes&#39;,     
        &#39;Project/Classes/Children&#39;,     
        &#39;Project/Interfaces&#39;    
     );    
      
     foreach($arr as $dir) {     
      
        $dir_list = opendir($dir);    
      
        while ($file = readdir($dir_list)) {     
             $path = $dir.DIRECTORY_SEPARATOR.$file;     
             if(in_array($file, array(&#39;.&#39;, &#39;..&#39;)) || is_dir($path))     
                 continue;    
             if (strpos($file, ".class.php"))     
                 require_once $path;     
         }     
    }     
      
     ?>

Une autre méthode consiste à établir une association entre le fichier de classe et son emplacement Fichier de configuration, par exemple :

    view sourceprint?  
    // configuration.php           
    array_of_associations = array(     
        'MainSuperClass' = 'C:/Main/Super/Class.php',     
        'MainPoorClass' = 'C:/blablabla/gy.php'    
     );

appel Fichiers

    <?php     
        require &#39;autoload_generated.php&#39;;    
        function autoload($className) {     
           global $autoload_list;     
           require_once $autoload_list[$className];     
        }    
          $x = new A();     
    ?>

--------------------------------------------- ----- ---------

3. Constructeurs et destructeurs

PHP Méthode constructeur construct() permet l'exécution avant d'instancier une classe Construction méthode.

Le constructeur est une méthode spéciale dans une classe. Lorsqu'une instance d'une classe est créée à l'aide de l'opérateur new, la méthode constructeur est automatiquement appelée et son nom doit être construct() .

(Un seul constructeur peut être déclaré dans une classe, mais le constructeur ne sera appelé qu'une seule fois à chaque fois que crée un objet . Cette méthode ne peut pas être appelée activement,
C'est donc généralement utilisé pour effectuer certaines tâches d'initialisation utiles. )

Fonction : utilisée pour initialiser l'objet lors de la création de l'objet
Le constructeur parent::construct() de l'exécution de la sous-classe.

Destructeur : définition destruct() : une fonction membre interne spéciale sans type de retour, sans paramètres, ne peut pas être appelée à volonté et n'est pas surchargée
uniquement lorsque la vie de l'objet de classe se termine, Les ressources allouées dans le constructeur ; sont automatiquement appelés par le système pour être libérés.

La méthode destructeur correspond à la méthode constructeur. La méthode destructeur vous permet d'effectuer certaines opérations ou de compléter certaines fonctions avant de détruire une classe, comme fermer des fichiers, libérer des jeux de résultats, etc.
Le destructeur ne peut prendre aucun paramètre et son nom doit être destruct().
Fonction : nettoyer les conséquences du travail, par exemple, utiliser new pour ouvrir un espace mémoire lors de la création d'un objet et utiliser le destructeur pour libérer les ressources allouées dans le constructeur avant de quitter.

Exemple :

    class Person {  
        public $name;  
        public $age;  
      
        //定义一个构造方法初始化赋值  
        public function construct($name,$age) {  
            $this->name=$name;  
            $this->age=$age;  
        }  
        public function say() {  
            echo "my name is :".$this->name."<br />";  
            echo "my age is :".$this->age;  
        }  
        //析构函数  
        function destruct()  
        {  
            echo "goodbye :".$this->name;  
        }  
    }  
      
    $p1=new Person("ren", 25);  
    $p1->say();

-------------------------------- - ---------------------------------

4.Contrôle d'accès

Le contrôle d'accès aux propriétés ou aux méthodes est obtenu en ajoutant les mots-clés public, protected ou private devant elles
Les membres de la classe définis par public sont accessibles de n'importe où
Les membres de la classe définis par protected Il peut ; être accessible par les sous-classes et les classes parents de la classe dans laquelle il se trouve (bien sûr, la classe dans laquelle se trouve le membre est également accessible
Les membres de la classe privée définie ne sont accessibles que par la classe dans laquelle ils se trouvent) ; .
Contrôle d'accès pour les membres de la classe
Les membres de la classe doivent être définis à l'aide des mots-clés public, protected ou private

Contrôle d'accès aux méthodes
Les méthodes de la classe doivent utiliser le mot-clé public, protected ou private à définir. Si ces mots-clés ne sont pas définis, la méthode sera définie sur le public par défaut.

Exemple :

class MyClass  
{  
    public $public = 'Public';  
    protected $protected = 'Protected';  
    private $private = 'Private';  
  
    function printHello()  
    {  
        echo $this->public;  
        echo $this->protected;  
        echo $this->private;  
    }  
}  
  
$obj = new MyClass();  
echo $obj->public; // 这行能被正常执行  
echo $obj->protected; // 这行会产生一个致命错误  
echo $obj->private; // 这行也会产生一个致命错误  
$obj->printHello(); // 输出 Public、Protected 和 Private

-------------------------------------------------------------

5 .对象继承

    继承定义：以原有的类为基础，创建一个新类，从而代码复用的目的；
--------------------------------------
覆写是对象继承时用到的
重载是单对象中同方法名不同参数的方法
--------------------------------------

继承已为大家所熟知的一个程序设计特性，PHP 的对象模型也使用了继承。继承将会影响到类与类，对象与对象之间的关系。

比如，当扩展一个类，子类就会继承父类的所有公有和保护方法。但是子类的方法会覆盖父类的方法。

继承对于功能的设计和抽象是非常有用的，而且对于类似的对象增加新功能就无须重新再写这些公用的功能。

    class Person {  
        public $name;  
        public $age;  
      
        function say() {  
            echo "my name is:".$this->name."<br />";  
        echo "my age is:".$this->age;  
        }  
    }  
      
    // 类的继承  
    class Student extends Person {  
        var $school;    //学生所在学校的属性  
          
        function study() {  
            echo "my name is:".$this->name."<br />";  
            echo "my shool is:".$this->school;  
        }         
    }  
      
    $t1 = new Student();  
    $t1->name = "zhangsan";  
    $t1->school = "beijindaxue";  
    $t1->study();

-------  ---------  ------   ---------  --------   -----

6 .范围解析操作符（::）

范围解析操作符（也可称作 Paamayim Nekudotayim）或者更简单地说是一对冒号，可以用于访问静态成员、方法和常量，还可以用于覆盖类中的成员和方法。
当在类的外部访问这些静态成员、方法和常量时，必须使用类的名字。

self 和 parent 这两个特殊的关键字是用于在类的内部对成员或方法进行访问的。
注意：
当一个子类覆盖其父类中的方法时，PHP 不会再执行父类中已被覆盖的方法，直到子类中调用这些方法为止

例子：

    <?php  
    class OtherClass extends MyClass  
    {  
        public static $my_static = &#39;static var&#39;;  
      
        public static function doubleColon() {  
            echo parent::CONST_VALUE . "\n";  
            echo self::$my_static . "\n";  
        }  
    }  
      
    OtherClass::doubleColon();  
    ?>

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!