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

在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. } 
11. class ChildClass extends BaseClass { 
12.    public function moreTesting() { 
13.        echo "ChildClass::moreTesting() called＼n"; 
14.    } 
15. } 
16. // 产生 Fatal error: Cannot override final method BaseClass::moreTesting() 
17. ?>  

方法实例二:

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. } 
12. class ChildClass extends BaseClass { 
13. } 
14. // 产生 Fatal error: Class ChildClass may not inherit from final class (BaseClass) 
15. ?> 

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

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

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

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

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

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

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

例1代码如下:

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

例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. } 
11. class Student extends Person { 
12.     function study() { 
13.         echo "我是". parent::$country."人<br />"; 
14.     } 
15. } 
16. // 输出成员属性值 
17. echo Person::$country."<br />";  // 输出：中国 
18. $p1 = new Person(); 
19. //echo $p1->country;   // 错误写法 
20. // 访问静态成员方法 
21. Person::myCountry();   // 输出：我是中国人 
22. // 静态方法也可通过对象访问： 
23. $p1->myCountry(); 
24. // 子类中输出成员属性值 
25. echo Student::$country."<br />"; // 输出：中国 
26. $t1 = new Student(); 
27. $t1->study();    // 输出：我是中国人 
28. ?> 

运行该例子，输出：

中国

我是中国人

我是中国人

中国

我是中国人

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

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

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. // 输出常量 
11. echo Person::country."<br />"; 
12. // 访问方法 
13. $p1 = new Person(); 
14. $p1 -> myCountry(); 
15. ?> 

运行该例子输出：

中国

我是中国人

PHP中小常用魔术方法：

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

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

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

void __clone(void)

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

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

__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. ?>