类的静态成员与一般的类成员不同: 静态成员与对象的实例无关,只与类本身有关. 他们用来实现类要封装的功能和数据,但不包括特定对象的功能和数据. 静态成员包括静态方法和静态属性.
静态属性包含在类中要封装的数据,可以由所有类的实例共享. 实际上,除了属于一个固定的类并限制访问方式外,类的静态属性非常类似于函数的全局变量
我们在下例中使用了一个静态属性Counter::$count. 它属于Counter类,而不属于任何Counter的实例.你不能用this来引用它,但可以用self或其它有效的命名表达. 在例子中,getCount方法返回self::$count,而不是Counter::$count.
静态方法则实现类需要封装的功能,与特定的对象无关. 静态方法非常类似于全局函数. 静态方法可以完全访问类的属性,也可以由对象的实例来访问,不论访问的限定语是否是什么.
在6.3例中,getCount是一个普通的方法,用->来调用. PHP建立一个this变量,尽管方法没有使用到.但是,getCount不属于任何对象.在有些情况下,我们甚至希望在不存在有效的对象时调用它,那么 就应该使用静态方法. PHP将不在静态方法内部建立this变量,即使你从一个对象中调用它们.
例子6.7由6.3改变getCount为静态方法而来. Static关键字不能阻止一个实例用->运算符来调用getCount,但PHP将不在方法内部建立this变量.如果你使用this->来调用,将会出错.
//6.3例指第四节--构造函数和析构函数中的例子(参看前文),通过两个例子的比较,你可以很好掌握
//static方法与普通方法之间的区别.
你可以写一个方法通过判断this是否建立来显示是否它被静态地或者非静态地调用. 当然,如果你用了static 关键字,不管它怎样被调用,这个方法总是静态的.
你的类也可以定义常量属性,不需要使用public static,只需要用const关键字即可. 常量属性总是静态的.它们是类的属性,而不是实例化该类的对象的属性.
Listing 6.7 Static members
<?php
class Counter
{
private static $count = 0;
const VERSION = 2.0;
function __construct()
{
self::$count++;
}
function __destruct()
{
self::$count--;
}
static function getCount()
{
return self::$count;
}
};
//创建一个实例,则__construct()将执行
$c = new Counter();
//输出 1
print(Counter::getCount() . "<br>n");
//输出类的版本属性
print("Version used: " . Counter::VERSION . "<br>n");
?>
PHP5的访问方式允许限制对类成员的访问. 这是在PHP5中新增的功能,但在许多面向对象语言中都早已存在. 有了访问方式,才能开发一个可靠的面向对象应用程序,并且构建可重用的面向对象类库.
像C++和Java一样,PHP有三种访问方式:public,private和protected. 对于一个类成员的访问方式,可以是其中之一. 如果你没有指明访问方式,默认地访问方式为public. 你也可以为静态成员指明一种访问方式,将访问方式放在static关键字之前(如public static).
Public成员可以被毫无限制地访问.类外部的任何代码都可以读写public属性. 你可以从脚本的任何地方调用一个public方法. 在PHP的前几个版本中,所有方法和属性都是public, 这让人觉得对象就像是结构精巧的数组.
Private(私有)成员只在类的内部可见. 你不能在一个private属性所在的类方法之外改变或读取它的值. 同样地,只有在同一个类中的方法可以调用一个private方法. 继承的子类也不能访问父类中的private 成员.
要注意,类中的任何成员和类的实例都可以访问private成员. 看例子6.8,equals方法将两个widget进行比较.==运算符比较同一个类的两个对象,但这个例子中每个对象实例都有唯一的ID.equals 方法只比较name和price. 注意equals方法如何访问另一个Widget实例的private属性. Java和C都允许这样的操作.
Listing 6.8 Private members
<?php
class Widget
{
private $name;
private $price;
private $id;
public function __construct($name, $price)
{
$this->name = $name;
$this->price = floatval($price);
$this->id = uniqid();
}
//checks if two widgets are the same 检查两个widget是否相同
public function equals($widget)
{
return(($this->name == $widget->name)AND
($this->price == $widget->price));
}
}
$w1 = new Widget('Cog', 5.00);
$w2 = new Widget('Cog', 5.00);
$w3 = new Widget('Gear', 7.00);
//TRUE
if($w1->equals($w2))
{
print("w1 and w2 are the same<br>n");
}
//FALSE
if($w1->equals($w3))
{
print("w1 and w3 are the same<br>n");
}
//FALSE, == includes id in comparison
if($w1 == $w2) file://不等,因为ID不同
{
print("w1 and w2 are the same<br>n");
}
?>
一个子类可能改变通过覆写父类方法来改变方法的访问方式,尽管如此,仍然有一些限制. 如果你覆写了一个public类成员,他子类中必须保持public. 如果你覆写了一个protected成员,它可保持protected或变成public.Private成员仍然只在当前类中可见. 声明一个与父类的private成员同名的成员将简单地在当前类中建立一个与原来不同的成员. 因此,在技术上你不能覆写一个private成员.
Final关键字是限制访问成员方法的另一个方法. 子类不能覆写父类中标识为final的方法. Final关键字不能用于属性.
//haohappy注:PHP5的面向对象模型仍然不够完善,如final不像Java中那样对Data,Method甚至Class都可以用。
9.绑定除了限制访问,访问方式也决定哪个方法将被子类调用或哪个属性将被子类访问. 函数调用与函数本身的关联,以及成员访问与变量内存地址间的关系,称为绑定.
在计算机语言中有两种主要的绑定方式—静态绑定和动态绑定. 静态绑定发生于数据结构和数据结构间,程序执行之前. 静态绑定发生于编译期, 因此不能利用任何运行期的信息. 它针对函数调用与函数的主体,或变量与内存中的区块. 因为PHP是一种动态语言,它不使用静态绑定. 但是可以模拟静态绑定.
动态绑定则针对运行期产生的访问请求,只用到运行期的可用信息. 在面向对象的代码中,动态绑定意味着决定哪个方法被调用或哪个属性被访问,将基于这个类本身而不基于访问范围.
Public和protected成员的动作类似于PHP的前几个版本中函数的动作,使用动态绑定. 这意味着如果一个方法访问一个在子类中被覆写的类成员,并是一个子类的实例,子类的成员将被访问(而不是访问父类中的成员).
看例子6.10. 这段代码输出” Hey! I am Son.” 因为当PHP调用getSalutation, 是一个Son的实例,是将Father中的salutation覆写而来. 如果salutation是public的,PHP将产生相同的结果. 覆写方法的操作很类似.在Son中,对于identify的调用绑定到那个方法.
即使在子类中访问方式被从protected削弱成public, 动态绑定仍然会发生. 按照访问方式使用的原则,增强对于类成员的访问限制是不可能的. 所以把访问方式从public改变成protected不可能进行.
Listing 6.10 Dynamic binding 动态绑定
<?php
class Father
{
protected $salutation = "Hello there!"; file://问候
public function getSalutation()
{
print("$this->salutationn");
$this->identify();
}
protected function identify()
{
print("I am Father.<br>n");
}
};
class Son extends Father
{
protected $salutation = "Hey!"; file://父类中的protected $salutation 被覆写
protected function identify() file://父类中的protected identify() 被覆写
{
print("I am Son.<br>n");
}
};
$obj = new Son();
$obj->getSalutation(); file://输出Hey! I am Son.
?>
//注: 在子类中没有覆写getSalutation(),但实际上仍然存在一个getSalutation().这个类中的$salutation和identify()
//与Son子类的实例中的getSalutation()方法动态绑定,所以调用Son的实例的getSalutation()方法,
//将调用Son类中的成员salutation及identify(),而不是父类中的成员salutation及identify().
Private成员只存在于它们所在的类内部. 不像public和protected成员那样,PHP模拟静态绑定. 看例子6.11. 它输出”Hello there! I am Father.”,尽管子类覆写了salutation的值. 脚本将this->salutation和当前类Father绑定. 类似的原则应用于private方法identify().
Listing 6.11 Binding and private members
<?php
class Father
{
private $salutation = "Hello there!";
public function getSalutation()
{
print("$this->salutationn");
$this->identify();
}
private function identify()
{
print("I am Father.<br>n");
}
}
class Son extends Father
{
private $salutation = "Hey!";
private function identify()
{
print("I am Son.<br>n");
}
}
$obj = new Son();
$obj->getSalutation(); file://输出Hello there! I am Father.
?>
//haohappy注:用一句话说清楚,就是对象类型与方法,属性绑定. 调用一个父类与子类中都存在的方法或访问一个属性时,会先判断实例属于哪种对象类型,再调用相应的类中的方法和属性.
Listing 6.12 动态绑定的好处
<?php
class User file://用户
{
protected function isAuthorized() file://是否是验证用户
{
return(FALSE);
}
public function getName() file://获得名字
{
return($this->name);
}
public function deleteUser($username) file://删除用户
{
if(!$this->isAuthorized())
{
print("You are not authorized.<br>n");
return(FALSE);
}
//delete the user
print("User deleted.<br>n");
}
}
class AuthorizedUser extends User file://认证用户
{
protected function isAuthorized() file://覆写isAuthorized()
{
return(TRUE);
}
}
$user = new User;
$admin = new AuthorizedUser;
//not authorized
$user->deleteUser("Zeev");
//authorized
$admin->deleteUser("Zeev");
?>
private成员只有当你不想让子类继承改变或特殊化父类的行为时才用到. 这种情况比你想像的要少. 通常来说,一个好的对象分层结构应当允许绝大多数功能被子类特殊化,改进,或改变—这是面向对象编程的基础之一. 一定的情况下需要private方法或变量,例如当你确信你不想允许子类改变父类中的某个特定的部份.
549
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
