面向对象之面试代码题|编程学习之路

在非静态环境下，$this即为该类实例后所属的对象，但是 $this-> 会在同一作用范围内尝试调用私有方法，而 static:: 则可能给出不同结果
重写成员的访问权限要大于或等于父类的成员。私有成员的重写问题：私有属性和方法不能重写(覆盖)，但其实子类可以定义跟父类私有的同名属性或方法，只是当做一个自身的新属性或方法来看待而已，不过方法的参数必须一致。
self:始终指向self代码所在的类的本身，无论这个类被继承了多少次，self都指向初使用self的类
后期(延迟)静态绑定是在PHP5.3中引入了的概念。关键字static；static类似self，但它指的是被调用的类而不是包含类
被定义为公有的类成员可以在任何地方被访问。被定义为受保护的类成员则可以被其自身以及其子类和父类访问。被定义为私有的类成员则只能被其定义所在的类访问

例1：

静态属性在类内部只能通过self来访问

class A 
{
    public static $instance;

    public function __construct($info){
        self::$instance = $info;//
    }

    public function tank(){
        return self::$instance;//访问静态属性
    }
}
$str = new A('instance');
echo $str->tank();

class A 
{  
    static $instance;  

    public function __construct(){  
        self::$instance = 'dell';  
    }  

    static public function pentium(){  
        return self::$instance;//静态方法也可以继续访问静态变量，访问时需要加$  
    }  

    public function tank(){  
        return self::pentium();//访问静态方法pentium()  
    }  
}  

$str = new A();  
echo $str->tank();

例2

在非静态环境下，$this即为该类实例后所属的对象，但是 $this-> 会在同一作用范围内尝试调用私有方法，而 static:: 则可能给出不同结果

class A
{
    private  $name = 'jack';
    public function getName(){
        return $this->name;
    }
}
class B extends A
{
    public $name = '老聂';
}
$b = new B();
echo $b->getName();

例3

后期(延迟)静态绑定是在PHP5.3中引入了的概念。关键字static；static类似self，但它指的是被调用的类而不是包含类

class A
{
    public static function who() 
    {
        echo  __CLASS__ ;
    }

    public static function test() {
        self:: who ();  // 后期静态绑定从这里开始
     }
}

class B extends A
{

}

A :: test ();

class A
{
    public static function who() 
    {
        echo  __CLASS__ ;
    }

    public static function test() {
        self:: who ();  // 后期静态绑定从这里开始
     }
}

class B extends A
{
    public static function who()
    {
        echo  __CLASS__ ;
    }
}

B :: test ();

class A
{
    public static function who() 
    {
        echo  __CLASS__ ;
    }

    public static function test() {
        static:: who ();  // 后期静态绑定从这里开始
     }
}

class B extends A
{
    public static function who()
    {
        echo  __CLASS__ ;
    }
}

B :: test ();

class A
{
    public static function who() 
    {
        echo  get_called_class();
    }

    public static function test() {
        static:: who ();  // 后期静态绑定从这里开始
     }
}

class B extends A
{
    public static function who()
    {
        echo  __CLASS__ ;
    }
}

B :: test ();

CLASS 魔术常量所在当前类的类名

self 所在当前类

static 表示的调用它的类

get_called_class 输出也是调用它的类名

例4

class A
{
    private function foo() 
    {
        echo  "success!\n" ;
    }

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

class B extends A
{

}

class C extends A  
{
    private function foo()
    {

    }
} 

$b  = new  B ();
$b -> test ();
echo '<hr/>';
$c  = new  C ();
$c -> test ();

例6

class A
{  
    public $public;  

    private $private;  

    protected $protected;  

    public function __construct(){  
        $this->public = 'public';  
        $this->private = 'private';  
        $this->protected = 'protected';  
    }  

    public function tank(){  
        return $this->public;  
    }  

    public function dell(){  
        return $this->private;  
    }  

    public function datesrt(){  
        return $this->protected;  
    }  
}  

$str = new A();  
echo $str->tank();  
echo "</br>";  
echo $str->dell();  
echo "</br>";  
echo $str->datesrt();

例7

class test
{
    private $name='jack';
}

class demo extends test
{
    public function getName()
    {
        return $this->name;
    }
}

$d = new demo();

echo $d->getName();

例8

class Teacher
{
    public static $name = 'jack';

    public static function getName()
    {
        return static::$name;
    }
}

class Student extends Teacher
{
    public static $name = 'Student';
}

class zhangsan extends Student
{
    public static $name = 'zhangsan';

}

echo Student::getName();

例9

后期静态绑定的解析会一直到取得一个完全解析了的静态调用为止。另一方面，如果静态调用使用 parent:: 或者 self:: 将转发调用信息

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

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

class B extends A
{
    public static function test()
    {
         A::foo(); 
         parent::foo (); 
         self::foo ();
    }

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

C::test();

例10

abstract class GoodMan
{
    private $group;
    public function __construct(){
        $this->group = static::getGroup();
    }
    public static function create(){
        return new static();
    }
    static function getGroup(){
        return "demo";
    }
}

class Yushi extends GoodMan{}

class Jack extends GoodMan{
    static function getGroup(){
        return "admin";
    }
}
var_dump(Yushi::create());
echo '<br/>';
var_dump(Jack::create());