本文介绍了PHP中的static关键字，self关键字，以及后期静态绑定的概念。后期静态绑定允许静态方法调用在运行时根据实际调用的对象确定，而self则固定在定义时的类。此外，还探讨了抽象类、接口和final关键字的使用，强调static不能调用非静态属性，且final用于限制类或方法的继承。
static 声明类属性或方法为静态，就可以不实例化类而直接访问
1.声明方法： 如果没有修饰符修饰默认为public
class Person
{
//声明静态属性
public static $name = 'foo';
//声明静态方法
public static function say() {
return self::$name;
}
}
$foo = new Foo();
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();//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）静态方法的缺点是不自动进行回收，而实例化的则可以做销毁
2.self关键字
self和__CLASS__都是对当前类的静态引用，取决于定义当前方法所在的类。也就是说self写在哪个类里面，它就引用谁。
$this 指向的是实际调用时的对象，也就是说，实际运行过程中，谁调用了类的属性或方法，$this 指向的就是哪个对象。但 $this 不能访问类的静态属性和常量，且 $this 不能存在于静态方法中
self只是表示当前的类，所以这就是self的限制
3.后期静态绑定：自 PHP 5.3.0 起，PHP 增加了一个叫做后期静态绑定的功能，用于在继承范围内引用静态调用的类
准确说，后期静态绑定工作原理是存储了在上一个“非转发调用”（non-forwarding call）的类名。当进行静态方法调用时，该类名即为明确指定的那个（通常在 :: 运算符左侧部分）；当进行非静态方法调用时，即为该对象所属的类。所谓的“转发调用”（forwarding call）指的是通过以下几种方式进行的静态调用：self::，parent::，static:: 以及 forward_static_call()。可用 get_called_class() 函数来得到被调用的方法所在的类名，static:: 则指出了其范围。
1.self的限制：写在哪个类里面就是谁
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
2.后期绑定的意思是想通过一个关键字为不是当前的方法所在的类，而是在实际运行计算的。也是静态绑定，因为她可以用于（但不限于）静态方法的调用。就是上面的例子打印出来要是B而不是A。最终决定不引用新关键字，而是使用已经有的static关键字
(1)静态环境下使用static关键字
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
(2)非静态环境下使用关键字static
在非静态环境下，所调用的类即为该对象实例所属的类。由于 $this-> 会在同一作用范围内尝试调用私有方法，而 static:: 则可能给出不同结果。另一个区别是 static:: 只能用于静态属性
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();
success!
success!
success!
$c = new C();
$c->test(); //fails Fatal error: Call to private method C::foo() from context 'A' in /tmp/test.php on line 9
3.后期静态绑定的解析会一直到取得一个完全解析了的静态调用为止。另一方面，如果静态调用使用 parent:: 或者 self:: 将转发调用信息。
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
如上代码：B调用test方法，test方法调用who方法。而B类中重写了who方法，则实际调用的是B中的who方法，所以输出的__CLASS__是B 这就是说 static 调用的静态方法会在运行时自动判断调用谁的方法。而self则只会调用定义它时所在的类中的方法。这是static的一个区别于其它调用的一个新特性。而static调用非静态方法时则不会达到这种后期绑定的效果，所以叫后期静态绑定。
还有就是 static只能调用静态属性
综上所述，static关键字可以实现以下功能：
1 调用类的静态方法 有后期静态绑定效果；
2 调用类的静态属性 有后期静态绑定效果；
3 调用类的非静态方法 没有后期静态绑定效果；
4 强调一下 不可以调用非静态属性；
4.抽象类 abstract 声明类中方法，不能声明属性
1.注意：
（1）定义为抽象的类不能被实例化，所以需要通过继承的方式为属性复制，因为继承后可以继承抽象父类的属性这样就可以使用值和赋值
（2）不能从抽象类创建对象，它的意义在于被扩展
（2）抽象方法不必实现具体的功能，由子类来完成
（2）任何一个类，只要里面有一个方法被声明为abstract的，那么这个类就是抽象的，所以抽象类里面可以有非抽象的方法
（3）继承一个抽象类，子类必须定义父类中的所有抽象方法，访问控制必须和父类一样或者更宽松
（4）继承一个抽象类，实例化子类后的方法的调用方式必须匹配，即类型和所需参数数量必须一致，但是子类可以定义可选参数
2.使用：
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";
3.什么时候用到
（1）有个方法，方法体不知如何写，子类中还必须有这个方法时，封装成抽象方法，类为抽象类
（2）控制子类中必须封装某些方法时，可以用抽象方法
（3）当需要控制类只能被继承，不能被实例化时
5.接口 interface
1.可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容
2.如果一个类中，所有的方法都是抽象方法，且没有成员属性，则这个类被称为接口
interface Common{
abstract function work();
abstract function test($args);
}
作用：虽然PHP的类是单继承，但可以通过接口来实现多继承
实现：类实现接口使用implements : class 类名 implements 接口名称1,接口名称2, ...
还可以继承类同时实现接口：
class 类名 extends 父类名 implements 接口名称
抽象类和接口的区别：
相同点：
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 />';
}
}
6.final 关键字 属性不能被定义为final,只有类和方法可以被定义为final
如果父类中的方法被声明为 final，则子类无法覆盖该方法。如果一个类被声明为 final，则不能被继承。
引用;https://blog.csdn.net/z772532526/article/details/83375629
扫一扫
561
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
