注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

88AVI-WEBZONE8-天空网

是金子总要发光的,但是当满地都是金子的时候,我自己也不知道自己是哪颗了

 
 
 

日志

 
 
关于我

两个人交谈,一个人可以洗耳恭听。但是,三个人则无法互谈这人世最严肃而应深究的事。 我们应该注意自己不用语言去伤害别的同志,但是,当别人用语言来伤害自己的时候,也应该受得起。 要对别人隐瞒我们知识的局限,最可靠的方法就是不要越过那界限。 不登高山,不知天之高也,不临深溪,不知地之厚也。 不飞则已,一飞冲天,不鸣则已,一鸣惊人!!!!!

网易考拉推荐

php5中类的学习  

2008-05-15 16:29:02|  分类: php |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |

类的结构:

类的内部能可能有三种东西,就是常量(constant),属性(property)和方法(method),功能可以理解成类外部的常量,变量和函数。

PHP代码

  1. <?php   
  2. class TEST   
  3. {   
  4.     const NAME = 'value'; // 常量   
  5.     public $name = 'value'; // 属性   
  6.     public function name() // 方法   
  7.     {   
  8.         echo 'value';   
  9.     }   
  10. }   
  11. ?>  

在这之中,属性和方法又可以使用public, protected, private三个不同的关键字来将属性和方法的作用范围做进一步的区分,带有private关键字的属性和方法,只有所在的类中的方法才能调用;带有protected关键字的属性和方法,除了自己以外,自己的父类和子类中的方法也可以调用;带有public关键字的属性和方法,则可以从实例化以后的对象中进行调用,这样做最大的好处给所有的属性和方法增加了一些描述的特征,更便于整理和组织代码的结构。const关键字先跳过,和后面的static一起讲。

static关键字是有别于public, protected, private的另一类型关键字(因此可以和public, protected, private叠加起来使用):

PHP代码

  1. <?php   
  2. class TEST   
  3. {   
  4.     public static function name()    
  5.     {   
  6.         echo 'value';   
  7.     }   
  8. }   
  9. ?>  

带有static关键字的方法,可以在不对类进行实例化的情况下直接通过“::”符号调用,和public, protected, private的搭配,也可以让调用区分权限,但是一般都是和public搭档,前面提到的常量关键字const,应该就是public static类型的,因此只能通过self::NAME,TEST::NAME这样的形式调用常量,后面的__construct,__destruct等方法,都是属于static。

类的结构部分,最后介绍的两个关键字是abstract和final,abstract关键字表示这个类必须被他的子类覆写,而final关键字表示这个类必须不能被他的子类覆写,这两个关键字的功能是正好相反的,带有abstract的方法被成为抽象方法,带有抽象方法的类,成为抽象类,这个在后面还有介绍。

类的使用:

类的使用主要有两种方法,一种是使用new关键字,另一种是使用“::”符号:

PHP代码

  1. <?php   
  2. class TEST   
  3. {   
  4.     public static function name()    
  5.     {   
  6.         echo 'value';   
  7.     }   
  8. }   
  9. //方法1:使用new关键字   
  10. $test = new TEST;   
  11. $test->name();   
  12.     
  13. //方法2:使用“::”符号   
  14. TEST::name();   
  15. ?>  

(1):使用new关键字成为实例化,上面的$test就是一个通过TEST类实例化而产生的对象,$test->name()称为调用$test对象的name方法。

(2):使用new关键字使用类的时候,可以使用$this来指代类本身。

(3):使用“::”符号的前提是方法必须是带有static关键字的,使用new关键字时,被调用的方法,必须带有public关键字(一个方法如果不带public, protected, private中的任何一个关键字,则默认为public)

(4):同一个类可以通过new关键字被实例成多个不同的对象,但是彼此之间的是隔离的;“::”符号在使用的时候,方法在多次使用之间,是共享的:

PHP代码

  1. <?php   
  2. class TEST1   
  3. {   
  4.     public $name = 0;   
  5.     public function name()    
  6.     {   
  7.         $this->name = $this->name + 1;   
  8.     }   
  9. }   
  10.     
  11. $test1 = new TEST1;   
  12. $test2 = new TEST1;   
  13. $test1->name(); //$name1 == 1   
  14. $test2->name(); //$name1 == 1   
  15.     
  16. /*--------------------------------------------*/  
  17.     
  18. class TEST2   
  19. {   
  20.     public static $name = 0;   
  21.     public static function name()    
  22.     {   
  23.         TEST2::$name = TEST2::$name + 1;   
  24.            
  25.     }   
  26. }   
  27. TEST2::name(); // $name == 1   
  28. TEST2::name(); // $name == 2   
  29. ?>  

类的关系:

类与类之间的关系,主要有抽象,接口和继承:

PHP代码

  1. <?php   
  2. abstract class TEST1 // 抽象   
  3. {   
  4.     abstract public function name1();   
  5.     public function name2()   
  6.     {   
  7.            
  8.     }   
  9. }   
  10.     
  11. class TEST2 extends TEST1 implements TEST3 // 继承   
  12. {   
  13.     public function name1()   
  14.     {   
  15.            
  16.     }   
  17. }   
  18.     
  19. interface TEST3 // 接口   
  20. {   
  21.     public function name2();   
  22. }   
  23. ?>  

(1)带有abstract关键字的类是抽象类,带有abstract关键字的方法是抽象方法,抽象类中的抽象方法,必须在子类中被覆写。

(2)带有interface关键字的类,就是接口,接口不允许实现任何的方法,接口中所有的方法,都必须在子类中被覆写。

(3)带有 classA extends classB 或者 classA implements classB 字样的就是继承,extends表示继承另一个类,implements表示继承另一个接口,一次只能extends一个类,但是可以implements多个接口。

(4)抽象类,接口,以及最终继承并实现的方法,都必须是public的。

在继承的过程中,子类会覆写父类的同名方法,这个时候如果需要在子类中调用父类的方法,可以使用parent关键字或者类名加上“::”符号调用:

PHP代码

  1. <?php   
  2. class TEST1 extends TEST2   
  3. {   
  4.     public function name()   
  5.     {   
  6.         echo parent::name2();   
  7.         echo TEST2::name2();   
  8.     }   
  9. }   
  10. class TEST2   
  11. {   
  12.     public function name2()   
  13.     {   
  14.         echo 'value2';   
  15.     }   
  16. }   
  17. $test = new TEST1;   
  18. $test->name();   
  19. ?>  

这里再解释一下“::”方法在类中的作用,一个作用是在没有实例化的情况下调用常量(其实也理解成static就可以了),static属性和方法,再一个是在类的内部,通过self,parent和类名建立便捷的调用通道。

对象于对象之间的关系,主要是“==”等于,“===”全等于,不等于和clone:

PHP代码

  1. <?php   
  2. class TEST   
  3. {   
  4.     public function name()   
  5.     {   
  6.            
  7.     }   
  8. }   
  9.     
  10. $test1 = new TEST;   
  11. $test2 = new TEST;   
  12. $test3 = $test1;   
  13. echo $test1 == $test2 ? true : false; // true   
  14. echo $test1 == $test3 ? true : false; // true   
  15. echo $test2 == $test3 ? true : false; // true   
  16. echo $test1 === $test2 ? true : false; // false   
  17. echo $test1 === $test3 ? true : false; // true   
  18. echo $test2 === $test3 ? true : false; // false   
  19. ?>  

(1)两个类只要拥有相同的属性和方法,就是“==”等于。

(2)两个类必须是指向的同一个对象,才能是“===”全等于。

clone比较特殊,在上面的例子中,$test3 = $test1的过程并不是给了 $test3 一份 $test1 对象的拷贝,而是让 $test3 指向了 $test1,如果一定要获得一份$test1的拷贝,就必须使用clone关键字:

PHP代码

  1. <?php   
  2. $test3 = clone $test1;   
  3. ?>  

类的钩子:

__autoload:

是一个函数名,也是唯一一个在类的外部使用的钩子,在实例化一个对象的时候,如果没有预先载入类,就会调用这个钩子。

__construct

在类被实例话的时候,被调用的钩子,可以做一些初始化的操作。

__destruct

在类被销毁的时候,被调用的钩子。

__call

当对象试图调用一个不存在的方法的时候,被调用的钩子

__sleep

当使用serialize()函数对一个类进行序列话操作的时候,会调用这个钩子

__wakeup

当使用unserialize()函数对一个类进行反序列话操作的时候,会调用这个钩子

__toString

当一个对象将被转变为字符串的时候,会调用这个钩子(比如echo的时候)

__set_state

当调用var_export()函数操作一个类的时候,会调用这个钩子

__clone

当使用clone关键字对一个类进行拷贝操作的时候,会调用这个钩子

__get

在获取一个类中的属性值的时候,会调用这个钩子

__set

在设置一个类中的属性值的时候,会调用这个钩子

__isset

在使用isset()函数对类中的属性值进行判定的时候,会调用这个钩子

__unset

在使用unset()函数销毁一个属性值的时候,会调用这个钩子

类的小技巧:

在实例话一个类的时候,可以使用这样的形式给__construct钩子传递参数:

PHP代码

  1. <?php   
  2. class TEST   
  3. {   
  4.     public function __construct($para)   
  5.     {   
  6.         echo $para;   
  7.     }   
  8. }   
  9.     
  10. $test = new TEST('value'); // 显示 value   
  11. ?>  

foreach()函数可以用来对类或者对象中的属性进行遍历,遍历的时候会先判断public, protected, private的情况而显示:

PHP代码

  1. <?php   
  2. class TEST   
  3. {   
  4.     public $property1 = 'value1';   
  5.     public $property2 = 'value2';   
  6.     public $property3 = 'value3';   
  7.        
  8.     public function name()   
  9.     {   
  10.         foreach($this as $key => $value)   
  11.         {   
  12.             print "$key => $value\n";   
  13.         }   
  14.     }   
  15. }   
  16.     
  17. $test = new TEST;   
  18. foreach($test as $key => $value)   
  19. {   
  20.     print "$key => $value\n";   
  21. }   
  22. $test->name();   
  23. ?>  

在给类中的方法传递参数的时候,可以对参数进行强制的判定,这里只支持对数组和对象的判定:

PHP代码

  1. <?php   
  2. class TEST1   
  3. {   
  4.     public function name( TEST2 $para )   
  5.     {   
  6.            
  7.     }   
  8. }   
  9.     
  10. class TEST2   
  11. {   
  12.        
  13. }   
  14.     
  15. $test2 = new TEST2;   
  16. $test1 = new TEST1;   
  17.     
  18. $test1->name('value'); // 会报错,因为这个参数必须是TEST2实例化以后的对象   
  19. $test1->name($test1); // 不会报错   
  20. ?>  

兼容php4的语法:

php5的类是往下兼容php4的,这些php4时代的语法也得到了继承,但是并不建议在php5的环境中使用。

(1)使用var预设属性,会自动转换成public。

(2)使用类名作为构造函数,在没有__construct构造方法的情况下,会寻找和类名相同的函数作为构造函数。

  评论这张
 
阅读(198)| 评论(0)
推荐 转载

历史上的今天

在LOFTER的更多文章

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017