目的传递:一种说法是“PHP对象是经过引用传递的”,更标准的说教是别名(标记符)传递,即它们都保留着同贰个标志符(ID)的正片,那几个标记符指向同贰个目的的确实内容。

对象传递:一种说法是“PHP对象是通过引用传递的”,更纯粹的说教是别称(标记符)传递,即它们都保留着同一个标志符(ID)的正片,这几个标记符指向同三个对象的真正内容。

 <?php
 class A {
   public $foo = 1;
 } 

 $a = new A;
 $b = $a;   // $a ,$b都是同一个标识符的拷贝
       // ($a) = ($b) = <id>
 $b->foo = 2;
 echo $a->foo."\n";//2

 $c = new A;
 $d = &$c;  // $c ,$d是引用
       // ($c,$d) = <id>

 $d->foo = 2;
 echo $c->foo."\n";//2

 $e = new A;

 function foo($obj) {
   // ($obj) = ($e) = <id>
   $obj->foo = 2;
 }

 foo($e);
 echo $e->foo."\n";//2

<?php

•对象复制:对象复制能够透过 clone 关键字来成功,借使原对象定义了
__clone() 方法,则新对象中的 __clone()
方法将在复制完后被调用,__clone()
方法可用于修改复制对象属性的值。当对象被复制后,会对目的的兼具属性施行一个浅复制(shallow
copy),但具有的援用属性还是会是二个对准原本的变量的援引。

classA {

 <?php
 class SubObject
 {
   static $instances = 0;
   public $instance;

   public function __construct()
   {
     $this->instance = ++self::$instances;
   }

   public function __clone()
   {
     $this->instance = ++self::$instances;
   }
 }

 class MyCloneable
 {
   public $object1;
   public $object2;

   function __clone()
   {
     // 强制复制一份this->object, 否则仍然指向同一个对象
     $this->object1 = clone $this->object1;
   }

   function cloneTest()
   {
     echo 'cloneTest';
   }
 }

 $obj = new MyCloneable();

 $obj->object1 = new SubObject();
 $obj->object2 = new SubObject();

 $obj2 = clone $obj;

 print("Original Object:\n");
 print_r($obj);

 print("Cloned Object:\n");
 print_r($obj2);
 echo $obj2->cloneTest().":\n";
 echo (new Reflectionclass($obj2));

  public$foo= 1;

上例输出结果:

Original Object:
MyCloneable Object
(
  [object1] => SubObject Object
    (
      [instance] => 1
    )

  [object2] => SubObject Object
    (
      [instance] => 2
    )

)
Cloned Object:
MyCloneable Object
(
  [object1] => SubObject Object
    (
      [instance] => 3
    )

  [object2] => SubObject Object
    (
      [instance] => 2
    )

)
cloneTest:
Class [ <user> class MyCloneable ] {
 @@ /public/t.php 18-33

 - Constants [0] {
 }

 - Static properties [0] {
 }

 - Static methods [0] {
 }

 - Properties [2] {
  Property [ <default> public $object1 ]
  Property [ <default> public $object2 ]
 }

 - Methods [2] {
  Method [ <user> public method __clone ] {
   @@ /public/t.php 23 - 27
  }

  Method [ <user> public method cloneTest ] {
   @@ /public/t.php 29 - 32
  }
 }
}

  

•对象遍历:
foreach只好遍历对象的可知属性,不能遍历其方法,实现起来相比轻易;其余,也可透过兑现Iterator接口或IteratorAggregate接口的章程遍历对象属性。

$a=newA;

•类型约束:
PHP作为一种弱类型语言,类型约束能够让编制程序特别正规,也少出些差错;类型约束既可以用在对象定义中,也能用在函数定义中。类型约束可内定对象、接口、array、callable(闭包callback),类型约束用来担保实际数据类型与原型定义一致,不同则抛出一个可捕获的致命错误;不过假诺定义了私下认可值为NULL,那么实参能够是NULL;类型约束不能够用于标量类型如
int 或 string,Traits 也不允许。

$b=$a;  // $a ,$b都是同三个标记符的正片

•对象系列化与还原:函数serialize()可将打成富含字节流的字符串便于存款和储蓄对象,函数unserialize()能够还原字符串为对象。但有三个前提是,无论种类化照旧反体系化,对象的类定义已经形成,即需求辅导入类(文件)。

      // ($a) = ($b) =

•重载:PHP的重载富含属性和措施,更像一个沿用说法,不援助广大的重载语法则范,具有不可预知性,影响范围更广泛,就是使用魔术点子(magic
methods)来调用当前条件下未定义或不可知的类属性或方法。全数重载方法都必须被声称为
public(这一条应该比较好掌握,别人可能因不可知才需求你,那您自身必须可知才行),参数也不能够通过引用传递(重载方法具备不可预言性,猜度是因为安全地点的虚拟啊,幸免变量被随机引用)。在除
isset()
外的别样语言结构中不恐怕采纳重载的性质,那意味当对二个重载的性质使用
empty() 时,重载魔术点子将不会被调用;
为躲避此限制,必须将重载属性赋值到地面变量再利用
empty(),可知重载属性是介于合法属性与地下属性之间的留存。

$b->foo = 2;

[质量重载]:那个方法无法被声称为
static,在静态方法中,那么些魔术点子将不会被调用
public void __set ( string $name , mixed $value )
在给不可访谈属性赋值时,__set() 会被调用

echo$a->foo.”\n”;//2

public mixed __get ( string $name )
读取不可访问属性的值时,__get() 会被调用

 

public bool __isset ( string $name )
当对不可访谈属性调用 isset() 或 empty() 时,__isset() 会被调用

$c=newA;

public void __unset ( string $name )
当对不可访谈属性调用 unset() 时,__unset() 会被调用

$d= &$c; // $c ,$d是引用

Note:
因为 PHP 管理赋值运算的章程,__set() 的重回值将被忽略。类似的,
在上边那样的链式赋值中,__get() 不会被调用:
 $a = $obj->b = 8;

      // ($c,$d) =

[艺术重载]:
public mixed __call ( string $name , array $arguments )
在对象中调用贰个不可访谈方法时,__call() 会被调用

$d->foo = 2;

public static mixed __callStatic ( string $name , array $arguments )
在静态上下文中调用二个不得访谈方法时,__callStatic() 会被调用

echo$c->foo.”\n”;//2

•静态属性和办法:static
关键字用来定义静态属性、静态方法,静态属性不能够透超过实际例化的对象->
来访谈(但静态方法能够)。静态属性只好被初步化为常量表明式,所以能够把静态属性开首化为整数或数组,但无法起始化为另贰个变量或函数再次来到值,也不能够指向贰个目的。能够用一个变量表示类来动态调用静态属性,但该变量的值不能够为机要字
self,parent 或 static。

$e=newA;

 class Foo
 {
   public static $my_static = 'foo';

   public function staticValue() {
     return self::$my_static;
   }
 }

 class Bar extends Foo
 {
   public function fooStatic() {
     return parent::$my_static;
   }
 }


 print Foo::$my_static . "\n";

 $foo = new Foo();
 print $foo->staticValue() . "\n";
 print $foo->my_static . "\n";   // Undefined "Property" my_static 

 print $foo::$my_static . "\n";
 $classname = 'Foo';
 print $classname::$my_static . "\n"; // As of PHP 5.3.0

 print Bar::$my_static . "\n";
 $bar = new Bar();
 print $bar->fooStatic() . "\n";

functionfoo($obj) {

•早先时期静态绑定:static::
定义后期静态绑定职业原理是积攒了上三个“非转载调用”(non-forwarding
call)的类名。当举办静态方法调用时,该类名即为泾渭明显钦定的可怜(日常在 ::
运算符右边部分);当进行非静态方法调用时,即为该指标所属的类。使用
self:: 大概 __CLASS__
对日前类的静态援用,取决于定义当前艺术所在的类;static::
不再被深入分析为定义当前形式所在的类,而是在骨子里运行时总计的,能够用来静态属性和全数办法的调用。

  // ($obj) = ($e) =

 <?php
 class A
 {

   private $proPrivate = "private of A";
   protected $proProtected = "protected of A";
   public $proPublic = "public of A";

   private function foo()
   {
     echo $this->proPrivate."\n";
     echo $this->proProtected."\n";
     echo $this->proPublic."\n";
   }

   public function test()
   {
     $this->foo();
     static::foo();
   }
 }

 class B extends A
 {
  /* foo() will be copied to B, hence its scope will still be A and
   * the call be successful */
 }

 class C extends A
 {
   private $proPrivate = "private of C";
   protected $proProtected = "protected of C";
   public $proPublic = "public of C";

   private function foo()
   {
     /* original method is replaced; the scope of the new one is C */
     echo "I am C\n";
   }

   public function myFoo()
   {
     //parent::foo();
     $this->foo();
   }
 }

 echo "Class B:\n";
 $b = new B();
 $b->test();
 echo "\nClass C:\n";
 $c = new C();
 $c->myFoo();
 $c->test();  //fails

  $obj->foo = 2;

上例输出结果:

}

Class B:
private of A
protected of A
public of A
private of A
protected of A
public of A

Class C:
I am C
private of A
protected of C
public of C 
Fatal error: Uncaught Error: Call to private method C::foo() from context 'A' in /public/t.php:19 Stack trace: #0 /public/t.php(54): A->test() #1 {main} thrown in /public/t.php on line 19

  

•继承:官方文书档案对后续有如此一段描述“当扩大三个类,子类就能接二连三父类全部国有的和受保险的点子。除非子类覆盖了父类的主意,被持续的主意都会保留其原有效劳”,言下之意就好像私有属性和措施不会被一连;但是上例又告诉我们子类具备与父类一致的本性和格局,承接就是一点一滴复制,那才具满意我们对继续编制程序的须要,假设个人的无法继续,子类就必须自行重新定义,在大许多时候无需。别的就是可见性难题,父类的村办属性和措施在子类是不可知的。上例还告诉大家对象实际执行的域要思量可知性、承接、后期静态绑定机制。

foo($e);

你大概感兴趣的稿子:

  • php对象和数组相互转变的方法
  • PHP对象Object的概念 介绍
  • 常用的php对象类型判定
  • php开头化对象和析构函数的简短实例
  • php学习笔记
    类的表明与对象实例化
  • php中什么使对象足以像数组同样进行foreach循环
  • php基础知识:类与对象(3)
    构造函数和析构函数

echo$e->foo.”\n”;//2

•对象复制:对象复制能够经过  clone 关键字来完结,就算原对象定义了
__clone() 方法,则新指标中的 __clone()
 方法将要复制完后被调用,__clone()
方法可用来修改复制对象属性的值。当目的被复制后,会对目的的富有属性推行一个浅复制(shallow
 copy),但具备的援用属性依然会是二个对准原本的变量的援用。

<?php

classSubObject

{

  static$instances= 0;

  public$instance;

  

  publicfunction__construct()

  {

    $this->instance = ++self::$instances;

  }

  

  publicfunction__clone()

  {

    $this->instance = ++self::$instances;

  }

}

  

classMyCloneable

{

  public$object1;

  public$object2;

  

  function__clone()

  {

    // 强制复制一份this->object, 不然照旧指向同四个指标

    $this->object1 =clone$this->object1;

  }

    

  functioncloneTest()

  {

    echo’cloneTest’

  }

}

  

$obj=newMyCloneable();

  

$obj->object1 =newSubObject();

$obj->object2 =newSubObject();

  

$obj2=clone$obj;

  

print(“Original Object:\n”);

print_r($obj);

  

print(“Cloned Object:\n”);

print_r($obj2);

echo$obj2->cloneTest().”:\n”;

echo(newReflectionclass($obj2));

上例输出结果:

Original Object:

MyCloneable Object

(

  [object1] => SubObject Object

    (

      [instance] => 1

    )

  

  [object2] => SubObject Object

    (

      [instance] => 2

    )

  

)

Cloned Object:

MyCloneable Object

(

  [object1] => SubObject Object

    (

      [instance] => 3

    )

  

  [object2] => SubObject Object

    (

      [instance] => 2

    )

  

)

cloneTest:

Class [classMyCloneable ] {

 @@ /public/t.php 18-33

  

 – Constants [0] {

 }

  

 – Static properties [0] {

 }

  

 – Static methods [0] {

 }

  

 – Properties [2] {

  Property [public$object1]

  Property [public$object2]

 }

  

 – Methods [2] {

  Method [publicmethod __clone ] {

网站地图xml地图