基础知识
1. 范围解析操作符 （::）
2. php内核将类的继承实现放在了"编译阶段"
我要评论
<?php
class a{
const h = 'a';
const j = 'a';
static function testself(){
echo self::h; //在编译阶段就确定了 self解析为 a
}
}
class b extends a{
const h = "b";
const j = 'b';
static function testparent(){
echo parent::j; //在编译阶段就确定了 parent解析为a
}
/* 若重写testself则能输出“b”, 且c::testself()也是输出“b”
static function testself(){
echo self::h;
}
*/
}
class c extends b{
const h = "c";
const j = 'c';
}
b::testparent();
b::testself();
echo "\n";
c::testparent();
c::testself();
运行结果：
aa
aa
结论：
self::和parent::出现在某个类x的定义中，则将被解析为相应的类x，除非在子类中覆盖父类的方法。
3.static（静态）关键字
作用：
- 在函数体内的修饰变量的static关键字用于定义静态局部变量。
- 用于修饰类成员函数和成员变量时用于声明静态成员。
- (php5.3之后)在作用域解析符(::)前又表示静态延迟绑定的特殊类。
例子：
定义静态局部变量（出现位置：局部函数中）
特征：静态变量仅在局部函数域中存在，但当程序执行离开此作用域时，其值并不丢失。
<?php
function test()
{
static $count = 0;
$count++;
echo $count;
if ($count < 10) {
test();
}
$count--;
}
定义静态方法，静态属性
a)声明类属性或方法为静态，就可以不实例化类而直接访问。
b)静态属性不能通过一个类已实例化的对象来访问（但静态方法可以）
c)如果没有指定访问控制，属性和方法默认为公有。
d)由于静态方法不需要通过对象即可调用，所以伪变量 $this 在静态方法中不可用。
e)静态属性不可以由对象通过 -> 操作符来访问。
f)用静态方式调用一个非静态方法会导致一个 e_strict 级别的错误。
g)就像其它所有的 php 静态变量一样，静态属性只能被初始化为文字或常量，不能使用表达式。所以可以把静态属性初始化为整数或数组，但不能初始化为另一个变量或函数返回值，也不能指向一个对象。
a.静态方法例子（出现位置： 类的方法定义）
<?php
class foo {
public static function astaticmethod() {
// ...
}
}
foo::astaticmethod();
$classname = 'foo';
$classname::astaticmethod(); // 自php 5.3.0后，可以通过变量引用类
?>
b.静态属性例子（出现位置：类的属性定义）
<?php
class foo
{
public static $my_static = 'foo';
public function staticvalue() {
return self::$my_static; //self 即 foo类
}
}
class bar extends foo
{
public function foostatic() {
return parent::$my_static; //parent 即 foo类
}
}
print foo::$my_static . "\n";
$foo = new foo();
print $foo->staticvalue() . "\n";
print $foo->my_static . "\n"; // undefined "property" my_static
print $foo::$my_static . "\n";
$classname = 'foo';
print $classname::$my_static . "\n"; // as of php 5.3.0
print bar::$my_static . "\n";
$bar = new bar();
print $bar->foostatic() . "\n";
?>
c.用于后期静态绑定（出现位置： 类的方法中，用于修饰变量或方法）
下面详细分析
后期静态绑定（late static binding）
自 php 5.3.0 起，php 增加了一个叫做后期静态绑定的功能，用于在继承范围内引用静态调用的类。
1.转发调用与非转发调用
转发调用 :
指的是通过以下几种方式进行的静态调用：self::，parent::，static:: 以及 forward_static_call()。
非转发调用 ：
明确指定类名的静态调用（例如foo::foo()）
非静态调用（例如$foo->foo()）
2.后期静态绑定工作原理
原理：存储了在上一个“非转发调用”（non-forwarding call）中的类名。意思是当我们调用一个转发调用的静态调用时，实际调用的类是上一个非转发调用的类。
例子分析：
<?php
class a {
public static function foo() {
echo __class__."\n";
static::who();
}
public static function who() {
echo __class__."\n";
}
}
class b extends a {
public static function test() {
echo "a::foo()\n";
a::foo();
echo "parent::foo()\n";
parent::foo();
echo "self::foo()\n";
self::foo();
}
public static function who() {
echo __class__."\n";
}
}
class c extends b {
public static function who() {
echo __class__."\n";
}
}
c::test();
/*
* c::test(); //非转发调用 ，进入test()调用后，“上一次非转发调用”存储的类名为c
*
* //当前的“上一次非转发调用”存储的类名为c
* public static function test() {
* a::foo(); //非转发调用， 进入foo()调用后，“上一次非转发调用”存储的类名为a，然后实际执行代码a::foo(), 转 0-0
* parent::foo(); //转发调用， 进入foo()调用后，“上一次非转发调用”存储的类名为c， 此处的parent解析为a ,转1-0
* self::foo(); //转发调用， 进入foo()调用后，“上一次非转发调用”存储的类名为c， 此处self解析为b, 转2-0
* }
*
*
* 0-0
* //当前的“上一次非转发调用”存储的类名为a
* public static function foo() {
* static::who(); //转发调用， 因为当前的“上一次非转发调用”存储的类名为a， 故实际执行代码a::who(),即static代表a，进入who()调用后，“上一次非转发调用”存储的类名依然为a，因此打印 “a”
* }
*
* 1-0
* //当前的“上一次非转发调用”存储的类名为c
* public static function foo() {
* static::who(); //转发调用， 因为当前的“上一次非转发调用”存储的类名为c， 故实际执行代码c::who(),即static代表c，进入who()调用后，“上一次非转发调用”存储的类名依然为c，因此打印 “c”
* }
*
* 2-0
* //当前的“上一次非转发调用”存储的类名为c
* public static function foo() {
* static::who(); //转发调用， 因为当前的“上一次非转发调用”存储的类名为c， 故实际执行代码c::who(),即static代表c，进入who()调用后，“上一次非转发调用”存储的类名依然为c，因此打印 “c”
* }
*/
故最终结果为：
a::foo()
a
a
parent::foo()
a
c
self::foo()
a
c
3.更多静态后期静态绑定的例子
a)self, parent 和 static的对比
<?php
class mango {
function classname(){
return __class__;
}
function selfname(){
return self::classname();
}
function staticname(){
return static::classname();
}
}
class orange extends mango {
function parentname(){
return parent::classname();
}
function classname(){
return __class__;
}
}
class apple extends orange {
function parentname(){
return parent::classname();
}
function classname(){
return __class__;
}
}
$apple = new apple();
echo $apple->selfname() . "\n";
echo $apple->parentname() . "\n";
echo $apple->staticname();
?>
运行结果：
mango
orange
apple
b)使用forward_static_call()
<?php
class mango
{
const name = 'mango is';
public static function fruit() {
$args = func_get_args();
echo static::name, " " . join(' ', $args) . "\n";
}
}
class orange extends mango
{
const name = 'orange is';
public static function fruit() {
echo self::name, "\n";
forward_static_call(array('mango', 'fruit'), 'my', 'favorite', 'fruit');
forward_static_call('fruit', 'my', 'father\'s', 'favorite', 'fruit');
}
}
orange::fruit('no');
function fruit() {
$args = func_get_args();
echo "apple is " . join(' ', $args). "\n";
}
?>
运行结果：
orange is
orange is my favorite fruit
apple is my father's favorite fruit
c)使用get_called_class()
<?php
class mango {
static public function fruit() {
echo get_called_class() . "\n";
}
}
class orange extends mango {
//
}
mango::fruit();
orange::fruit();
?>
运行结果：
mango
orange
应用
前面已经提到过了，引入后期静态绑定的目的是：用于在继承范围内引用静态调用的类。
所以， 可以用后期静态绑定的办法解决单例继承问题。
先看一下使用self是一个什么样的情况：
<?php
// new self 得到的单例都为a。
class a
{
protected static $_instance = null;
protected function __construct()
{
//disallow new instance
}
protected function __clone(){
//disallow clone
}
static public function getinstance()
{
if (self::$_instance === null) {
self::$_instance = new self();
}
return self::$_instance;
}
}
class b extends a
{
protected static $_instance = null;
}
class c extends a{
protected static $_instance = null;
}
$a = a::getinstance();
$b = b::getinstance();
$c = c::getinstance();
var_dump($a);
var_dump($b);
var_dump($c);
运行结果：
e:\code\php_test\apply\self.php:37:
class a#1 (0) {
}
e:\code\php_test\apply\self.php:38:
class a#1 (0) {
}
e:\code\php_test\apply\self.php:39:
class a#1 (0) {
}
通过上面的例子可以看到，使用self，实例化得到的都是类a的同一个对象
再来看看使用static会得到什么样的结果
<?php
// new static 得到的单例分别为d，e和f。
class d
{
protected static $_instance = null;
protected function __construct(){}
protected function __clone()
{
//disallow clone
}
static public function getinstance()
{
if (static::$_instance === null) {
static::$_instance = new static();
}
return static::$_instance;
}
}
class e extends d
{
protected static $_instance = null;
}
class f extends d{
protected static $_instance = null;
}
$d = d::getinstance();
$e = e::getinstance();
$f = f::getinstance();
var_dump($d);
var_dump($e);
var_dump($f);
运行结果：
e:\code\php_test\apply\static.php:35:
class d#1 (0) {
}
e:\code\php_test\apply\static.php:36:
class e#2 (0) {
}
e:\code\php_test\apply\static.php:37:
class f#3 (0) {
}
可以看到，使用static可以解决self时出现的单例继承问题。
如对本文有疑问， 点击进行留言回复！！
offset、client、scroll (width,height、left,top、X,Y)
网友评论