WEB安全之PHP基础（五）：类中接口与典型关键字

1.接口

• 使用接口（interface），可以指定某个类必须实现哪些方法，但不需要定义这些方法的具体内容。
  接口是通过 interface 关键字来定义的，就像定义一个标准的类一样，但其中定义所有的方法都是空的。
  接口中定义的所有方法都必须是公有，这是接口的特性。
• 要实现一个接口，使用 implements 操作符。类中必须实现接口中定义的所有方法，否则会报一个致命错误。类可以实现多个接口，用逗号来分隔多个接口的名称。

<?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;
    }
}

• 
  
• 
  
• get_name同样也可以被调用
  
  
• 常量
  可以把在类中始终保持不变的值定义为常量。在定义和使用常量的时候不需要使用 $ 符号。
  常量的值必须是一个定值，不能是变量，类属性，数学运算的结果或函数调用。
• 自 PHP 5.3.0 起，可以用一个变量来动态调用类。但该变量的值不能为关键字（如 self，parent 或 static）。
• 实例

<?php
class MyClass
{
    const constant = '常量值';

    function showConstant() {
        echo  self::constant . PHP_EOL;
    }
}

echo MyClass::constant . PHP_EOL;

$classname = "MyClass";
echo $classname::constant . PHP_EOL; // 自 5.3.0 起

$class = new MyClass();
$class->showConstant();

echo $class::constant . PHP_EOL; // 自 PHP 5.3.0 起
?>

• 抽象类
  任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的。
  定义为抽象的类不能被实例化。
  被定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现。
• 继承一个抽象类的时候，子类必须定义父类中的所有抽象方法；另外，这些方法的访问控制必须和父类中一样（或者更为宽松）。例如某个抽象方法被声明为受保护的，那么子类中实现的方法就应该声明为受保护的或者公有的，而不能定义为私有的。
• 抽象类
• 类可以有多个接口
  
  
  

<?php
abstract class AbstractClass
{
 // 强制要求子类定义这些方法
    abstract protected function getValue();
    abstract protected function prefixValue($prefix);

    // 普通方法（非抽象方法）
    public function printOut() {
        print $this->getValue() . PHP_EOL;
    }
}

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_') . PHP_EOL;

$class2 = new ConcreteClass2;
$class2->printOut();
echo $class2->prefixValue('FOO_') . PHP_EOL;
?>

• 
• 抽象类不能实例化
  
• 定义变量和构造函数
  
• get_name用a1调用
  
• 因为get_name是受保护的，所以出现错误
  
  
  
• 
  
  
• 执行以上代码，输出结果为：

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

• 调用公有的抽象类的方法
• 直接在类的外部调用
  
  
• abstract抽象方法 在子类中必须 定义 少一个都会出错
• 抽象类不能new一个对象出来，会报错

接口与抽象类

• 1. 接口
     （1）对接口的使用是通过关键字implements
     （2）接口不能定义成员变量（包括类静态变量），能定义常量
     （3）子类必须实现接口定义的所有方法
     （4）接口只能定义不能实现该方法
     （5）接口没有构造函数
     （6）接口中的方法和实现它的类默认都是public类型的
• 2. 抽象类
     （1）对抽象类的使用是通过关键字extends
     （2）不能被实例化，可以定义子类必须实现的方法
     （3）子类必须定义父类中的所有抽象方法，这些方法的访问控制必须和父类中一样（或者更为宽松）
     （4）如一个类中有一个抽象方法，则该类必须定义为抽象类
     （5）抽象类可以有构造函数
     （6）抽象类中的方法可以使用private,protected,public来修饰。
     （7）一个类可以同时实现多个接口，但一个类只能继承于一个抽象类。

2.典型关键字

Static 关键字

• 声明类属性或方法为 static(静态)，就可以不实例化类而直接访问。
  静态属性不能通过一个类已实例化的对象来访问（但静态方法可以）。
  由于静态方法不需要通过对象即可调用，所以伪变量 $this 在静态方法中不可用。
  静态属性不可以由对象通过 -> 操作符来访问。
  自 PHP 5.3.0 起，可以用一个变量来动态调用类。但该变量的值不能为关键字 self，parent 或 static。

<?php
class Foo {
  public static $my_static = 'foo';
  
  public function staticValue() {
     return self::$my_static;
  }
}

print Foo::$my_static . PHP_EOL;
$foo = new Foo();

print $foo->staticValue() . PHP_EOL;
?>	

• 执行以上程序，输出结果为：

foo
Foo

• 想要调用类里面的属性和方法，加了静态关键字，就不需要实例化访问了
• 
  
• 方法也是一样的，类名加函数
  
  
• 不被允许的
  
• 通过self来访问
  
  

Final 关键字

• PHP 5 新增了一个 final 关键字。如果父类中的方法被声明为 final，则子类无法覆盖该方法。如果一个类被声明为 final，则不能被继承。
• 以下代码执行会报错：

<?php
class BaseClass {
   public function test() {
       echo "BaseClass::test() called" . PHP_EOL;
   }
   
   final public function moreTesting() {
       echo "BaseClass::moreTesting() called"  . PHP_EOL;
   }
}

class ChildClass extends BaseClass {
   public function moreTesting() {
       echo "ChildClass::moreTesting() called"  . PHP_EOL;
   }
}
// 报错信息 Fatal error: Cannot override final method BaseClass::moreTesting()
?>

• 调用父类构造方法
  PHP 不会在子类的构造方法中自动的调用父类的构造方法。要执行父类的构造方法，需要在子类的构造方法中调用 parent::__construct() 。
• 现在是一个子类的方法
  
  
• 加上Final关键字，父类与子类不能通信
  
  
• Final 子类不能重写父类的函数

<?php
class BaseClass {
   function __construct() {
       print "BaseClass 类中构造方法" . PHP_EOL;
   }
}
class SubClass extends BaseClass {
   function __construct() {
       parent::__construct();  // 子类构造方法不能自动调用父类的构造方法
       print "SubClass 类中构造方法" . PHP_EOL;
   }
}
class OtherSubClass extends BaseClass {
    // 继承 BaseClass 的构造方法
}

// 调用 BaseClass 构造方法
$obj = new BaseClass();

// 调用 BaseClass、SubClass 构造方法
$obj = new SubClass();

// 调用 BaseClass 构造方法
$obj = new OtherSubClass();
?>

• 执行以上程序，输出结果为：

BaseClass 类中构造方法
BaseClass 类中构造方法
SubClass 类中构造方法
BaseClass 类中构造方法

• 在子类中怎么调用父类的方法
  
  
• 构造函数
  
• 实例化的时候，构造函数会自动的去执行
  
  
• 会去调用父类的构造函数，再输出子类的构造函数