php做用域限定符

时间 2019-11-30

标签 php 限定栏目 PHP 繁體版

原文原文链接

双冒号::被认为是做用域限定操做符，用来指定类中不一样的做用域级别。::左边表示的是做用域，右边表示的是访问的成员。php

系统定义了两个做用域，self和parent。self表示当前类的做用域，在类以外的代码是不能使用这个操做符的。html

Program List：使用self做用域访问父类中的函数

  
<?php
class NowaClass
{
function nowaMethod()
{
print '我在类 NowaClass 中声明了。';
}
}

class ExtendNowaClass extends NowaClass
{
function extendNowaMethod()
{
print 'extendNowaMethod 这个方法在 ExtendNowaClass 这个类中声明了。';
self::nowaMethod();
}
}

ExtendNowaClass::extendNowaMethod();

?>

程序运行结果：程序员

extendNowaMethod 这个方法在 ExtendNowaClass 这个类中声明了。
我在类 NowaClass 中声明了。

parent这个做用域很简单，就是派生类用来调用基类的成员时候使用。app

Program List：使用parent做用域

    
<?php
class NowaClass
{
function nowaMethod()
{
print '我是基类的函数。';
}
}

class ExtendNowaClass extends NowaClass
{
function extendNowaMethod()
{
print '我是派生类的函数。';
parent::nowaMethod();
}
}

$obj = new ExtendNowaClass();
$obj -> extendNowaMethod();

?>

程序运行结果：函数

我是派生类的函数。
我是基类的函数。

Program List：用基类的方法访问派生类的静态成员

如何继承一个存储位置上的静态属性。性能

  
<?php
class Fruit 
{
public function get() 
{
        echo $this->connect();
    }
}
class Banana extends Fruit 
{
    private static $bananaColor;
    public function connect() 
{
        return self::$bananaColor = 'yellow';
    }
}
class Orange extends Fruit {
    private static $orange_color;
    public function connect() 
{
        return self::$orange_color = 'orange';
    }
}
$banana = new Banana();
$orange = new Orange();
$banana->get();
$orange->get();
?>

程序运行结果：学习

yellow
orange。

Program List：静态函数初始化

在一个类中初始化静态变量比较复杂，你能够经过建立一个静态函数建立一个静态的构造器，而后在类声明后立刻调用它来实现初始化。测试

    
<?php
class Fruit 
{
    private static $color = "White";
    private static $weigth;
    public static function init() 
{
        echo self::$weigth = self::$color . " Kilogram!";
    }
}
Fruit::init();
?>

程序运行结果：ui

White Kilogram!

Program List：一个简单的单例模式例子

这个应该能够帮到某些人吧。this

  
<?php
class Fruit
{
private static $instance = null;
    private function __construct()
    {
      $this-> color = 'Green';
    }
    public static function getInstance()
    {
      if(self::$instance == null)
      {
        print "Fruit object created!<br />";
        self::$instance = new self;
      }
      return self::$instance;
    }
    public function showColor()
    {
      print "My color is {$this-> color}!<br>";
    }
    public function setColor($color)
    {
      $this-> color = $color;
    }
}
  $apple = Fruit::getInstance(); // Fruit object created!
  $apple-> showColor(); // My color is Green!
  $apple-> setColor("Red");
  $apple-> showColor(); // My color is Red!
  $banana = Fruit::getInstance();
  $banana-> showColor(); // My color is Red!
  $banana-> setColor("Yellow");
  
  $apple-> showColor(); // My color is Yellow!
?>

程序运行结果：

Fruit object created!
My color is Green!
My color is Red!
My color is Red!
My color is Yellow!

转载请注明：老高的自留地 » PHP做用域限定符::的几个程序例子

在访问PHP类中的成员变量或方法时，若是被引用的变量或者方法被声明成const（定义常量）或者static（声明静态）,那么就必须使用操做符::,反之若是被引用的变量或者方法没有被声明成const或者static,那么就必须使用操做符->。

另外，若是从类的内部访问const或者static变量或者方法,那么就必须使用自引用的self，反之若是从类的内部访问不为const或者static变量或者方法,那么就必须使用自引用的$this。

静态变量
是只存在于函数做用域的变量, 不过, 在函数执行完成后,这种变量的值不会丢失,也就是说, 在下一次调用这个函数时,变量仍然会记得原来的值. 要将某个变量定义为静态的, 只须要在变量前加上 static 关键字便可.

类中静态元素的使用
在类中, static 关键字有两种主要用法, 一是用来定义静态成员,一是用来定义静态方法. 在类的内部, 可使用做用域限定符 (::) 来访问不一样层次做用域的变量.

静态成员
静态成员是一种类变量, 能够把它当作时属于整个类而不是属于类的某个实例. 与通常的实例变量不一样的是, 静态成员只保留一个变量值, 而这个变量值对全部的实例都是有效的, 也就是说, 全部的实例共享这个成员.
$this 只表示类的当前实例, 而 self:: 表示的是类自己,在类以外的代码中不能使用这个操做符,并且它不能识别本身在继承树层次结构中的位置.
也就是说, 在扩展类中使用self 做用域时, self 能够调用基类中声明的方法, 但它调用的老是已经在扩展类中重写的方法. 与$this 不一样的是, 在使用静态变量时,必须在做用域限定符后面加上$符号.
在扩展类中, 在基类的方法被重写的状况下,使用 parent 做用域调用定义在基类中的方法.静态成员也能够只属于父类. 若是在子类和父类中同时声明了某个成员,也可使用parant:: 在子类中访问父类中的变量. 在这种状况下, 父类的静态成员和子类的静态成员保存的是不一样的值.
能够在 :: 操做符的左边写上类的名称来静态地访问某个成员, 这样避免建立类的实例. 不只省略掉实例化类的代码, 并且还会更高效, 由于类的每一个实例都会占用一小部分的系统资源.
在使用 :: 操做符访问成员变量时, 须要再次注意对$符号的使用. 由于PHP当前不支持动态的静态变量的使用, 也就是说不支持可变的静态变量. 在使用$this->$var时, 被访问的成员是包含在$var中的变量的值. 而不用$符号访问某个变量实际上查找的是类的某个常量, 而常量是不能经过$this来访问的.
PHP6 中提出的static:: 做用域使咱们再也不须要使用self:: 和parent::. 当但愿指向最终的实现功能的类时, 就可使用static::, 这个限定符会在代码执行以前当即计算出继承层次机构上最后那个类的成员. 之一过程被称为延迟绑定, 它使咱们能够在子类中重写某个静态变量, 而且也能够从某个在父类中声明的函数中反问这个最终成员.

静态方法
静态方法和非静态方法之间有一个重要的区别: 在调用静态方法时, 再也不须要拥有类的实例.
静态方法和非静态方法使用原则:
一是若是某个方法中不包含$this 变量, 就应该时静态方法; 若是不须要类的实例, 可能还应该使用静态类, 这样能够免去实例化类的工做. 另, 在静态方法中时不能使用$this 变量的, 由于静态方法不属于某个特定的实例.

PHP中使用做用域限定操做符时, 用变量做为类的名称时不容许的.

parent:: 可用于调用父类中定义的成员方法。
parent::的追溯不只于直接父类。

注：
在类里面的时候，$this->func()和self::func()没什么区别。
在外部的时候，->必须是实例化后的对象使用； 而::能够是未实例化的类名直接调用。
举个例子:
class Mytest{
    function ccc($str){
        echo $str;
    }
}
Mytest::ccc("123456");
$object = new Mytest();
$object->ccc("123456"

php是个很诡异的语言。固然，这是对学习过C++或者Java等面向对象语言的人来讲。
php能够定义静态的方法，而后经过className::staticMethod()形式来调用。非静态的方法，固然经过classObject->nonStaticMethod()使用。这个其余语言中也是如此，没什么大惊小怪的。但是，您能用className::nonStaticMethod()调用非静态方法吗？这方面恐怕Java和C++要冷汗直流了。其实，php本身也是满脸黑线。为何这么说呢？
先来看看面向对象的静态和非静态。面向对象的语言中，都会支持静态方法。静态方法，属于类的固定资产的；非静态的方法，属于类的实例的私有财产。在内存中，静态方法，对于整个类也就只存了这么一份；不管你new了多少个实例对象，它们共用的也就这么一份。对于非静态的就不同了，你new几个，内存就给你new几份。另外，静态方法内不能够调用非静态方法，非静态方法内却能够调用静态方法。这个就是静态和非静态的区别。
面向对象用static关键字来定义静态。未被标明是静态的方法，是不能够用类名加两个冒号的形式调用的。php和其它颇有区别的一点就是这个了：php中未被标明是静态的方法，也能够用类名加两个冒号的形式调用。那么为何php有这种语法？又为何感到很无奈呢？
-----如下说明php无奈的故事据相关资料改编，已通过演义处理--------
php之因此发展如此迅速，得益于它的速度。做为脚本语言，php追求高速度和简洁方便，因此选择了解释执行和使用过程方法。后来为了与国际接轨，引入了面向对象的概念。而就是在引入这个面向对象的特征时，发生了一件令php目瞪口呆，最终迫不得已的事情。面向对象有个很重要的概念就是继承。在继承中，子类若是覆盖父类的方法，同时须要调用父类的同名方法，该怎么办呢？php4版本提供了这样一种方法：parentClassName::method()。提出此种方法之时，有识之士已经发现了问题：这个调用方式，不正是静态方法的调用方式吗？php4随即答曰：不碍事。类中使用时，能够判断此方式为子类正在调用父类方法；非类中使用时，就判断为静态调用了。所须要的只是发现此种调用时查询一下方法映射就行了。其实，一想，也确实是那么回事。php4后来想一想，若是每次调用都检验一下这次调用是否合法，那多少也会影响性能，不如这个问题就交给程序员去控制吧：他们会知道只在类中使用此形式的调用的。唉，惋惜天不遂人愿。php4低估了程序员们的创造力！程序员们很快发现了这个方式，而且不余遗力地使用起来。许多集成的API也开始使用这种怪癖的方式。php无奈了，随即在php5中引入了另外一种方式，使用关键字parent来调用父类函数：parent::method()。可是，想要放弃php的非静态方法的静态调用，着实是再也不可能了。
--------------------------------------------------------
不过，话说回来，这种php的怪癖方式，有什么好处吗？性能和内存占用方面如何呢？
因而我开始推理了：定义了一个非静态的方法，静态调用时，php首先转换此方法为静态定义，加载入静态内存区域，而后执行。一般一次业务，只使用一个业务处理类中的一个方法，若是使用非静态定义，静态调用，内存中岂不是只加载了这个业务类中的一个方法，不是就实现了静态方法的按需加载吗？岂不是要省下一部份内存？性能方面，不管是静态调用，仍是对象调用，反正都是执行一个方法，性能还不是同样？而且静态调用非静态定义方法还省了一个new语句。嗯，嗯。这么想的同时，手就开始写上了。
那么实际如何呢？我作了一个小测试。

PHP code
t::start();t::end(); //消除t类首次加载的影响
t::start();
model_profile_base::getBaseInfo($uid);
t::end();

t::start();
$model = new model_profile_base();
$model->getBaseInfo($uid);
t::end();

model_profile_base是处理基本资料的一个业务类，比较复杂，比较接近于项目中的业务处理实际。
下面是用到的计时和统计内存的t类的定义：

PHP code
<?php
function microtime_float()
{
list($usec, $sec) = explode(" ", microtime());
return ((float)$usec + (float)$sec);
}
class t{
static $start_time;
static $end_time;
static $start_memory;
static $end_memory;

public static function start()
{
self::$start_memory = memory_get_usage();
self::$start_time = microtime_float();
echo '<br/>Start @'.self::$start_time.'('.self::$start_memory.')|------->';
}

public static function end()
{
self::$end_time = microtime_float();
self::$end_memory = memory_get_usage();
echo 'End @'.self::$end_time.'('.self::$end_memory.') :';
echo '|======= 共耗时：'.(self::$end_time-self::$start_time).'，共用内存：'.(self::$end_memory-self::$start_memory);
}
}

第二行是静态调用非静态方法，第三行是正常调用非静态方法。而后，我发现个人推理悲剧了。刷了好几回页面，统计结果在数量级上都差很少。静态调用非静态方法不管内存占用仍是性能上都不敢恭维。这样的结果有点使人咂舌。
那么，再试一下循环执行屡次的结果：

PHP code
t::start();t::end(); //消除t类首次加载的影响
t::start();
for($i=0; $i<1000;++$i) model_profile_base::getBaseInfo($uid);
t::end();

t::start();
$model = new model_profile_base();
for($i=0; $i<1000;++$i) $model->getBaseInfo($uid);
t::end();

因而更让人无语的结果出来了：

PHP code
Start @1287562243.5799(1009372)|------->End @1287562243.5799(1009372) :|======= 共耗时：3.0040740966797E-5，共用内存：0
Start @1287562243.58(1009372)|------->End @1287562244.1532(1587544) :|======= 共耗时：0.57321000099182，共用内存：578172
Start @1287562244.1532(1587544)|------->End @1287562244.6921(1587744) :|======= 共耗时：0.53887605667114，共用内存：200

除了两种方式时间上开始接近外（而且仍是正常调用比较利索），内存上仍然有天壤之别。失望之余，查了下网上，发现也有人作了相似的测试。我就直接把结果拷上来吧：
(可能光看结果，会感受有点难于理解，能够在这里找到详细说明：http://vega.rd.no/articles/php-static-method-performance)

测试结果 (ORDER BY time DESC):

PHP code
============Which method========================Time======
Inline calculation 0.0805 s
Normal function call 0.3438 s
Normal method called through object 0.4118 s
Static method called statically 0.4280 s
Unspecified method called through object() 0.4294 s
Unspecified method called statically() 0.6960 s

如此看来，静态调用非静态方法在性能和内存上都不占优点；另外，此种调用方法容易产生维护混乱。那么，来个短而有力的总结：静态调用非静态方法不可取。
http://www.dabaoku.com/jiaocheng/biancheng/php/201102248955.shtml

有一个原则若是某个方法中不包含$this变量那么这个方法就应该是静态方法。若是不须要类的实例，可能还须要使用静态类。在静态方法中不能使用$this变量。