PHP中的static-有解無憂

關于靜態變數和方法的問題也是面試中經常會出現的問題，這種問題多看手冊搞明白原委就能解決，只是確實關于靜態變數的問題還是比較繞的，這里我們就結合手冊用實際的代碼來看！


class Test
{
    static $v = 'a';

    static function showV()
    {
        echo self::$v;
    }

    function showVV()
    {
        echo self::$v;
    }

    static function showVVV()
    {
        // $this->showVV(); // 會直接報錯
    }
}

先準備一個類，這里面有靜態變數、靜態方法，其中showV()方法是靜態方法呼叫靜態變數，showVV()方法是普通方法呼叫靜態變數，showVVV()方法是普通方法呼叫靜態方法，

從注釋中可以看出第一個問題，普通方法使用$this呼叫靜態方法會報錯，也就是說，$this這個東東對于一切靜態的東西都是不友好的，不信您打開注釋試試，也可以去呼叫靜態的$v變數，直接就是語法錯誤的提示，

接下來，我們實體化類，并開始一些測驗

$t = new Test();
$t->showV();
//echo $t->v; // 報例外
echo Test::$v;
//Test::showVV(); // 報例外
$t->showVV();

1行：實體化的類直接呼叫showV()，這是沒問題的，靜態方法可以通過普通的方式呼叫，當然我們正規的應該是使用Test::showV()來進行呼叫，注意這里面試的時候會是坑
2行：正常呼叫
2行：直接->v是不行的，方法可以進行普通呼叫，但屬性不行
3行：用靜態呼叫的方式是沒問題的
4行：正常獲取靜態變數
5行：使用::當然不能呼叫非靜態方法啦
6行：正常方法中可以使用靜態變數

那么問題來了，靜態方法中不能使用$this，如何獲得變數內容呢？請參考單例模式，將來我們會在設計模式的系列文章中講到，這里先賣個關子，大家也可以自己研究下，

上面是正常來說一些比較簡單的靜態屬性和方法的演示，接下來好玩的東西就來了，

初始化特性

class Calculate
{
    function cacl()
    {
        static $a = 1;
        echo $a;
        $a++;
    }

    static function cacl2()
    {
        static $a = 1;
        echo $a;
        $a++;
    }

    static $b = 1;

    static function cacl3()
    {
        echo self::$b;
        self::$b++;
    }
}

$calculate = new Calculate();
$calculate->cacl(); // 1
$calculate->cacl(); // 2

Calculate::cacl2(); // 1
Calculate::cacl2(); // 2

Calculate::cacl3(); // 1
Calculate::cacl3(); // 2

看著代碼很多，其實都是在講一件事兒，如果是普通的$a和$b，那么每次都在重新賦值，echo出來的都是0，但是靜態屬性可不一樣，靜態屬性是運行時計算的，只在第一次賦值的時候是真正的賦值操作，而后并不會進行賦值，可以相當于這一行代碼不存在，

靜態變數只在區域的作用域中存在，離開這個作用域也不會丟失，當然也不能再次初始化，學過前端的同學一定會拍案而起，這不是閉包的作用域嘛？？確實很像，而且用處也非常像，比如我們做一個遞回：

function test1()
{
    static $count = 0;

    $count++;
    echo $count;
    if ($count < 10) {
        test();
    }
    $count--;
}

test1();

在不了解static之前，結束遞回我們可能需要給方法傳遞一個數字進來，但現在似乎是不需要了，使用內部的靜態變數就可以解決了，

參考物件問題


class Foo
{
    public $a = 1;
}

function getRefObj($o)
{
    static $obj;
    var_dump($obj);
    if (!isset($obj)) {
        $obj = &$o;
    }
    $obj->a++;
    return $obj;
}

function getNoRefObj($o)
{
    static $obj;
    var_dump($obj);
    if (!isset($obj)) {
        $obj = $o;
    }
    $obj->a++;
    return $obj;
}

$o    = new Foo;
$obj1 = getRefObj($o); // NULL
$obj2 = getRefObj($o); // NULL

$obj3 = getNoRefObj($o); // NULL
$obj4 = getNoRefObj($o); // Foo

又是一大串代碼，啥也不說，先復制下來運行一下看看結果是不是一樣，在使用參考物件時，我們賦值的是記憶體參考地址，但是同樣的原因，靜態屬性是運行時產生的，而參考地址不是靜態地存盤，于是，賦不上值了唄，永遠會是NULL，不信你接著用getRefObj()再生成幾個試試，實際應用中反正要記住，這種情況下千萬不要把參考值賦給靜態變數就行了，而上面原因的理解確實還是比較繞的，能講明白最好，講不明白就記住這個事兒，

后期靜態系結


class A
{
    static function who()
    {
        echo __CLASS__ . "\n";
    }

    static function test()
    {
        self::who();
    }
}

class B extends A
{
    static function who()
    {
        echo __CLASS__ . "\n";
    }
}

B::test(); // A

先看這一段，使用self輸出的結果會是A，但如果使用普通的類實體化，并且使用普通方法的話，輸出的會是B，大家可以嘗試下，原因呢，就是self是取決于當前定義方法所在的類，這就是靜態屬性方法的另一大特點，不實體化，跟隨著類而不是實體，

class A{...}，這個東西叫做類，是對現實的抽象，我們可以理解為一個模板，這里面的東西是假的，沒有生命的，$a = new A了之后，這個$a才是物件，相當于是復制一了個模板做了一個真的東西出來，是有生命的，就好像我們做一個錘子，需要一個模具，這玩意就是類，然后澆鑄金屬后成型拿出來，這玩意就是物件，一個物件有真正的記憶體地址空間的，

非靜態的屬性和方法是在物件中的，是我們澆進去的金屬，也就是new了之后才有的東西，而靜態屬性和方法是依附于class A的，是運行時進行編譯讀取的，

現在我們回過頭來看最早的例子，普通方法中呼叫靜態方法或變數，實際上就是在這個實體化物件中呼叫了Test::showV()，只是我們使用了self關鍵字而已，依然是走的靜態程序而不是這個物件中真的包含了showV()這個方法，因此，$this當然取不到啦！

那么，如何讓父類A中test()方法去呼叫到子類的who()方法呢？


class AA
{
    static function who()
    {
        echo __CLASS__ . "\n";
    }

    static function test()
    {
        static::who();
    }
}

class BB extends AA
{
    static function who()
    {
        echo __CLASS__ . "\n";
    }
}

BB::test(); // BB

沒錯，使用static::關鍵字這種形式呼叫，static表示運行最初時的類，不是方法定義時的類，這樣就完成了后期靜態系結，另外，parent::和self::是會轉發這個鏈條的，


class AAA
{
    public static function foo()
    {
        static::who();
    }

    public static function who()
    {
        echo __CLASS__ . "\n";
    }
}

class BBB extends AAA
{
    public static function test()
    {
        AAA::foo();
        parent::foo();
        self::foo();
    }

    public static function who()
    {
        echo __CLASS__ . "\n";
    }
}

class CCC extends BBB
{
    public static function who()
    {
        echo __CLASS__ . "\n";
    }
}

CCC::test(); // AAA、CCC、CCC

CCC繼承了BBB，BBB繼承了AAA
在AAA中的foo()方法使用了static::who()來呼叫who()方法
BBB中的test()執行了三種呼叫
結果是parent::foo()和self::foo()都將CCC傳遞了過去，最后使用的是CCC的who()方法

這個例子看著很繞，但其實結論就一個，如果父類使用了static關鍵字來呼叫父子類都有的內容，那么就是以哪個子類在外面進行呼叫了為準，就像普通類的方法呼叫一樣，反過來，self就是以這個self關鍵字所在的類為準，

說了這么多，也算是把static靜態的特性講解的差不多了，在實際應用中還是要綜合考慮，不能因為靜態屬性方便就全都使用靜態屬性和方法或者完全不使用，還是要結合各路業務需求進行取舍，

具體代碼：
https://github.com/zhangyue0503/php/blob/master/newblog/php-static.php

本文由博客群發一文多發等運營工具平臺 OpenWrite 發布

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/227619.html

標籤：PHP

上一篇：我要偷偷的學Python，然后驚呆所有人（第十五天）

下一篇：java實作向郵件發送訊息