当前位置:首页 > PHP教程 > php面向对象 > 列表

PHP中关键字与魔术方法介绍

发布:smiling 来源: PHP粉丝网  添加日期:2014-01-05 22:35:41 浏览: 评论:0 

在php中魔术方法与关键字都是我们常用的,关键字有final、static 、const,魔术方法__call()、__toString() 、_clone() 、__autoload() 等等。

PHP中常用的关键字

final  

1、final只能修饰类和方法,不能修饰成员属性,作用:使用修饰的类不能被继承,修饰的方法不能被覆盖,PHP 5 新增了一个 final 关键字,如果父类中的方法被声明为final,则子类无法覆盖该方法;如果一个类被声明为final,则不能被继承。

方法示例一,代码如下:

  1. <?php 
  2. class BaseClass { 
  3.    public function test() { 
  4.        echo "BaseClass::test() called\n"
  5.    } 
  6.     
  7.    final public function moreTesting() { 
  8.        echo "BaseClass::moreTesting() called\n"
  9.    } 
  10. class ChildClass extends BaseClass { 
  11.    public function moreTesting() { 
  12.        echo "ChildClass::moreTesting() called\n"
  13.    } 
  14. // 产生 Fatal error: Cannot override final method BaseClass::moreTesting() 
  15. ?>  

方法实例二:

  1. <?php 
  2. final class BaseClass { 
  3.    public function test() { 
  4.        echo "BaseClass::test() called\n"
  5.    } 
  6.     
  7.    // 这里无论你是否将方法声明为final,都没有关系 
  8.    final public function moreTesting() { 
  9.        echo "BaseClass::moreTesting() called\n"
  10.    } 
  11. class ChildClass extends BaseClass { 
  12. // 产生 Fatal error: Class ChildClass may not inherit from final class (BaseClass) 
  13. ?> 
static

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

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

3.静态的数据是存在于内存中的数据段中(初使化静态段)

4.静态的数据是在类第一次加载时分配到内存中的,后面用到时就可以直接使用了

5.只要在程序中有这个类名出现,即是类被加载,静态数据就会被分配到内存中了   注:静态的成员都要使用类名访

问:不用创建对象,不要用对象去访问静态成员,访问方法,类名::静态成员,如果在类中使用静态成员,可以使用self代表本类访问方法 self::静态成员

6.静态方法不能访问非静态成员,非静态方法可以访问静态成员,因为非静态成员必须用对象来访问,而静态成员不需要

例1代码如下:

  1. <?php 
  2. function test() 
  3.     static $var1=1; 
  4.     $var1+=2; 
  5.     echo $var1.' '
  6. test(); 
  7. test(); 
  8. test(); 
  9. ?> 

例2代码如下:

  1. <?php 
  2. Class Person{ 
  3.     // 定义静态成员属性 
  4.     public static $country = "中国"
  5.     // 定义静态成员方法 
  6.     public static function myCountry() { 
  7.         // 内部访问静态成员属性 
  8.         echo "我是".self::$country."人<br />"
  9.     } 
  10. class Student extends Person { 
  11.     function study() { 
  12.         echo "我是". parent::$country."人<br />"
  13.     } 
  14. // 输出成员属性值 
  15. echo Person::$country."<br />";  // 输出:中国 
  16. $p1 = new Person(); 
  17. //echo $p1->country;   // 错误写法 
  18. // 访问静态成员方法 
  19. Person::myCountry();   // 输出:我是中国人 
  20. // 静态方法也可通过对象访问: 
  21. $p1->myCountry(); 
  22. // 子类中输出成员属性值 
  23. echo Student::$country."<br />"// 输出:中国 
  24. $t1 = new Student(); 
  25. $t1->study();    // 输出:我是中国人 
  26. ?> 

运行该例子,输出:

中国

我是中国人

我是中国人

中国

我是中国人

首先,我们知道PHP中调用实例方法都是通过如:someobj->someFun()调用,那么我们调用静态函数是否也能像C#那样,通过SomeClass->someFun()调用呢?答案是否定的,在PHP中,对静态成员的调用只能通过::的方式进行,如:SomeClass::someFun(),代码如下:

  1. <?php 
  2. class TestC 
  3.     public static $var1=1; 
  4.     public $var2=1; 
  5.     function t1() 
  6.  { 
  7.         self::$var1+=2; 
  8.         echo self::$var1.'&nbsp;'
  9.         echo $this->var2.'&nbsp;'
  10.     } 
  11.     public static function t2() 
  12.  { 
  13.         self::$var1+=2; 
  14.         echo self::$var1.'&nbsp;'
  15.     } 
  16. $t=new TestC(); 
  17. $t->t1(); 
  18. TestC::t2();  
  19. ?> 

const

1.const只能修饰成员属性

2.类中使用const声明常量

3.用法类似定义一般常量

4.访问方式和静态成员是一样的(在类外 类名::常量名,类内 self::常量名)

5.常量一定要在声明时就给初值

语法:const constant = "value";

例子代码如下:

  1. <?php 
  2. Class Person{ 
  3.     // 定义常量 
  4.     const country = "中国"
  5.     public function myCountry() { 
  6.         //内部访问常量 
  7.         echo "我是".self::country."人<br />"
  8.     } 
  9. // 输出常量 
  10. echo Person::country."<br />"
  11. // 访问方法 
  12. $p1 = new Person(); 
  13. $p1 -> myCountry(); 
  14. ?> 

运行该例子输出:

中国

我是中国人

PHP中小常用魔术方法:

__call()   在调用对象中不存在的方法时,就会调用此方法。就会出现系统报错,然后程序会退出。声明此方法来对错误进行操作,阻止程序崩溃。

__toString()   直接输出对象引用时调用,用来快速获取对象的字符串表示的最便捷的方式,代码如下:

  1. <?php 
  2. // Declare a simple class 
  3. class TestClass 
  4.     public $foo
  5.     public function __construct($foo)  
  6.     { 
  7.         $this->foo = $foo
  8.     } 
  9.     public function __toString() { 
  10.         return $this->foo; 
  11.     } 
  12. $class = new TestClass('Hello'); 
  13. echo $class
  14. ?> 

void __clone(void)

当复制完成时,如果定义了__clone()方法,则新创建的对象(复制生成的对象)中的__clone()方法会被调用,可用于修改属性的值(如果有必要的话),代码如下:

  1. <?php 
  2. class SubObject 
  3.     static $instances = 0; 
  4.     public $instance
  5.     public function __construct() { 
  6.         $this->instance = ++self::$instances
  7.     } 
  8.     public function __clone() { 
  9.         $this->instance = ++self::$instances
  10.     } 
  11. class MyCloneable 
  12.     public $object1
  13.     public $object2
  14.     function __clone() 
  15.     { 
  16.        
  17.         // 强制复制一份this->object, 否则仍然指向同一个对象 
  18.         $this->object1 = clone $this->object1; 
  19.     } 
  20. $obj = new MyCloneable(); 
  21. $obj->object1 = new SubObject(); 
  22. $obj->object2 = new SubObject(); 
  23. $obj2 = clone $obj
  24.  
  25. print("Original Object:\n"); 
  26. print_r($obj); 
  27. print("Cloned Object:\n"); 
  28. print_r($obj2); 
  29. ?> 

__autoload()其它的魔术方法都是在类中添加起作用,这个是唯一一个不在类中添加的方法,只要在页面中使用到一个类,只要用到类名就会自动传进此方法,代码如下:

  1. <?php 
  2. session_start(); 
  3. require_once 'MyClass.php'
  4. $obj = new MyClass; 
  5. $_SESSION['obj'] = $obj
  6. ?> 

运行正常,然后在后续页面加载,代码如下:

  1. <?php 
  2. session_start(); 
  3. require_once 'MyClass.php'
  4. $_SESSION['obj']->callSomeMethod(); 
  5. ?> 

致命错误:脚本试图执行一个方法或访问一个不完整的对象的属性,请确保对象的类定义“MyClass”你想操作被加载 _before_ unserialize()调用或提供一个__autoload()函数来加载类定义,但是如果你这样做,它将正常工作,代码如下:

  1. <?php 
  2. require_once 'MyClass.php'
  3. session_start(); 
  4. $_SESSION['obj']->callSomeMethod(); 
  5. ?> 

对象串行化:将一个对象转化为二进制串

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

2.将对象在多个PHP文件中传输时,serialize():参数是一个对象,返回的是一个二进制串   unserialize():参数是对象的二进制串,返回的就是新生成的对象,__sleep()   在序列化时自动调用的方法(serialize)

作用:可以将一个对象部分序列化,只要这个方法中返回一个数据组,数组中有几个成员属性就序列化几个成员属性,如果不加,所有成员属性都被序列化 

__wakeup()   在反序列化时自动调用的方法(unserialize)   也就是对象重新诞生的一个过程

注意事项:PHP把所有以__(两个下划线)开头的类方法当成魔术方法。所以当你定义类方法时,除了上述魔术方法,建议不要以 __为前缀。


Tags: 关键字 魔术 方法

分享到: