PHP對象相關知識點的總結

訪問控制(可見性)：public表明類成員在任何地方可見，protected表明類成員在其自身、子類和父類內可見，private表明類成員只對自己可見。對於private和protected有個特例，同一個類的對象即使不是同一個實例也可以互相訪問對方的私有與受保護成員，這是由於在這些對象的內部具體實現的細節都是已知的。

class Test
{
    private $foo;

    public function __construct($foo)
    {
        $this->foo = $foo;
    }

    private function bar()
    {
        echo 'Accessed the private method.';
    }

    public function baz(Test $other)
    {
        // We can change the private property:
        $other->foo = 'hello';
        var_dump($other->foo);

        // We can also call the private method:
        $other->bar();
    }
}

$test = new Test('test');

$test->baz(new Test('other'));

範圍解析符(::)：通常以self::、 parent::、 static:: 和 <classname>::形式來訪問靜態成員、類常量，另外，static::、self:: 和 parent:: 還可用來調用類中的非靜態方法。

<?php
class A
{
    public static $proPublic = "public of A";
    
    public function myMethod()
    {
        echo static::$proPublic."\n";
    }
    
    public function test()
    {
        echo "Class A:\n";
        echo self::$proPublic."\n";
        echo __CLASS__."\n";
        //echo parent::$proPublic."\n";
        self::myMethod();
        static::myMethod();
    }
}

class B extends A
{
   public static $proPublic = "public of B";
   
   public function test()
    {
        echo "\n\nClass B:\n";
        echo self::$proPublic."\n";
        echo __CLASS__."\n";
        echo parent::$proPublic."\n";
        self::myMethod();
        static::myMethod();
    }
}

class C extends B
{
    public static $proPublic = "public of C";
}

$t1 = new A();
$t1->test();
$t2 = new B();
$t2->test();
$t3 = new C();
$t3->test();

上例輸出結果爲：

Class A:
public of A
A
public of A
public of A


Class B:
public of B
B
public of A
public of B
public of B


Class B:
public of B
B
public of A
public of C
public of C

接口與抽象類：

1. 抽象類定義要使用abstract關鍵字來聲明，凡是用abstract關鍵字定義了抽象方法的類必須聲明爲抽象類。另外，子類實現抽象方法時訪問控制必須和父類中一樣（或者更爲寬鬆），同時調用方式必須匹配，即類型和所需參數數量必須一致；

2. 接口是通過interface關鍵字來定義的，但其中定義所有的方法都是空的，訪問控制必須是public。另外，接口可以如類一樣定義常量，可以使用extends來繼承其他接口；

3. 抽象類可用於對多個同構類的通用部分定義，用extends關鍵字繼承(父子間存在"is a"關係)，屬單繼承。接口可用於多個異構類的通用部分定義，用implements關鍵字繼承(父子間存在"like a"關係)，可多繼承。如果子類不能實現父類或接口的全部抽象方法，則該子類只能被聲明成抽象類。

對象傳遞：一種說法是“PHP對象是通過引用傳遞的”，更準確的說法是別名(標識符)傳遞，即它們都保存着同一個標識符(ID)的拷貝，這個標識符指向同一個對象的真正內容，與引用(&)有質的區別，請比較下例中行11和行18的輸出結果。

 1 <?php
 2 class A {
 3     public $foo = 1;
 4 }  
 5 
 6 $a = new A;
 7 $b = $a;     // $a ,$b都是同一個標識符的拷貝 ($a) = ($b) = <id>
 8 $b->foo = 2;
 9 echo $a->foo."\n";//2
10 $b = null;
11 echo $a->foo."\n";//2
12 
13 $c = new A;
14 $d = &$c;    // $c ,$d是引用 ($c,$d) = <id>
15 $d->foo = 2;
16 echo $c->foo."\n";//2
17 $d = null;
18 echo $c->foo."\n";//Notice: Trying to get property of non-object
19 
20 $c = new A;
21 $d = &$c;    // $c ,$d是引用 ($c,$d) = <id>
22 $d->foo = 2;
23 echo $c->foo."\n";//2
24 unset($d);   //unset()刪除引用，$c = <id>
25 echo $c->foo."\n";//2
26 
27 $e = new A;
28 function foo($obj) {
29     // ($obj) = ($e) = <id>
30     $obj->foo = 2;
31 }
32 foo($e);
33 echo $e->foo."\n";//2

對象複製：對象複製可以通過 clone 關鍵字來完成，如果原對象定義了 __clone() 方法，則新對象中的 __clone() 方法將在複製完後被調用，__clone() 方法可用於修改複製對象屬性的值。當對象被複制後，會對對象的所有屬性執行一個淺複製(shallow copy)，但所有的引用屬性仍然會是一個指向原來的變量的引用。

 1 <?php
 2 class SubObject
 3 {
 4     static $instances = 0;
 5     public $instance;
 6 
 7     public function __construct()
 8     {
 9         $this->instance = ++self::$instances;
10     }
11 
12     public function __clone()
13     {
14         $this->instance = ++self::$instances;
15     }
16 }
17 
18 class MyCloneable
19 {
20     public $object1;
21     public $object2;
22 
23     function __clone()
24     {
25         // 強制複製一份this->object， 否則仍然指向同一個對象
26         $this->object1 = clone $this->object1;
27     }
28     
29     function cloneTest()
30     {
31         echo 'cloneTest';
32     }
33 }
34 
35 $obj = new MyCloneable();
36 
37 $obj->object1 = new SubObject();
38 $obj->object2 = new SubObject();
39 
40 $obj2 = clone $obj;
41 
42 print("Original Object:\n");
43 print_r($obj);
44 
45 print("Cloned Object:\n");
46 print_r($obj2);
47 echo $obj2->cloneTest();

上例輸出結果：

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

對象遍歷： foreach只能遍歷對象的可見屬性，無法遍歷其方法，實現起來比較容易；另外，也可通過實現Iterator接口或IteratorAggregate接口的方法遍歷對象屬性。
類型約束： PHP作爲一種弱類型語言，類型約束可以讓編程更加規範，也少出些差錯；類型約束不只能用在對象定義中，也能用在函數定義中。類型約束可指定對象、接口、array、callable(閉包callback)，類型約束用來保證實際數據類型與原型定義一致，不一致則拋出一個可捕獲的致命錯誤；不過如果定義了默認值爲NULL，那麼實參可以是NULL；類型約束不能用於標量類型如 int 或 string，Traits 也不允許。

對象序列化與還原：函數serialize()可將對象打成包含字節流的字符串，但不含靜態屬性(如果屬性需要序列化後進行存儲，最好將該屬性實例化)和方法；函數unserialize()能夠還原字符串爲對象。無論序列化還是反序列化，對象的類定義已經完成，即需要先導入類(文件)。大致過程是先創建一個同類實例，然後再合併之前保存的對象屬性來實現最後還原對象。

//SerializationTest.php:
class SerializationTest
{
    static $staticProp = 0;
    public $instanceProp;

    public function __construct()
    {
        $this->instanceProp = self::$staticProp + 5;
    }
    
    public function doIncrease()
    {
        self::$staticProp += 10;
    }

    public function doPrint()
    {
        print "instanceProp:".$this->instanceProp."\n";
        print "staticProp:".self::$staticProp."\n";
    }
}

//object.store.php:
include 'SerializationTest.php';

$myTest = new SerializationTest();
$myTest->doIncrease();
$myTest->doPrint()."\n";$myTestSeri = serialize($myTest);
file_put_contents('object.store', $myTestSeri);

//object.restore.php:
include 'SerializationTest.php';

$myTestSeri = file_get_contents('object.store');
$myTestUnseri = unserialize($myTestSeri);
$myTestUnseri->doPrint();

上例執行結果：如果上述三個文件中的代碼放在同一個文件中去執行，由於類的靜態屬性是其所有實例所共享而導致序列化後恢復對象的staticProp值也爲10

/object.store.php:
instanceProp:5
staticProp:10

/object.restore.php:
instanceProp:5
staticProp:0

重載：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 class Foo
 2 {
 3     public static $my_static = 'foo';
 4 
 5     public function staticValue() {
 6         return self::$my_static;
 7     }
 8 }
 9 
10 class Bar extends Foo
11 {
12     public function fooStatic() {
13         return parent::$my_static;
14     }
15 }
16 
17 
18 print Foo::$my_static . "\n";
19 
20 $foo = new Foo();
21 print $foo->staticValue() . "\n";
22 print $foo->my_static . "\n";      // Undefined "Property" my_static 
23 
24 print $foo::$my_static . "\n";
25 $classname = 'Foo';
26 print $classname::$my_static . "\n"; // As of PHP 5.3.0
27 
28 print Bar::$my_static . "\n";
29 $bar = new Bar();
30 print $bar->fooStatic() . "\n";

後期靜態綁定：static:: 定義後期靜態綁定工作原理是存儲了上一個“非轉發調用”（non-forwarding call）的類名。當進行靜態方法調用時，該類名即爲明確指定的那個（通常在 :: 運算符左側部分）；當進行非靜態方法調用時，即爲該對象所屬的類。使用 self:: 或者 __CLASS__ 對當前類的靜態引用，取決於定義當前方法所在的類；static:: 不再被解析爲定義當前方法所在的類，而是在實際運行時計算的，可以用於靜態屬性和所有方法的調用。

 1 <?php
 2 class A
 3 {
 4     
 5     private $proPrivate = "private of A";
 6     protected $proProtected = "protected of A";
 7     public $proPublic = "public of A";
 8     
 9     private function foo()
10     {
11         echo $this->proPrivate."\n";
12         echo $this->proProtected."\n";
13         echo $this->proPublic."\n";
14     }
15     
16     public function test()
17     {
18         $this->foo();
19         static::foo();
20     }
21 }
22 
23 class B extends A
24 {
25    /* foo() will be copied to B, hence its scope will still be A and
26     * the call be successful */
27 }
28 
29 class C extends A
30 {
31     private $proPrivate = "private of C";
32     protected $proProtected = "protected of C";
33     public $proPublic = "public of C";
34     
35     private function foo()
36     {
37         /* original method is replaced; the scope of the new one is C */
38         echo "I am C\n";
39     }
40     
41     public function myFoo()
42     {
43         //parent::foo();
44         $this->foo();
45     }
46 }
47 
48 echo "Class B:\n";
49 $b = new B();
50 $b->test();
51 echo "\nClass C:\n";
52 $c = new C();
53 $c->myFoo();
54 $c->test();   //fails

上例輸出結果：

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

繼承與可見性：當擴展一個類，子類就會繼承父類所有公有的和受保護的方法。除非子類覆蓋了父類的方法，被繼承的方法都會保留其原有功能。對象實際執行的域要考慮可見性、繼承、後期靜態綁定機制。

PHP對象相關知識點的總結

Ubuntu / linux 下創建Wi-Fi熱點以AP模式互聯共享網絡寬帶

MySQL 事務與鎖機制

Laravel框架一：原理機制篇

PHP對象相關知識點的總結

ECMAScript 6新特性簡記

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結