PHP面向对象：延迟静态绑定（static关键字）

最近看到了PHP面向对象中的延迟静态绑定这块，注意：php5.3之前没有引入延迟静态绑定，所以版本较低的童鞋可能用不了。

这里我们用一个简单的工厂方法(生成包含类的实例的一种方法）来说明

//定义一个抽象方法作为父类
abstract class ParentClass{
//....
}
//子类User
class User extends ParentClass{
//定义一个静态方法来生成返回一个类实例
public static function create(){
return new User();
}
}
//子类Animal
class Animal extends ParentClass{
public static function create(){
return new Animal();
}
}

//使用:
print_r(User::create());
print_r(Animal::create());

//返回:
User Object ( )
Animal Object ( )

从返回结果上看，我们取得了两个子类的实例，说明这个工厂方法正常的工作了。但是，假如我假如Document、Plant等子类呢？我们要重写很多create()方法！这个很烦人！既然create()方法都是类似的，我把这个方法放到父类中怎么样？

abstract class ParentClass{
//定义一个静态方法来生成返回一个类实例
public static function create(){
return new self();
}
}
//子类User
class User extends ParentClass{
//...
}
//子类Animal
class Animal extends ParentClass{
//...
}

//使用：
print_r(User::create());
print_r(Animal::create());

//返回:
Fatal error: Cannot instantiate abstract class ParentClass in....

返回的结果：不能实例化ParentClass这个抽象类！

好，我们把抽象abstract去掉：

class ParentClass{
//定义一个静态方法来生成返回一个类实例
public static function create(){
return new self();
}
}
//返回结果：
ParentClass Object ( )
ParentClass Object ( )

去掉abstract前后都足以证明：self()调用的是基类本身。

也就不能把create()放在父类中？错！

PHP5.3之后引入了延迟静态绑定的概念。该特性最明显的标志就是新关键字static（静态）。static类似于self，但它表示的是被调用的类而不是包含类。现在我们用 static() 替换 self() :

abstract class ParentClass{
//定义一个静态方法来生成返回一个类实例
public static function create(){
return new static();
}
}
//子类User
class User extends ParentClass{
//...
}
//子类Animal
class Animal extends ParentClass{
//...
}

//使用：
print_r(User::create());
print_r(Animal::create());

//返回:
User Object ( )
Animal Object ( )

我们暂时可以这样理解：self()只能父类中起作用，只会紧跟在所在类中，固定的，而static()灵活性更强，谁调用我，我就是在谁那里起作用，被子类继承下来，那就是指的是子类。在本类中，self()指的是ParentClass，而对于static()，子类User调用我，我就是指User类。当然，通过ParentClass类的对象调用create（）,static()指的就是ParentClass类了

关于static关键字，它不仅可以用于实例化所在类，和self和parent一样，static还可以调用类里面的方法：

//这里先用self
class ParentClass{
public $order;
//构造函数
function __construct(){
$this->order = self::getOrder();//调用本类的getorder()方法
}
//延迟静态绑定
public static function create(){
return new static();
}
public function getOrder(){
return "ParentClass";
}
}
class User extends ParentClass{
//重写getOrder()方法
public function getOrder(){
return "User";
}
}
class Animal extends ParentClass{
//重写getOrder()方法
public function getOrder(){
return "Animal";
}
}
//使用：
print_r(User::create());
print_r(Animal::create());
//返回结果：
User Object ( [order] => ParentClass )
Animal Object ( [order] => ParentClass )

结果也说明了，self关键字只能父类中起作用，只会紧跟在所在类中，

我们把self换成static:

class ParentClass{
public $order;
//构造函数
function __construct(){
$this->order = static::getOrder();//调用本类的getorder()方法
}
public static function create(){
return new static();
}
public function getOrder(){
return "ParentClass";
}
}

//使用：
print_r(User::create());
print_r(Animal::create());
//返回结果：
User Object ( [order] => User )
Animal Object ( [order] => Animal )

看结果，static成功的调用了子类中的getOrder()方法！

现在我比较喜欢拿C#和PHP作对比。。。。

在这里，我感觉这跟C#中的运行时多态比较相似（多态后面给大家介绍，这里先用了）

//动物类：父类
public class Animal
{
public int age;//年龄
public double weight;//体重
//吃方法：虚方法
public virtual string Eat()
{
return "Animal Eat";
}
public virtual string Sleep()
{
return "Animal Sleep";
}
}
//狗类：子类
public class Dog : Animal
{
//覆写虚方法
public override string Eat()
{
return "Dog Eat";
}
public override string Sleep()
{
return "Dog Sleep";
}
}
public class Bird : Animal
{
public override string Eat()
{
return "Bird Eat";
}
public override string Sleep()
{
return "Bird Sleep";
}
}
//使用:
Animal al1 = new Dog();
Animal al2 = new Bird();
Console.WriteLine(al1.Sleep());
Console.WriteLine(al2.Sleep());
Console.ReadLine();

//输出结果：
Dog Sleep
Bird Sleep

假如我把Dog类中的覆写Sleep()方法去掉

public class Dog : Animal
{
//覆写虚方法
public override string Eat()
{
return "Dog Eat";
}
}

//返回结果：
Animal Sleep
Bird Sleep

运行时多态（virtual 和 override 关键字）：当用子类实例化父类的时候，通过判断对象的类型来决定执行哪个类中的哪个方法，在这里:Animal al1 = new Dog();

al1的类型是Animal，然后去Animal类里面找Sleep()方法，但是，当发现Sleep()方法是个虚方法，到Dog()里面看看该方法有没有被覆写，假如被覆写了，调用覆写后的方法，不然调用虚方法。

这就好比PHP中的延迟静态绑定中的 self 和 static 关键字,假如子类中有覆写（override）父类的虚方法，就相当于使用 static，没有覆写就相当于使用 self。