Explication détaillée des mots-clés et méthodes magiques couramment utilisés en PHP orienté objet

1.construct()

L'objet instancié est automatiquement appelé. Construct est appelé lorsque construct et la fonction avec le nom de classe et le nom de fonction existent en même temps, et que l'autre n'est pas appelée.

La fonction avec le nom de classe et le nom de fonction est l'ancienne version du constructeur.

2.destruct()

est appelé lors de la suppression d'un objet ou lorsqu'une opération sur un objet se termine.

3.call()

L'objet appelle une méthode. Si la méthode n'existe pas, appelez cette méthode

4.get()

Lire une propriété d'objet, si la propriété d'objet est privée elle sera appelée

5. set()

Lors de l'attribution d'une valeur à une propriété d'objet, elle sera appelée si la propriété est privée

6.toString()

Elle sera appelée lors de l'impression un objet.

7.clone()

Appelé lors du clonage d'un objet, tel que : $a=new test(); $a1=clone $a;

8.sleep ( )

Serialize a été appelé auparavant. Si l'objet est plus grand que et que vous souhaitez supprimer quelque chose pendant la sérialisation, vous pouvez l'utiliser.

9.wakeup()

est appelé lorsque Unserialize est utilisé pour effectuer un travail d'initialisation d'objet.

10.isset()

Détecte si les attributs d'un objet existent. Si l'attribut détecté est privé, il sera appelé.

11.unset()

Lors de la suppression d'un attribut d'objet, si l'attribut d'objet supprimé est privé, il sera appelé

12.set_state()

Appelé lorsque var_export est appelé. Utilisez la valeur de retour de set_state comme valeur de retour de var_export.

13.autoload()

Lors de l'instanciation d'un objet, si la classe correspondante n'existe pas, cette méthode sera utilisée.

---

L'éditeur suivant vous apportera une discussion détaillée des mots-clés orientés objet PHP et des méthodes magiques couramment utilisées. L'éditeur le trouve plutôt bon, je vais donc le partager avec vous maintenant et le donner comme référence pour tout le monde. Suivons l'éditeur et jetons un coup d'oeil

Mots-clés couramment utilisés en PHP orienté objet

final

1. Final ne peut pas modifier les attributs des membres (ce mot-clé n'est pas utilisé pour les constantes dans les classes)

2. Final ne peut modifier que les classes et les méthodes

Fonction :

Les classes modifiées avec final ne peuvent pas être héritées par les sous-classes

Les méthodes modifiées avec final ne peuvent pas être remplacées par les sous-classes

Utilisé pour restreindre l'héritage des classes, méthodes S'il n'est pas remplacé, utilisez final

<?php
//final修饰的类不能被继承
final class Person{
  var $name;
  var $age;
  var $sex;

  function construct($name,$age,$sex){
    $this->name=$name;
    $this->age=$age;
    $this->sex=$sex;
  }

  function fun1(){
    echo $this->name;
  }
}

//Student类继承类用final修饰的Person类，所以会报错
class Student extends Person{
}

$stu=new Student("zs",20,"nan");

$stu->fun1();
?>

static (mot-clé statique)

1. Utilisez static pour modifier les propriétés et les méthodes des membres , ne peut pas modifier la classe

2. Les attributs membres modifiés avec static peuvent être partagés par tous les objets de la même classe

3. Les données statiques sont stockées dans le segment de données en mémoire (segment statique initialisé). )

4. Les données statiques sont allouées à la mémoire lorsque la classe est chargée pour la première fois. Lorsque la classe est utilisée ultérieurement, elles sont obtenues directement à partir du segment de données

5. Qu'est-ce que la classe est en cours de chargement ? Tant que cette classe est utilisée dans le programme (ce nom de classe apparaît)

6. Les méthodes statiques (méthodes statiques modifiées) ne peuvent pas accéder aux membres non statiques (les membres statiques sont accessibles dans les méthodes non statiques)

Parce que les membres non statiques doivent être accessibles à l'aide d'objets. Pour accéder aux membres internes, $this est utilisé. Les méthodes statiques n'ont pas besoin d'être appelées à l'aide d'objets, donc il n'y a pas d'objet $this ne peut pas représenter un objet. Elle est non statique. Les membres doivent également utiliser des objets

Si vous êtes sûr que les membres non statiques ne sont pas utilisés dans une méthode, vous pouvez déclarer cette méthode comme méthode statique

Remarque : Les membres statiques doivent utiliser des noms de classe Pour y accéder, ne

créez pas d'objets, n'utilisez pas d'objets pour accéder au

Nom de classe :: membres statiques

Si vous utilisez des membres statiques dans une classe, vous pouvez utiliser self pour représenter cette classe

const

1 Elle ne peut modifier que les attributs des membres

. 2. Utilisez const

< pour déclarer des attributs constants dans une classe 🎜>3 La méthode d'accès est la même que les propriétés des membres statiques (utilisez class name::constant en dehors de la classe et self::constant à l'intérieur de la classe) <🎜. >

4. Les constantes doivent recevoir des valeurs initiales lorsqu'elles sont déclarées

<?php
//定义一个类“人们”
class Person{
  protected $name;
  protected $age;
  protected $sex;
  static $country="中国";
  //声明一个常量
  const RUN="走";

  //构造方法
  function construct($name,$age,$sex){
    $this->name=$name;
    $this->age=$age;
    $this->sex=$sex;
  }

  function getCountry(){
    //如果在类中使用静态成员，可以使用self代表本类
    return self::$country;
  }

  function say(){
    echo "我的名字：{$this->name}，我的年龄：{$this->age}，我的性别：{$this->sex}。<br>";
  }

  protected function eat(){
    echo "吃饭！<br>";
  }

  function run(){
    //在类的内部使用常量 self::常量
    echo self::RUN."<br>";
  }

  //声明静态的方法
  static function hello(){
    echo "你好<br>";
  }
}

Méthodes magiques couramment utilisées en PHP orienté objet

<. 🎜>call()

Fonction : Lors de l'appel d'une méthode qui n'existe pas dans l'objet, une erreur système apparaîtra, puis le programme sortira. Quand appeler automatiquement : il appellera automatiquement lors de l'appel d'une méthode qui n'existe pas dans un objet

Gérer certains appels d'erreur inexistants

Cette méthode nécessite deux paramètres

toString()

<?php
//定义一个类“人们”
class Person{
  protected $name;
  protected $age;
  protected $sex;
  static $country="中国";
  //声明一个常量
  const RUN="走";

  //构造方法
  function construct($name,$age,$sex){
    $this->name=$name;
    $this->age=$age;
    $this->sex=$sex;
  }

  function getCountry(){
    //如果在类中使用静态成员，可以使用self代表本类
    return self::$country;
  }

  function say(){
    echo "我的名字：{$this->name}，我的年龄：{$this->age}，我的性别：{$this->sex}。<br>";
  }

  protected function eat(){
    echo "吃饭！<br>";
  }

  function run(){
    //在类的内部使用常量 self::常量
    echo self::RUN."<br>";
  }

  //处理一些不存在的错误调用
  //就会在调用一个对象中不存在的方法时就会自动调用
  function call($methodName,$args){
    //$methodName调用不存在方法的方法名 $args里面的参数
    echo "你调用的方法{$methodName}（参数：";
    print_r($args);
    echo "）不存在<br>";
  }

  //声明静态的方法
  static function hello(){
    echo "你好<br>";
  }
}

$p=new Person("张三",20,"女");

$p->test(10,20,30);
$p->demo("aa","bb");
$p->say();
?>

est automatiquement appelé lors de la sortie directe d'une référence d'objet, utilisé pour obtenir rapidement la valeur maximale représentée par un chaîne. Méthode rapide

clone()

<?php
//定义一个类“人们”
class Person{
  protected $name;
  protected $age;
  protected $sex;
  static $country="中国";
  //声明一个常量
  const RUN="走";

  //构造方法
  function construct($name,$age,$sex){
    $this->name=$name;
    $this->age=$age;
    $this->sex=$sex;
  }

  function say(){
    echo "我的名字：{$this->name}，我的年龄：{$this->age}，我的性别：{$this->sex}。<br>";
  }

  function toString(){
    return self::$country."<br>{$this->name}<br>{$this->age}<br>{$this->sex}<br>".self::RUN;
  }
}

$p=new Person("张三",21,"女");
echo $p;
?>

L'objet clone est traité à l'aide de clone()Original ( original Object)

Copier (objet copié)

clone() est une méthode appelée automatiquement lors du clonage d'un objet

Dès qu'un objet est créé, il doit être initialisé L'action est similaire au constructeur constuct

在clone()方法中的$this关键字代表的是复本的对象,$that代表原本对象

<?php
//定义一个类“人们”
class Person{
  var $name;
  protected $age;
  protected $sex;
  static $country="中国";
  //声明一个常量
  const RUN="走";

  //构造方法
  function construct($name,$age,$sex){
    $this->name=$name;
    $this->age=$age;
    $this->sex=$sex;
  }

  function say(){
    echo "我的名字：{$this->name}，我的年龄：{$this->age}，我的性别：{$this->sex}。<br>";
  }

  function clone(){
    $this->name="王五";
    $this->age=18;
    $this->sex="男";
  }

  function destruct(){
    echo $this->name."<br>";
  }
}

$p=new Person("张三",21,"女");
$p->say();
//这并不能叫做克隆对象，因为在析构时只析构一次
/*$p1=$p;
$p1->name="李四";
$p1->say();*/

$p1= clone $p;
$p1->say();
?>

autoload()

注意：其它的魔术方法都是在类中添加起作用，这是唯一一个不在类中添加的方法

只要在页面中使用到一个类，只要用到类名，就会自动将这个类名传给这个参数

<?php
function autoload($className){
  include "./test/".$className.".class.php";
}

  $o=new One;
  $o->fun1();  

  $t=new Two;
  $t->fun2();

  $h=new Three;
  $h->fun3();

?>

test里的文件

one.class.php

<?php
class One{
  function fun1(){
    echo "The Class One<br>";
  }
}
?>

two.class.php

<?php
class Two{
  function fun2(){
    echo "The Class Two<br>";
  }
}
?>

three.class.php

<?php
class Three{
  function fun3(){
    echo "The Class Three<br>";
  }
}
?>

对象串行化（序列化）：将一个对象转为二进制串（对象是存储在内存中的，容易释放）

使用时间：

1.将对象长时间存储在数据库或文件中时

2.将对象在多个PHP文件中传输时

serialize(); 参数是一个对象，返回来的就是串行化后的二进制串

unserialize(); 参数就是对象的二进制串，返回来的就是新生成的对象

sleep()

是在序列化时调用的方法

作用：就是可以将一个对象部分串行化

只要这个方法中返回一个数组，数组中有几个成员属性就序列化几个成员属性，如果不加这个方法，则所有成员都被序列化

wakeup()

是在反序列化时调用的方法

也是对象重新诞生的过程

<?php
//定义一个类“人们”
class Person{
  var $name;
  protected $age;
  protected $sex;
  static $country="中国";
  //声明一个常量
  const RUN="走";

  //构造方法
  function construct($name,$age,$sex){
    $this->name=$name;
    $this->age=$age;
    $this->sex=$sex;
  }

  function say(){
    echo "我的名字：{$this->name}，我的年龄：{$this->age}，我的性别：{$this->sex}。<br>";
  }

  function clone(){
    $this->name="王五";
    $this->age=18;
    $this->sex="男";
  }

  //是在序列化时调用的方法，可以部分串行化对象
  function sleep(){
    return array("name","age");
  }

  //是在反序列化时调用的方法，也是对象重新诞生的过程。可以改变里面的值
  function wakeup(){
    $this->name="sanzhang";
    $this->age=$this->age+1;
  }

  function destruct(){

  }
}
?>

read.php

<?php
  require "11.php";
  
  $str=file_get_contents("mess.txt");
  $p=unserialize($str);

  echo $p->say();
?>

write.php

<?php
  require "11.php";

  $p=new Person("张三",18,"男");

  $str=serialize($p);

  file_put_contents("mess.txt",$str);
?>

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!