@Chiang 2019-12-24T10:30:19.000000Z 字数 9691 阅读 561

static关键字 self 后期静态绑定抽象类接口 final关键字

PHP

static

1.声明方法： 如果没有修饰符修饰默认为public
class Person
{
   //声明静态属性
    public static $name = 'foo';
    //声明静态方法
    public static function say() {
        return self::$name;
    }
}
$person = new Person();
2.使用方法：
访问静态属性
类中：Person::$name;   self::$name
类外：1.$me = new Person();   echo $me::$name;
     2.Person::$name;
访问静态方法
类中：Person::say();   self::say();
类外：1.$me = new Person();   $me::say();
     2.$me = new Person();  $me->say();
/*************/
class foo {
    function bar() {
        echo 'I am not static!';
    }
}
foo::bar();//php7说静态调用非静态方法将被弃用
3.实战：
（1）初始化一个值，不能为含有变量和函数方法：
    public static $writeToBodyOfCompany = array('1190','1370','1380','1930');
    以下两种为错误定义：
    public static $number1 = self::$age; #错的
	public static $number2 = mt_rand(18,24); #错的
（2）方法中变量设为static:
    static的定义语句只会被执行一次，但是它的值会被函数记住，直到程序终止 
function increment1(){
    //static这个语句只会在该程序运行的第一次调用生效，但是这个值在函数执行结束后会被该函数记住，
    //也就是说下次执行到这个函数的，$a是已经存在的且值为上次运行后的值
    static $n = 0;
    $n++;
    echo $n;
}
increment1(); #1
increment1(); #2
increment1(); #3
function increment2(){
    $n = 0;
    $n++;
    echo $n;
}
increment2(); #1
increment2(); #1
increment2(); #1
4.好处：
（1）不需要实例化类就可以访问属性和方法
（2）在内存中只有一份，为所有的实例共用，而实例化的方式会创建多个内存
（3）访问速度比实例化访问快
（4）静态方法中不能访问非静态属性和方法（还未创建，速度快的原因）
（5）静态方法的缺点是不自动进行回收，而实例化的则可以做销毁

PHP static

<?php
class Person{
    public static $name = 'Voyager';
	public static function say(){
		echo 'My name is ' . self::$name;
    }
}

一.介绍

不需要实例化类可直接访问。

在内存中只有一份，为所有的实例共用。

访问速度比实例化访问快。

静态方法中不能访问非静态属性和方法（还未创建，速度快的原因）。

静态属性不能通过实例化的对象方式访问，但静态方法可以。

不能直接定义为变量或者方法，详见三。

定义后不被自动回收，详见四。

二.访问方式

访问静态属性
1.Person::$name;
2.$me = new Person();
echo $me::$name;
访问静态方法
1.Person::say();
2.$me = new Person();
$me::say();
3.$me = new Person();
$me->say();

三.初始化为一个不定值

为什么static要一个不定值呢？例如一个方法处理一批订单，需要一个随机数，或者当天开始时间戳。我们需要初始化一次，然后对这批订单处理都使用这一个值，但是下一批又不一样了。

<?php
class Person{
    public static $age = 2018-1994;#正确
    public static $number1 = self::$age; #错的
    public static $number2 = mt_rand(18,24); #错的
    public static $number3;
	#正确
	public static function init(){
		if(!self::$number3){
			self::$number3 = mt_rand(18,24);
		} 
	}
	#正确
	public function __construct(){
		if(!self::$number3){
			self::$number3 = mt_rand(18,24);
		}
	}
}
// init
Person::init();
echo Person::$number3;
// __construct
$a = new Person();
$b = new Person();
echo $a::$number3;
echo '<br />';
echo $b::$number3;

四.方法中的static

<?php
function increment1(){
    static $n = 0;
	$n++;
    echo $n;
}
increment1(); #1
increment1(); #2
increment1(); #3
//输出‘123’
function increment2(){
    $n = 0;
	$n++;
    echo $n;
}
increment2(); #1
increment2(); #1
increment2(); #1
//输出‘111’

self 关键字

self和__CLASS__都是对当前类的静态引用，取决于定义当前方法所在的类。也就是说self写在哪个类里面，它就引用谁。

$this 指向的是实际调用时的对象，也就是说，实际运行过程中，谁调用了类的属性或方法，$this 指向的就是哪个对象。但 $this 不能访问类的静态属性和常量，且 $this 不能存在于静态方法中

self 只是表示当前的类，所以这就是self的限制

php CLASS、get_class()与get_called_class()的区别

__CLASS__ 获取当前的类名，

get_class() 与上面一样，都是获取当前的类名

get_called_class() 获取当前主调类的类名

当涉及到继承时，在方法中使用类名。直接贴图了

pic_process
pic_result

MVC框架中，涉及到单例时很好用，一般在基类中

public static function getInstance() {
        $class_name = get_called_class();
        if (isset(self::$instance[$class_name])) {
            return self::$instance[$class_name];
        }
        self::$instance[$class_name] = new $class_name;
        return self::$instance[$class_name];
    }

其他类只要继承这个类，然后通过getInstance()就实现了单例模式

后期静态绑定

自 PHP 5.3.0 起，PHP 增加了一个叫做后期静态绑定的功能，用于在继承范围内引用静态调用的类。

准确说，后期静态绑定工作原理是存储了在上一个“非转发调用”（non-forwarding call）的类名。当进行静态方法调用时，该类名即为明确指定的那个（通常在 :: 运算符左侧部分）；当进行非静态方法调用时，即为该对象所属的类。所谓的“转发调用”（forwarding call）指的是通过以下几种方式进行的静态调用：self::，parent::，static:: 以及 forward_static_call()。可用 get_called_class() 函数来得到被调用的方法所在的类名，static:: 则指出了其范围。

该功能从语言内部角度考虑被命名为“后期静态绑定”。“后期绑定”的意思是说，static:: 不再被解析为定义当前方法所在的类，而是在实际运行时计算的。也可以称之为“静态绑定”，因为它可以用于（但不限于）静态方法的调用。

self:: 的限制

使用 self:: 或者 __CLASS__ 对当前类的静态引用，取决于定义当前方法所在的类

<?php
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();
// A

后期静态绑定的用法

后期静态绑定本想通过引入一个新的关键字表示运行时最初调用的类来绕过限制。简单地说，这个关键字能够让你在上述例子中调用 test() 时引用的类是 B 而不是 A。最终决定不引入新的关键字，而是使用已经预留的 static 关键字。

<?php
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();
// B

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

<?php
class A {
    private function foo() {
        echo "success!\n";
    }
    public function test() {
        $this->foo();
        static::foo();
    }
}
class B extends A {
   /* foo() will be copied to B, hence its scope will still be A and
    * the call be successful */
}
class C extends A {
    private function foo() {
        /* original method is replaced; the scope of the new one is C */
    }
}
$b = new B();
$b->test();
$c = new C();
$c->test();   //fails
// success!
// success!
// success!
// Fatal error:  Call to private method C::foo() from context 'A' in /tmp/test.php on line 9

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

<?php
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();
// A
// C
// C

抽象类 abstract

抽象类 abstract 声明类中方法，不能声明属性

PHP 5 支持抽象类和抽象方法。定义为抽象的类不能被实例化。任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的。被定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现。

继承一个抽象类的时候，子类必须定义父类中的所有抽象方法；另外，这些方法的访问控制必须和父类中一样（或者更为宽松）。例如某个抽象方法被声明为受保护的，那么子类中实现的方法就应该声明为受保护的或者公有的，而不能定义为私有的。此外方法的调用方式必须匹配，即类型和所需参数数量必须一致。例如，子类定义了一个可选参数，而父类抽象方法的声明里没有，则两者的声明并无冲突。这也适用于 PHP 5.4 起的构造函数。在 PHP 5.4 之前的构造函数声明可以不一样的。

<?php
abstract class AbstractClass
{
 // 强制要求子类定义这些方法
    abstract protected function getValue();
    abstract protected function prefixValue($prefix);
    // 普通方法（非抽象方法）
    public function printOut() {
        print $this->getValue() . "\n";
    }
}
class ConcreteClass1 extends AbstractClass
{
    protected function getValue() {
        return "ConcreteClass1";
    }
    public function prefixValue($prefix) {
        return "{$prefix}ConcreteClass1";
    }
}
class ConcreteClass2 extends AbstractClass
{
    public function getValue() {
        return "ConcreteClass2";
    }
    public function prefixValue($prefix) {
        return "{$prefix}ConcreteClass2";
    }
}
$class1 = new ConcreteClass1;
$class1->printOut();
echo $class1->prefixValue('FOO_') ."\n";
$class2 = new ConcreteClass2;
$class2->printOut();
echo $class2->prefixValue('FOO_') ."\n";
// ConcreteClass1
// FOO_ConcreteClass1
// ConcreteClass2
// FOO_ConcreteClass2

<?php
abstract class AbstractClass
{
    // 我们的抽象方法仅需要定义需要的参数
    abstract protected function prefixName($name);
}
class ConcreteClass extends AbstractClass
{
    // 我们的子类可以定义父类签名中不存在的可选参数
    public function prefixName($name, $separator = ".") {
        if ($name == "Pacman") {
            $prefix = "Mr";
        } elseif ($name == "Pacwoman") {
            $prefix = "Mrs";
        } else {
            $prefix = "";
        }
        return "{$prefix}{$separator} {$name}";
    }
}
$class = new ConcreteClass;
echo $class->prefixName("Pacman"), "\n";
echo $class->prefixName("Pacwoman"), "\n";
// Mr. Pacman
// Mrs. Pacwoman

接口 interface

对象接口

使用接口（interface），可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容。

接口是通过 interface 关键字来定义的，就像定义一个标准的类一样，但其中定义所有的方法都是空的。

接口中定义的所有方法都必须是公有，这是接口的特性。

需要注意的是，在接口中定义一个构造方法是被允许的。在有些场景下这可能会很有用，例如用于工厂模式时。

实现(implements)

要实现一个接口，使用 implements 操作符。类中必须实现接口中定义的所有方法，否则会报一个致命错误。类可以实现多个接口，用逗号来分隔多个接口的名称。

在 PHP 5.3.9 之前，实现多个接口时，接口中的方法不能有重名，因为这可能会有歧义。在最近的 PHP 版本中，只要这些重名的方法签名相同，这种行为就是允许的。

接口也可以继承，通过使用 extends 操作符。

类要实现接口，必须使用和接口中所定义的方法完全一致的方式。否则会导致致命错误。

常量

接口中也可以定义常量。接口常量和类常量的使用完全相同，但是不能被子类或子接口所覆盖。

范例

<?php
// 声明一个'iTemplate'接口
interface iTemplate
{
    public function setVariable($name, $var);
    public function getHtml($template);
}
// 实现接口
// 下面的写法是正确的
class Template implements iTemplate
{
    private $vars = array();
    public function setVariable($name, $var)
    {
        $this->vars[$name] = $var;
    }
    public function getHtml($template)
    {
        foreach($this->vars as $name => $value) {
            $template = str_replace('{' . $name . '}', $value, $template);
        }
        return $template;
    }
}
// 下面的写法是错误的，会报错，因为没有实现 getHtml()：
// Fatal error: Class BadTemplate contains 1 abstract methods
// and must therefore be declared abstract (iTemplate::getHtml)
class BadTemplate implements iTemplate
{
    private $vars = array();
    public function setVariable($name, $var)
    {
        $this->vars[$name] = $var;
    }
}

可扩充的接口

<?php
interface a
{
    public function foo();
}
interface b extends a
{
    public function baz(Baz $baz);
}
// 正确写法
class c implements b
{
    public function foo()
    {
    }
    public function baz(Baz $baz)
    {
    }
}
// 错误写法会导致一个致命错误
class d implements b
{
    public function foo()
    {
    }
    public function baz(Foo $foo)
    {
    }
}

继承多个接口

<?php
interface a
{
    public function foo();
}
interface b
{
    public function bar();
}
interface c extends a, b
{
    public function baz();
}
class d implements c
{
    public function foo()
    {
    }
    public function bar()
    {
    }
    public function baz()
    {
    }
}

使用接口常量

<?php
interface a
{
    const b = 'Interface constant';
}
// 输出接口常量
echo a::b;
// 错误写法，因为常量不能被覆盖。接口常量的概念和类常量是一样的。
class b implements a
{
    const b = 'Class constant';
}

抽象类和接口的区别

相同点：
1.都是用于声明某一种事物，规范名称、参数，形成模块，未有详细的实现细节。
2.都是通过类来实现相关的细节工作
3.语法上，抽象类的抽象方法与接口一样，不能有方法体，即｛｝符号
4.都可以用继承，接口可以继承接口形成新的接口，抽象类可以继承抽象类从而形成新的抽象类
不同点：
抽象类：是基于类来说，其本身就是类，只是一种特殊的类，不能直接实例，可以在类里定义方法，属性。类似于模版，规范后让子类实现详细功能
接口：主要基于方法的规范，有点像抽象类里的抽象方法，只是其相对于抽象方法来说，更加独立。可让某个类通过组合多个方法来形成新的类
1.接口是一种特殊的抽象类，接口中只包含抽象方法，没有成员属性
2.类实现（implements）接口时，必须完全实现接口中的所有方法；类继承（extends）抽象类时，只需对需要用到的抽象方法进行重写
3.抽象类只能单继承，但接口却是多继承，类对接口的实现也是多实现
4.接口本身就是抽象的，但注意不是抽象类，因为接口不是类，只是其方法是抽象的
抽象类和接口的结合：
interface work{ 
  public function say(); 
}
abstract class a implements work{ 
  public function showlove(){ 
    echo 'love you<br />'; 
  } 
}
class b extends a{ 
  public function say(){ 
    echo 'hello, i m in b'; 
  } 
}
接口和继承的结合：
class b extends a implements kk{ 
  public function say(){ 
    echo '我是继承A类，同时实现say接口的<br />'; 
  }
}

final 关键字

PHP 5 新增了一个 final 关键字。如果父类中的方法被声明为 final，则子类无法覆盖该方法。如果一个类被声明为 final，则不能被继承。

<?php
class BaseClass {
   public function test() {
       echo "BaseClass::test() called\n";
   }
   final public function moreTesting() {
       echo "BaseClass::moreTesting() called\n";
   }
}
class ChildClass extends BaseClass {
   public function moreTesting() {
       echo "ChildClass::moreTesting() called\n";
   }
}
// Results in Fatal error: Cannot override final method BaseClass::moreTesting()

<?php
final class BaseClass {
   public function test() {
       echo "BaseClass::test() called\n";
   }
   // 这里无论你是否将方法声明为final，都没有关系
   final public function moreTesting() {
       echo "BaseClass::moreTesting() called\n";
   }
}
class ChildClass extends BaseClass {
}
// 产生 Fatal error: Class ChildClass may not inherit from final class (BaseClass)

属性不能被定义为 final，只有类和方法才能被定义为 final。

参考资料:
sinat_38804294的博客
 PHP7.0.x弃用的功能
 PHP static
php CLASS、get_class()与get_called_class()的区别
 后期静态绑定
 abstract
interface
final

static关键字 self 后期静态绑定 抽象类 接口 final关键字

static

PHP static

一.介绍

二.访问方式

三.初始化为一个不定值

四.方法中的static

self 关键字

php CLASS、get_class()与get_called_class()的区别

后期静态绑定

self:: 的限制

后期静态绑定的用法

抽象类 abstract

接口 interface

对象接口

实现(implements)

常量

范例

抽象类和接口的区别

final 关键字

内容目录

static关键字 self 后期静态绑定抽象类接口 final关键字