当前位置：Gxlcms > PHP教程 > PHP面向对象中常用的关键字和魔术方法详解

PHP面向对象中常用的关键字和魔术方法详解

时间：2021-07-01 10:21:17 帮助过：35人阅读

本篇文章主要介绍PHP面向对象中常用的关键字和魔术方法详解，感兴趣的朋友参考下，希望对大家有所帮助。

PHP面向对象中常用的关键字

final

1.final不能修饰成员属性（类中常量不是用这个关键字）

2.final只能修饰类和方法

作用：

使用final修饰的类不能被子类继承

使用final修饰的方法不能被子类覆盖

用来限制类不被继承，方法不被覆盖就使用final

  1. <?php
  2. //final修饰的类不能被继承
  3. final class Person{
  4.   var $name;
  5.   var $age;
  6.   var $sex;
  7.   function __construct($name,$age,$sex){
  8.     $this->name=$name;
  9.     $this->age=$age;
  10.     $this->sex=$sex;
  11.   }
  12.   function fun1(){
  13.     echo $this->name;
  14.   }
  15. }
  16. //Student类继承类用final修饰的Person类，所以会报错
  17. class Student extends Person{
  18. }
  19. $stu=new Student("zs",20,"nan");
  20. $stu->fun1();
  21. ?>

static（静态关键字）

1.使用static可以修饰成员属性和成员方法，不能修饰类

2.用static修饰的成员属性，可以被同一个类的所有对象共享

3.静态的数据是存在内存中的数据段中（初始化静态段）

4.静态的数据是在类被第一次加载时分配到内存中的，以后再用到类时就直接从数据段中获取

5.什么是类被加载？只要在程序中使用到这个类（有这个类名出现）

6.静态方法（static修饰的方法），不能访问非静态的成员（在非静态方法中可以访问静态成员）

因为非静态的成员，就必须用对象来访问，访问内部成员使用的就是$this，而静态方法不用使用对象调用，也就没有对象，$this也就不能代表对象，非静态的成员还必须使用对象

如果你确定一个方法中不使用非静态成员，则可以将这个方法声明为即静态方法

注意：静态的成员都要使用类名去访问，不要创建对象，不用对象访问

类名::静态成员

如果在类中使用静态成员，可以使用self代表本类

const

1.它只能修饰成员属性

2.类中声明常量属性使用const

3.访问方式和static静态成员属性一样（在类外部使用 类名::常量 在类内部使用 self::常量）

4.常量一定要在声明的时候就给初值

  1. <?php
  2. //定义一个类“人们”
  3. class Person{
  4.   protected $name;
  5.   protected $age;
  6.   protected $sex;
  7.   static $country="中国";
  8.   //声明一个常量
  9.   const RUN="走";
  10.   //构造方法
  11.   function __construct($name,$age,$sex){
  12.     $this->name=$name;
  13.     $this->age=$age;
  14.     $this->sex=$sex;
  15.   }
  16.   function getCountry(){
  17.     //如果在类中使用静态成员，可以使用self代表本类
  18.     return self::$country;
  19.   }
  20.   function say(){
  21.     echo "我的名字：{$this->name}，我的年龄：{$this->age}，我的性别：{$this->sex}。<br>";
  22.   }
  23.   protected function eat(){
  24.     echo "吃饭！<br>";
  25.   }
  26.   function run(){
  27.     //在类的内部使用常量 self::常量
  28.     echo self::RUN."<br>";
  29.   }
  30.   //声明静态的方法
  31.   static function hello(){
  32.     echo "你好<br>";
  33.   }
  34. }

PHP面向对象中常用的魔术方法

__call()

作用：调用对象中不存在的方法时，就会出现系统报错，然后程序退出。

什么时候自动调用：就会在调用一个对象中不存在的方法时就会自动调用

处理一些不存在的错误调用

这个方法需要两个参数

  1. <?php
  2. //定义一个类“人们”
  3. class Person{
  4.   protected $name;
  5.   protected $age;
  6.   protected $sex;
  7.   static $country="中国";
  8.   //声明一个常量
  9.   const RUN="走";
  10.   //构造方法
  11.   function __construct($name,$age,$sex){
  12.     $this->name=$name;
  13.     $this->age=$age;
  14.     $this->sex=$sex;
  15.   }
  16.   function getCountry(){
  17.     //如果在类中使用静态成员，可以使用self代表本类
  18.     return self::$country;
  19.   }
  20.   function say(){
  21.     echo "我的名字：{$this->name}，我的年龄：{$this->age}，我的性别：{$this->sex}。<br>";
  22.   }
  23.   protected function eat(){
  24.     echo "吃饭！<br>";
  25.   }
  26.   function run(){
  27.     //在类的内部使用常量 self::常量
  28.     echo self::RUN."<br>";
  29.   }
  30.   //处理一些不存在的错误调用
  31.   //就会在调用一个对象中不存在的方法时就会自动调用
  32.   function __call($methodName,$args){
  33.     //$methodName调用不存在方法的方法名 $args里面的参数
  34.     echo "你调用的方法{$methodName}（参数：";
  35.     print_r($args);
  36.     echo "）不存在<br>";
  37.   }
  38.   //声明静态的方法
  39.   static function hello(){
  40.     echo "你好<br>";
  41.   }
  42. }
  43. $p=new Person("张三",20,"女");
  44. $p->test(10,20,30);
  45. $p->demo("aa","bb");
  46. $p->say();
  47. ?>

__toString()

直接输出对象引用的时候自动调用，用来快速获取字符串表示的最快捷的方法

  1. <?php
  2. //定义一个类“人们”
  3. class Person{
  4.   protected $name;
  5.   protected $age;
  6.   protected $sex;
  7.   static $country="中国";
  8.   //声明一个常量
  9.   const RUN="走";
  10.   //构造方法
  11.   function __construct($name,$age,$sex){
  12.     $this->name=$name;
  13.     $this->age=$age;
  14.     $this->sex=$sex;
  15.   }
  16.   function say(){
  17.     echo "我的名字：{$this->name}，我的年龄：{$this->age}，我的性别：{$this->sex}。<br>";
  18.   }
  19.   function __toString(){
  20.     return self::$country."<br>{$this->name}<br>{$this->age}<br>{$this->sex}<br>".self::RUN;
  21.   }
  22. }
  23. $p=new Person("张三",21,"女");
  24. echo $p;
  25. ?>

__clone()

克隆对象使用clone()处理

原本（原来的对象）

复本（复制出来的对象）

__clone()就是在克隆对象时自动调用的方法

只要一个对象一创建，就要有初始化的动作，和构造方法__constuct作用相似

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

  1. <?php
  2. //定义一个类“人们”
  3. class Person{
  4.   var $name;
  5.   protected $age;
  6.   protected $sex;
  7.   static $country="中国";
  8.   //声明一个常量
  9.   const RUN="走";
  10.   //构造方法
  11.   function __construct($name,$age,$sex){
  12.     $this->name=$name;
  13.     $this->age=$age;
  14.     $this->sex=$sex;
  15.   }
  16.   function say(){
  17.     echo "我的名字：{$this->name}，我的年龄：{$this->age}，我的性别：{$this->sex}。<br>";
  18.   }
  19.   function __clone(){
  20.     $this->name="王五";
  21.     $this->age=18;
  22.     $this->sex="男";
  23.   }
  24.   function __destruct(){
  25.     echo $this->name."<br>";
  26.   }
  27. }
  28. $p=new Person("张三",21,"女");
  29. $p->say();
  30. //这并不能叫做克隆对象，因为在析构时只析构一次
  31. /*$p1=$p;
  32. $p1->name="李四";
  33. $p1->say();*/
  34. $p1= clone $p;
  35. $p1->say();
  36. ?>

__autoload()

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

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

  1. <?php
  2. function __autoload($className){
  3.   include "./test/".$className.".class.php";
  4. }
  5.   $o=new One;
  6.   $o->fun1();  
  7.   $t=new Two;
  8.   $t->fun2();
  9.   $h=new Three;
  10.   $h->fun3();
  11. ?>

test里的文件

one.class.php

  1. <?php
  2. class One{
  3.   function fun1(){
  4.     echo "The Class One<br>";
  5.   }
  6. }
  7. ?>

two.class.php

  1. <?php
  2. class Two{
  3.   function fun2(){
  4.     echo "The Class Two<br>";
  5.   }
  6. }
  7. ?>

three.class.php

  1. <?php
  2. class Three{
  3.   function fun3(){
  4.     echo "The Class Three<br>";
  5.   }
  6. }
  7. ?>

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

使用时间：

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

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

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

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

__sleep()

是在序列化时调用的方法

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

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

__wakeup()

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

也是对象重新诞生的过程

  1. <?php
  2. //定义一个类“人们”
  3. class Person{
  4.   var $name;
  5.   protected $age;
  6.   protected $sex;
  7.   static $country="中国";
  8.   //声明一个常量
  9.   const RUN="走";
  10.   //构造方法
  11.   function __construct($name,$age,$sex){
  12.     $this->name=$name;
  13.     $this->age=$age;
  14.     $this->sex=$sex;
  15.   }
  16.   function say(){
  17.     echo "我的名字：{$this->name}，我的年龄：{$this->age}，我的性别：{$this->sex}。<br>";
  18.   }
  19.   function __clone(){
  20.     $this->name="王五";
  21.     $this->age=18;
  22.     $this->sex="男";
  23.   }
  24.   //是在序列化时调用的方法，可以部分串行化对象
  25.   function __sleep(){
  26.     return array("name","age");
  27.   }
  28.   //是在反序列化时调用的方法，也是对象重新诞生的过程。可以改变里面的值
  29.   function __wakeup(){
  30.     $this->name="sanzhang";
  31.     $this->age=$this->age+1;
  32.   }
  33.   function __destruct(){
  34.   }
  35. }
  36. ?>

read.php

  1. <?php
  2.   require "11.php";
  3.   
  4.   $str=file_get_contents("mess.txt");
  5.   $p=unserialize($str);
  6.   echo $p->say();
  7. ?>

write.php

  1. <?php
  2.   require "11.php";
  3.   $p=new Person("张三",18,"男");
  4.   $str=serialize($p);
  5.   file_put_contents("mess.txt",$str);
  6. ?>

以上就是本文的全部内容，希望对大家的学习有所帮助。


相关推荐：

PHP中关键字interface和implements图文详解

详细讲解php 类、方法关键字教程

了解SQL INNER JOIN 关键字的相关知识

以上就是PHP面向对象中常用的关键字和魔术方法详解的详细内容，更多请关注Gxl网其它相关文章！

人气教程排行

本站所有资源全部来源于网络，若本站发布的内容侵害到您的隐私或者利益，请联系我们删除！