乐趣区

关于php:PHP中的static

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

退出移动版