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

PHP对象相关知识

发布:smiling 来源: PHP粉丝网  添加日期:2018-08-02 14:55:46 浏览: 评论:0 

对象传递:一种说法是“PHP对象是通过引用传递的”,更准确的说法是别名(标识符)传递,即它们都保存着同一个标识符(ID)的拷贝,这个标识符指向同一个对象的真正内容。

  1. classA { 
  2.  
  3.   public$foo= 1; 
  4.  
  5.  
  6. $a=newA; 
  7.  
  8. $b=$a;  // $a ,$b都是同一个标识符的拷贝 
  9.  
  10.       // ($a) = ($b) = 
  11.  
  12. $b->foo = 2; 
  13.  
  14. echo$a->foo."\n";//2 
  15.  
  16. $c=newA; 
  17.  
  18. $d= &$c// $c ,$d是引用 
  19.  
  20.       // ($c,$d) = 
  21.  
  22. $d->foo = 2; 
  23.  
  24. echo$c->foo."\n";//2 
  25.  
  26. $e=newA; 
  27.  
  28. functionfoo($obj) { 
  29.  
  30.   // ($obj) = ($e) = 
  31.  
  32.   $obj->foo = 2; 
  33.  
  34.  
  35. foo($e); 
  36. //phpfensi.com 
  37. echo$e->foo."\n";//2 

•对象复制:对象复制可以通过  clone 关键字来完成,如果原对象定义了 __clone() 方法,则新对象中的 __clone()  方法将在复制完后被调用,__clone() 方法可用于修改复制对象属性的值。当对象被复制后,会对对象的所有属性执行一个浅复制(shallow  copy),但所有的引用属性仍然会是一个指向原来的变量的引用。

  1. classSubObject  
  2.  
  3.  
  4.   static$instances= 0; 
  5.  
  6.   public$instance
  7.  
  8.    
  9.  
  10.   publicfunction__construct() 
  11.  
  12.   { 
  13.  
  14.     $this->instance = ++self::$instances
  15.  
  16.   } 
  17.  
  18.    
  19.  
  20.   publicfunction__clone() 
  21.  
  22.   { 
  23.  
  24.     $this->instance = ++self::$instances
  25.  
  26.   } 
  27.  
  28.  
  29.    
  30.  
  31. classMyCloneable 
  32.  
  33.  
  34.   public$object1
  35.  
  36.   public$object2
  37.  
  38.    
  39.  
  40.   function__clone() 
  41.  
  42.   { 
  43.  
  44.     // 强制复制一份this->object, 否则仍然指向同一个对象 
  45.  
  46.     $this->object1 =clone$this->object1; 
  47.  
  48.   } 
  49.  
  50.      
  51.  
  52.   functioncloneTest() 
  53.  
  54.   { 
  55.  
  56.     echo'cloneTest' 
  57.  
  58.   } 
  59.  
  60.  
  61. $obj=newMyCloneable();  
  62.  
  63. $obj->object1 =newSubObject(); 
  64.  
  65. $obj->object2 =newSubObject(); 
  66.  
  67. $obj2=clone$obj
  68.  
  69. print("Original Object:\n"); 
  70.  
  71. print_r($obj); 
  72.  
  73. print("Cloned Object:\n"); 
  74.  
  75. print_r($obj2); 
  76.  
  77. echo$obj2->cloneTest().":\n"
  78.  
  79. echo(newReflectionclass($obj2)); 
  80.  
  81. 上例输出结果: 
  82.  
  83. Original Object: 
  84.  
  85. MyCloneable Object 
  86.  
  87.  
  88.   [object1] => SubObject Object 
  89.  
  90.     ( 
  91.  
  92.       [instance] => 1 
  93.  
  94.     ) 
  95.  
  96.    
  97.  
  98.   [object2] => SubObject Object 
  99.  
  100.     ( 
  101.  
  102.       [instance] => 2 
  103.  
  104.     ) 
  105.  
  106.    
  107.  
  108.  
  109. Cloned Object: 
  110.  
  111. MyCloneable Object 
  112.  
  113.  
  114.   [object1] => SubObject Object 
  115.  
  116.     ( 
  117.  
  118.       [instance] => 3 
  119.  
  120.     ) 
  121.  
  122.    
  123.  
  124.   [object2] => SubObject Object 
  125.  
  126.     ( 
  127.  
  128.       [instance] => 2 
  129.  
  130.     ) 
  131.  
  132.    
  133.  
  134.  
  135. cloneTest: 
  136.  
  137. Class [classMyCloneable ] { 
  138.  
  139.  @@ /public/t.php 18-33 
  140.  
  141.    
  142.  
  143.  - Constants [0] { 
  144.  
  145.  } 
  146.  
  147.    
  148.  
  149.  - Static properties [0] { 
  150.  
  151.  } 
  152.  
  153.    
  154.  
  155.  - Static methods [0] { 
  156.  
  157.  } 
  158.  
  159.    
  160.  
  161.  - Properties [2] { 
  162.  
  163.   Property [public$object1
  164.  
  165.   Property [public$object2
  166.  
  167.  } 
  168.  
  169.    
  170.  
  171.  - Methods [2] { 
  172.  
  173.   Method [publicmethod __clone ] { 
  174.  
  175.    @@ /public/t.php 23 - 27 
  176.    //phpfensi.com 
  177.   } 
  178.  
  179.   Method [publicmethod cloneTest ] { 
  180.  
  181.    @@ /public/t.php 29 - 32 
  182.  
  183.   } 
  184.  
  185.  } 
  186.  

•对象遍历: foreach只能遍历对象的可见属性,无法遍历其方法,实现起来比较容易;另外,也可通过实现Iterator接口或IteratorAggregate接口的方法遍历对象属性。

•类型约束:   PHP作为一种弱类型语言,类型约束可以让编程更加规范,也少出些差错;类型约束不只能用在对象定义中,也能用在函数定义中。类型约束可指定对象、接口、array、callable(闭包callback),类型约束用来保证实际数据类型与原型定义一致,不一致则抛出一个可捕获的致命错误;不过如果定义了默认值为NULL,那么实参可以是NULL;类型约束不能用于标量类型如  int 或 string,Traits 也不允许。

•对象序列化与还原:函数serialize()可将打成包含字节流的字符串便于存储对象,函数unserialize()能够还原字符串为对象。但有一个前提是,无论序列化还是反序列化,对象的类定义已经完成,即需要先导入类(文件)。

•重载:PHP的重载包括属性和方法,更像一个套用说法,不支持常见的重载语法规范,具有不可预见性,影响范围更宽泛,就是利用魔术方法(magic  methods)来调用当前环境下未定义或不可见的类属性或方法。所有重载方法都必须被声明为  public(这一条应该比较好理解,别人可能因不可见才需要你,那你自己必须可见才行),参数也不能通过引用传递(重载方法具有不可预见性,估计出于安全方面的考虑吧,防止变量被随意引用)。在除  isset() 外的其它语言结构中无法使用重载的属性,这意味着当对一个重载的属性使用 empty() 时,重载魔术方法将不会被调用;  为避开此限制,必须将重载属性赋值到本地变量再使用 empty(),可见重载属性是介于合法属性与非法属性之间的存在。

[属性重载]:这些方法不能被声明为 static,在静态方法中,这些魔术方法将不会被调用

public void __set ( string $name , mixed $value )

在给不可访问属性赋值时,__set() 会被调用

public mixed __get ( string $name )

读取不可访问属性的值时,__get() 会被调用

public bool __isset ( string $name )

当对不可访问属性调用 isset() 或 empty() 时,__isset() 会被调用

public void __unset ( string $name )

当对不可访问属性调用 unset() 时,__unset() 会被调用

Note:

因为 PHP 处理赋值运算的方式,__set() 的返回值将被忽略。类似的, 在下面这样的链式赋值中,__get() 不会被调用:

$a = $obj->b = 8;

[方法重载]:

public mixed __call ( string $name , array $arguments )

在对象中调用一个不可访问方法时,__call() 会被调用

public static mixed __callStatic ( string $name , array $arguments )

在静态上下文中调用一个不可访问方法时,__callStatic() 会被调用

•静态属性和方法:static  关键字用来定义静态属性、静态方法,静态属性不能通过实例化的对象->  来访问(但静态方法可以)。静态属性只能被初始化为常量表达式,所以可以把静态属性初始化为整数或数组,但不能初始化为另一个变量或函数返回值,也不能指向一个对象。可以用一个变量表示类来动态调用静态属性,但该变量的值不能为关键字  self,parent 或 static。

  1. classFoo 
  2.  
  3.  
  4.   publicstatic$my_static='foo' 
  5.  
  6.   publicfunctionstaticValue() { 
  7.  
  8.     returnself::$my_static
  9.  
  10.   } 
  11.  
  12.  
  13. classBarextendsFoo 
  14.  
  15.  
  16.   publicfunctionfooStatic() { 
  17.  
  18.     returnparent::$my_static
  19.  
  20.   } 
  21.  
  22.   
  23. printFoo::$my_static."\n"
  24.  
  25. $foo=newFoo(); 
  26.  
  27. print$foo->staticValue() ."\n"
  28.  
  29. print$foo->my_static ."\n";  // Undefined "Property" my_static  
  30.  
  31. print$foo::$my_static."\n"
  32.  
  33. $classname='Foo' 
  34.  
  35. print$classname::$my_static."\n";// As of PHP 5.3.0 
  36.  
  37. printBar::$my_static."\n"
  38.  
  39. $bar=newBar(); 
  40.  
  41. print$bar->fooStatic() ."\n"

•后期静态绑定:static::  定义后期静态绑定工作原理是存储了上一个“非转发调用”(non-forwarding  call)的类名。当进行静态方法调用时,该类名即为明确指定的那个(通常在 ::  运算符左侧部分);当进行非静态方法调用时,即为该对象所属的类。使用 self:: 或者 __CLASS__  对当前类的静态引用,取决于定义当前方法所在的类;static::  不再被解析为定义当前方法所在的类,而是在实际运行时计算的,可以用于静态属性和所有方法的调用。

  1. classA 
  2.  
  3.  
  4.   private$proPrivate="private of A"
  5.  
  6.   protected$proProtected="protected of A"
  7.  
  8.   public$proPublic="public of A"
  9.  
  10.   privatefunctionfoo() 
  11.  
  12.   { 
  13.  
  14.     echo$this->proPrivate."\n"
  15.  
  16.     echo$this->proProtected."\n"
  17.  
  18.     echo$this->proPublic."\n"
  19.  
  20.   } 
  21.  
  22.      
  23.  
  24.   publicfunctiontest() 
  25.  
  26.   { 
  27.  
  28.     $this->foo(); 
  29.  
  30.     static::foo(); 
  31.  
  32.   } 
  33.  
  34.  
  35.    
  36.  
  37. classBextendsA 
  38.  
  39.  
  40.  /* foo() will be copied to B, hence its scope will still be A and 
  41.  
  42.   * the call be successful */ 
  43.  
  44.  
  45.    
  46.  
  47. classCextendsA 
  48.  
  49.  
  50.   private$proPrivate="private of C"
  51.  
  52.   protected$proProtected="protected of C"
  53.  
  54.   public$proPublic="public of C"
  55.  
  56.      
  57.  
  58.   privatefunctionfoo() 
  59.  
  60.   { 
  61.  
  62.     /* original method is replaced; the scope of the new one is C */ 
  63.  
  64.     echo"I am C\n"
  65.  
  66.   } 
  67.  
  68.      
  69.  
  70.   publicfunctionmyFoo() 
  71.  
  72.   { 
  73.  
  74.     //parent::foo(); 
  75.  
  76.     $this->foo(); 
  77.  
  78.   } 
  79.  
  80.  
  81.    
  82.  
  83. echo"Class B:\n"
  84.  
  85. $b=newB(); 
  86.  
  87. $b->test(); 
  88.  
  89. echo"\nClass C:\n"
  90.  
  91. $c=newC(); 
  92.  
  93. $c->myFoo(); 
  94.  
  95. $c->test(); //fails 

上例输出结果:

Class B:

privateof A

protectedof A

publicof A

privateof A

protectedof A

publicof A

Class C:

I am C

privateof A

protectedof C

publicof C

•继承:官方文档对继承有这样一段描述“当扩展一个类,子类就会继承父类所有公有的和受保护的方法。除非子类覆盖了父类的方法,被继承的方法都会保留其原有功能”,言下之意似乎私有属性和方法不会被继承;然而上例又告诉我们子类拥有与父类一致的属性和方法,继承就是全盘复制,这才能满足我们对继承编程的需求,如果私有的不能继承,子类就必须自行重新定义,在大多数时候没有必要。另外就是可见性问题,父类的私有属性和方法在子类是不可见的。上例还告诉我们对象实际执行的域要考虑可见性、继承、后期静态绑定机制。

Tags: 对象 知识

分享到: