Explication détaillée des didacticiels sur les mots-clés de classe et de méthode PHP

Ce qui suit est un tutoriel sur les classes PHP et les mots-clés de méthode que j'ai compilé pour vous. Les étudiants intéressés peuvent le consulter.

1. final
Si nous ne voulons pas qu'une classe soit héritée, nous utilisons final pour modifier la classe. Cette classe ne sera pas héritée.
final --- utilisé avant les cours et les méthodes.
Classe finale --- ne peut pas être héritée.
Méthode finale --- ne peut pas être remplacée.
2. Public signifie global et est accessible par les sous-classes à l'intérieur et à l'extérieur de la classe ; private signifie privé et ne peut être utilisé qu'au sein de cette classe ; protected signifie protégé et n'est accessible que par cette classe, ces sous-classes ou classes parent;
3. ceci est un pointeur vers l'objet actuel (peut être considéré comme un pointeur en C), self est un pointeur vers la classe actuelle et parent est un pointeur vers la classe parent
self : Lorsque les variables et les méthodes sont définies sur static, dans cette classe, utilisez self
4, static
pour déclarer les membres de la classe ou les méthodes comme statiques, et vous pouvez y accéder directement sans instancier la classe. Vous ne pouvez pas accéder aux membres statiques (. sauf méthodes statiques) via un objet. Les membres statiques appartiennent à la classe et n'appartiennent à aucune instance d'objet, mais les instances d'objet de la classe peuvent être partagées.
Jetons ensuite un coup d'œil à la différence entre l'utilisation de $object->… et l'utilisation de class::…:
1 Lorsque vous utilisez $object->…, vous devez exécuter le constructeur<.>Créer des objets ; 2. Utilisez class::... pour appeler des méthodes/variables statiques, sans exécuter le constructeur pour créer des objets ; pour appeler des méthodes/variables non statiques, il n'est pas non plus nécessaire d'exécuter un constructeur pour créer un objet.
5. résumé
1.
Classe abstraite
classe abstraite1. Une classe abstraite fait référence à une classe avec le mot-clé abstrait ajouté avant la classe et une méthode abstraite (mot-clé abstrait ajouté avant le mot-clé fonction de la méthode de classe). 2． Les classes abstraites ne peuvent pas être instanciées directement. La classe abstraite définit uniquement (ou implémente partiellement) les méthodes requises par la sous-classe. Les sous-classes peuvent rendre concrète une classe abstraite en en héritant et en implémentant toutes les méthodes abstraites de la classe abstraite.
3． Si une sous-classe doit être instanciée, elle doit implémenter toutes les méthodes abstraites de la classe abstraite. Si la sous-classe n'implémente pas toutes les méthodes abstraites de la classe abstraite, alors la sous-classe est également une classe abstraite et doit être précédée du mot-clé abstract dans class et ne peut pas être instanciée.
6. Interface utilisateur
1. Les classes abstraites fournissent des normes pour une implémentation concrète, tandis que les interfaces sont de purs modèles. Les interfaces définissent uniquement les fonctions, pas le contenu de l'implémentation. Les interfaces sont déclarées avec le mot-clé interface.
2． L'interface est complètement abstraite. Elle ne peut déclarer que des méthodes et uniquement des méthodes publiques. Elle ne peut pas déclarer de méthodes privées et protégées, ne peut pas définir de corps de méthode et ne peut pas déclarer de variables d'instance. Cependant, les interfaces peuvent déclarer des variables constantes. Mais placer des variables constantes dans une interface viole son objectif d'exister en tant qu'interface et confond également les différentes valeurs des interfaces et des classes. Si vous en avez vraiment besoin, vous pouvez le mettre dans la classe abstraite ou la classe correspondante.
7. instanceof
Un autre nouveau membre de PHP5 est le mot-clé instdnceof. Utilisez ce mot-clé pour déterminer si un objet est une instance d'une classe, une sous-classe d'une classe ou implémente une interface spécifique et effectuez les opérations correspondantes. Dans certains cas, nous souhaitons déterminer si une classe est d'un type spécifique ou implémente une interface spécifique. L'instanceof
operator
est parfaite pour cette tâche. L'opérateur instanceof vérifie trois choses : si l'instance est d'un type spécifique, si l'instance hérite d'un type spécifique et si l'instance ou l'une de ses classes ancêtres implémente une interface spécifique. Par exemple, supposons que vous souhaitiez savoir si l'objet nommé manager est une instance de la classe Employee :

$manager = new Employee();
if ($manager instanceof Employee)
  echo "Yes";
有两点值得注意。首先，类名没有任何定界符（引号）。使用定界符将导致
语法错误
。其次，如果比较失败，脚本将退出执行。instanceof关键字在同时处理多个对象时特别有用。例如，你可能要重复地调用某个函数，但希望根据对象类型调整函数的行为。可以使用case语句和instanceof关键字来实现这个目标。
class test{}
class test{}
class testChilern 
Extends
 test{}
$a = new test();
$m = new test();
$i = ($m instanceof test);
if($i)
  echo &#39;$m是类test的实例！<br />&#39;; // get this value
switch ($a instanceof test){
  case true :
    echo &#39;YES<br />&#39;;
    break;
  case false :
    echo &#39;No<br />&#39;; //get this value
    break;
}
$d=new testChilern();
if($d instanceof test)echo &#39;$d是类test的子类！<br />&#39;; // get this value

Première utilisation :

<?php
$obj = new A();
if ($obj instanceof A) {
  echo &#39;A&#39;;
}

<?php
interface ExampleInterface
{
   public function interfaceMethod();
 }
 class ExampleClass implements ExampleInterface
{
   public function interfaceMethod()
   {
     return &#39;Hello World!&#39;;
   }
 }
$exampleInstance = new ExampleClass();
 if($exampleInstance instanceof ExampleInterface){
   echo &#39;Yes, it is&#39;;
 }else{
   echo &#39;No, it is not&#39;;
} 
?>

<?php
class Foo {
   public $foobar = &#39;Foo&#39;;
   public function test() {
     echo $this->foobar . "\n";
   }
 }
 class Bar extends Foo {
   public $foobar = &#39;Bar&#39;;
 }
$a = new Foo();
$b = new Bar();
echo "use of test() method\n";
$a->test();
$b->test();
echo "instanceof Foo\n";
var_dump($a instanceof Foo); // TRUE
var_dump($b instanceof Foo); // TRUE
echo "instanceof Bar\n";
var_dump($a instanceof Bar); // FALSE
var_dump($b instanceof Bar); // TRUE
echo "subclass of Foo\n";
var_dump(is_subclass_of($a, &#39;Foo&#39;)); // FALSE
var_dump(is_subclass_of($b, &#39;Foo&#39;)); // TRUE
echo "subclass of Bar\n";
var_dump(is_subclass_of($a, &#39;Bar&#39;)); // FALSE
var_dump(is_subclass_of($b, &#39;Bar&#39;)); // FALSE
?>
 输出结果（PHP 5.4.4）：
 use of test() method
 Foo
 Bar
 instanceof Foo
 bool(true)
 bool(true)
 instanceof Bar
 bool(false)
 bool(true)
 subclass of Foo
 bool(false)
 bool(true)
 subclass of Bar
 bool(false)

Articles connexes :

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!