comment apprendre des cours en php

Structure des classes : Les fonctions internes d'une classe peuvent avoir trois choses, à savoir des constantes, des propriétés et des méthodes. Les fonctions peuvent être comprises comme des constantes, des variables et des fonctions extérieures à la classe.

Le code est le suivant :

<?php      
class TEST      
{      
    const NAME = &#39;value&#39;; // 常量      
    public $name = &#39;value&#39;; // 属性      
    public function name() // 方法      
    {      
        echo &#39;value&#39;;      
    }      
}      
?>

En cela, les propriétés et les méthodes peuvent utiliser trois mots-clés différents : public, protected et private pour combiner les fonctions des propriétés et des méthodes. . La portée est davantage distinguée. Les propriétés et les méthodes avec le mot-clé private ne peuvent être appelées que par les méthodes de la classe dans laquelle elles se trouvent ; les propriétés et les méthodes avec le mot-clé protected peuvent être appelées par les méthodes de leur propre classe et sous-classe parent, sauf elles-mêmes. . Il peut également être appelé ; les propriétés et les méthodes avec le mot-clé public peuvent être appelées à partir de l'objet après l'instanciation. Le plus grand avantage est qu'il ajoute des fonctionnalités descriptives à toutes les propriétés et méthodes, ce qui facilite l'organisation et l'organisation du code. . structure. Le mot-clé const est ignoré en premier et discuté avec static plus tard.

Le mot-clé statique est un autre type de mot-clé différent de public, protected, private (il peut donc être utilisé en combinaison avec public, protected, private) :

Le code est le suivant :

<?php      
class TEST      
{      
    public static function name()       
    {      
        echo &#39;value&#39;;      
    }      
}      
?>

Les méthodes avec le mot-clé static peuvent être appelées directement via le symbole "::" sans instancier la classe, et sont combinées avec public, protected et private , vous pouvez également laisser l'appel distinguer les autorisations, mais il est généralement associé à public. Le mot clé constant const mentionné ci-dessus doit être de type public statique, donc les constantes ne peuvent être appelées que via self::NAME, TEST::NAME . les méthodes suivantes __construct, __destruct et autres sont toutes statiques.

Dans la partie structurelle de la classe, les deux derniers mots-clés introduits sont abstract et final. Le mot-clé abstract indique que cette classe doit être surchargée par ses sous-classes, et le mot-clé final indique que cette classe ne doit pas être surchargée. par ses sous-classes. Subclass override, les fonctions de ces deux mots-clés sont exactement opposées. Les méthodes avec des méthodes abstraites sont appelées méthodes abstraites, et les classes avec des méthodes abstraites sont appelées classes abstraites. Il existe deux manières principales d'utiliser la classe

 : Il existe deux manières principales d'utiliser la classe

, l'une consiste à utiliser le nouveau mot-clé, l'autre consiste à utiliser le "::" symbole :

Code PHP

Le code est le suivant :

<?php      
class TEST      
{      
    public static function name()       
    {      
        echo &#39;value&#39;;      
    }      
}      
//方法1：使用new关键字      
$test = new TEST;      
$test->name();      
//方法2：使用“::”符号      
TEST::name();      
?>

(1) : Utilisez le nouveau mot-clé pour devenir une instanciation. Le $test ci-dessus est une classe TEST Pour l'objet généré par l'instanciation, $test->name() est appelée la méthode de nom de l'objet $test.
(2) : Lorsque vous utilisez le mot-clé new pour utiliser une classe, vous pouvez utiliser $this pour faire référence à la classe elle-même.
(3) : La condition préalable à l'utilisation du symbole '::' est que la méthode doit avoir le mot-clé static. Lors de l'utilisation du mot-clé new, la méthode appelée doit avoir le mot-clé public (si une méthode n'a pas le mot-clé public). mot-clé public , protected, private, la valeur par défaut est public)
(4) : La même classe peut être instanciée en plusieurs objets différents via le nouveau mot-clé, mais ils sont isolés les uns des autres " Lorsque le symbole ::" est ; utilisée, la méthode est partagée entre plusieurs usages :

Code PHP

Le code est le suivant :

<?php      
class TEST1      
{      
    public $name = 0;      
    public function name()       
    {      
        $this->name = $this->name + 1;      
    }      
}      
$test1 = new TEST1;      
$test2 = new TEST1;      
$test1->name(); //$name1 == 1      
$test2->name(); //$name1 == 1      
/*--------------------------------------------*/     
class TEST2      
{      
    public static $name = 0;      
    public static function name()       
    {      
        TEST2::$name = TEST2::$name + 1;      
    }      
}      
TEST2::name(); // $name == 1      
TEST2::name(); // $name == 2      
?>

Relation entre classes :

La relation entre les classes comprend principalement l'abstraction, l'interface et l'héritage :

Code PHP

Le code est le suivant :

<?php      
abstract class TEST1 // 抽象      
{      
    abstract public function name1();      
    public function name2()      
    {      
    }      
}      
class TEST2 extends TEST1 implements TEST3 // 继承      
{      
    public function name1()      
    {      
    }      
}      
interface TEST3 // 接口      
{      
    public function name2();      
}      
?>

(1) Les classes avec le mot-clé abstract sont des classes abstraites, et les méthodes avec le mot-clé abstract sont des méthodes abstraites. Les méthodes abstraites des classes abstraites doivent être remplacées dans les sous-classes.
(2) Une classe avec le mot-clé interface est une interface. Les interfaces ne sont autorisées à implémenter aucune méthode. Toutes les méthodes de l'interface doivent être remplacées dans les sous-classes.
(3) Ceux avec les mots classA extends classB ou classA Implements classB sont l'héritage extends signifie hériter d'une autre classe, et Implements signifie hériter d'une autre interface. Une seule classe peut être étendue à la fois, mais plusieurs interfaces peuvent être implémentées.
(4) Les classes abstraites, les interfaces et finalement les méthodes héritées et implémentées doivent être publiques.

Pendant le processus d'héritage, la sous-classe écrasera la méthode de la classe parent du même nom. À ce stade, si vous devez appeler la méthode de la classe parent dans la sous-classe, vous pouvez utiliser le parent. mot-clé ou le nom de la classe plus ":: "Appel du symbole :

Code PHP

Le code est le suivant :

<?php      
class TEST1 extends TEST2      
{      
    public function name()      
    {      
        echo parent::name2();      
        echo TEST2::name2();      
    }      
}      
class TEST2      
{      
    public function name2()      
    {      
        echo &#39;value2&#39;;      
    }      
}      
$test = new TEST1;      
$test->name();      
?>

Voici une autre explication de la méthode '::' dans la classe Les fonctions de Canal d'appel.

La relation entre les objets est principalement "==" égal, "===" tous égaux, non égaux et clone : ​​

Code PHP

<?php     
class TEST     
{     
    public function name()     
    {     
    }     
}     
$test1 = new TEST;     
$test2 = new TEST;     
$test3 = $test1;     
echo $test1 == $test2 ? true : false; // true     
echo $test1 == $test3 ? true : false; // true     
echo $test2 == $test3 ? true : false; // true     
echo $test1 === $test2 ? true : false; // false     
echo $test1 === $test3 ? true : false; // true     
echo $test2 === $test3 ? true : false; // false     
?>

（1）两个类只要拥有相同的属性和方法，就是“==”等于。
（2）两个类必须是指向的同一个对象，才能是“===”全等于。

clone比较特殊，在上面的例子中，$test3 = $test1的过程并不是给了 $test3 一份 $test1 对象的拷贝，而是让 $test3 指向了 $test1，如果一定要获得一份$test1的拷贝，就必须使用clone关键字：

PHP代码

代码如下:

<?php      
$test3 = clone $test1;      
?>

类的钩子：

__autoload：
是一个函数名，也是唯一一个在类的外部使用的钩子，在实例化一个对象的时候，如果没有预先载入类，就会调用这个钩子。

__construct
在类被实例话的时候，被调用的钩子，可以做一些初始化的操作。

__destruct
在类被销毁的时候，被调用的钩子。

__call
当对象试图调用一个不存在的方法的时候，被调用的钩子

__sleep
当使用serialize()函数对一个类进行序列话操作的时候，会调用这个钩子

__wakeup
当使用unserialize()函数对一个类进行反序列话操作的时候，会调用这个钩子

__toString
当一个对象将被转变为字符串的时候，会调用这个钩子（比如echo的时候）

__set_state
当调用var_export()函数操作一个类的时候，会调用这个钩子

__clone
当使用clone关键字对一个类进行拷贝操作的时候，会调用这个钩子

__get
在获取一个类中的属性值的时候，会调用这个钩子

__set
在设置一个类中的属性值的时候，会调用这个钩子

__isset
在使用isset()函数对类中的属性值进行判定的时候，会调用这个钩子

__unset
在使用unset()函数销毁一个属性值的时候，会调用这个钩子

类的小技巧：

在实例话一个类的时候，可以使用这样的形式给__construct钩子传递参数：

PHP代码

代码如下:

<?php      
class TEST      
{      
    public function __construct($para)      
    {      
        echo $para;      
    }      
}      
$test = new TEST(&#39;value&#39;); // 显示 value      
?>

foreach()函数可以用来对类或者对象中的属性进行遍历，遍历的时候会先判断public, protected, private的情况而显示：

PHP代码

代码如下:

<?php      
class TEST      
{      
    public $property1 = &#39;value1&#39;;      
    public $property2 = &#39;value2&#39;;      
    public $property3 = &#39;value3&#39;;      
    public function name()      
    {      
        foreach($this as $key => $value)      
        {      
            print "$key => $value\n";      
        }      
    }      
}      
$test = new TEST;      
foreach($test as $key => $value)      
{      
    print "$key => $value\n";      
}      
$test->name();      
?>

在给类中的方法传递参数的时候，可以对参数进行强制的判定，这里只支持对数组和对象的判定：

PHP代码

代码如下:

<?php      
class TEST1      
{      
    public function name( TEST2 $para )      
    {      
    }      
}      
class TEST2      
{      
}      
$test2 = new TEST2;      
$test1 = new TEST1;      
$test1->name(&#39;value&#39;); // 会报错，因为这个参数必须是TEST2实例化以后的对象      
$test1->name($test1); // 不会报错      
?>

兼容php4的语法：

php5的类是往下兼容php4的，这些php4时代的语法也得到了继承，但是并不建议在php5的环境中使用。

（1）使用var预设属性，会自动转换成public。

（2）使用类名作为构造函数，在没有__construct构造方法的情况下，会寻找和类名相同的函数作为构造函数。

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!