php中的类与对象(抽象、接口与特性)

抽象

抽象类和抽象方法使用关键字abstract进行声明。任何一个类，如果它里面至少有一个方法是被声明为抽象的，那么这个类就必须被声明为抽象的。被定义为抽象的方法只是声明了其调用方式（参数），不能定义其具体的功能实现。注意，抽象的类可以有非抽象方法，但不能被实例化。

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

// 定义一个抽象类，不管其中是否有抽象方法
abstract class MyAbClass 
{
  public const Name = "MyAbClass";  // 类常量
  static public function put() {    // 类方法
    echo "MyAbClass put()\n";
  }
  public function putDat() {        // 普通方法
    echo "\$x: $this->x, \$y: $this->y\n";
  } 

  // 抽象方法，注意可访问修饰符不能是private
  abstract protected function comput($i); 
}

class MySubClass extends MyAbClass 
{
  public function __construct($x, $y) {
    $this->x = $x;
    $this->y = $y;
  }

  // 实现抽象方法，可访问修修饰符可以变得更开放
  // 抽象父类要求此方法可用一个实参调用，这里添加可选参数，满足"可用一个实参调用"的要求
  public function comput($i, ...$x) {
    $this->x *= $i;
    $this->y *= $i;

    foreach($x as $d) {
      $this->x += $d;
      $this->y += $d;
    }
  }
}

$a = new MySubClass(2,3);
$a->comput(2);
$a->putDat();       // $x: 4, $y: 6
$a->comput(2,3,4);
$a->putDat();       // $x: 15, $y: 19

接口

接口使用interface关键字进行定义，接口在继承另一个接口时，使用extends关键字，但类在实现接口时，使用implements关键字。

接口中定义的所有方法都必须是公有，这是接口的特性。类可以实现多个接口，用逗号来分隔多个接口的名称。如果类中没有实现接口的全部方法，则必须将类定义成抽象类。

interface if00{}
interface if01{}

interface if1
{
  // 接口成员都必须是public的，可省略
  public function func1();
}

interface if2 extends if1, if01
{
  // 接口中可以定义常量，但不能定义静态变量
  const Name = "if2";
  function func2();
}

// 定义一个抽象类，因为此类未实现全部接口方法
abstract class MyAbClass  implements if2, if00
{
  public function func1(){
    echo "func1\n";
  }
}

class MySubClass extends MyAbClass implements if00
{
  // 与实现抽象方法一样，可以添加可选参数
  public function func2(...$x) {
    echo "func2\n";
  }
}

$a = new MySubClass();
$a->func1();            // func1
$a->func2();            // func2
echo MySubClass::Name;  // if2      也可使用"接口名::Name"以及类名或接口名的字符串变量形式

trait

trait是一种与类类似的语言结构，作用与继承相似，都可以达到代码利用的目的。

Trait 是为类似 PHP 的单继承语言而准备的一种代码复用机制。Trait 为了减少单继承语言的限制，使开发人员能够自由地在不同层次结构内独立的类中复用成员。Trait 和 Class 组合的语义定义了一种减少复杂性的方式，避免传统多继承和 Mixin 类相关典型问题。 
Trait 和 Class 相似，但仅仅旨在用细粒度和一致的方式来组合功能。 无法通过 trait 自身来实例化。它为传统继承增加了水平特性的组合；也就是说，应用的几个 Class 之间不需要继承。 
trait不能继承类，也不能实现接口，但可以使用组合其他trait。

trait MyTrait
{
  private function getMax(...$x) {
    if(count($x)) {
      $max = $x[0];
      foreach($x as $dat) {
        if($dat > $max) $max = $dat;
      }
      return $max;
    }
  }
}

class MyClass
{
  use MyTrait;

  private $a = array(1,2,3,4,8,23,3,32,3);

  public function printMax() {
    echo self::getMax(...$this->a);
  }
}

$a = new MyClass;
$a->printMax();              // 32

trait这种代码利用技术有点像“复制粘贴”，在trait中可以定义private成员，当类使用了该trait之后，就会原原本本地获得一个private成员。在trait中，可以定义对象成员、静态成员，虚拟方法，不过不可以定义类常量。

如果类中定义了与trait中定义的同名属性，则必须以完成相同的定义形式，则相同的可访问必和初始值。

trait MyTrait1
{
  private $a = 4;
  protected $b = 4;
  public $c = 4;

  function put() {
    echo "put \$a: $this->a\n";
  }

  static public $d = 5;
  // const Six = 6; trait中不能定义常量

  static function testStatic() {
    echo self::$d."\n";
  }
}

trait MyTrait2
{
  abstract function abTest();
}

trait MyTrait
{
  use MyTrait1, MyTrait2;
}

class MyClass
{
  use Mytrait;

  private $a = 4;
  protected $b = 4;
  public $c = 4;

  public function abTest() {
    echo "abTest\n";
  }
}

$a = new MyClass;
$a->put();              // put $a: 4
$a->abTest();           // abTest
MyClass::testStatic();  // 5

trait中的重名优先级

优先顺序是来自当前类的成员覆盖了 trait 的方法，而 trait 则覆盖了被继承的方法。

class Base
{
  public function sayHello() {
    echo "Hello Base\n";
  }
}

trait MyTrait
{
  public function sayHello() {
    parent::sayHello();
    echo "Hello Trait\n";
  }
  public function sayHelloWorld() {
    echo "Hello Trait\n";
  }
}

class MyClass extends Base
{
  use MyTrait;

  public function sayHelloWorld() {
    echo "Hello World\n";
  }
}

$a = new MyClass();
$a->sayHello();
$a->sayHelloWorld();
/*
Hello Base
Hello Trait
Hello World
*/

解决多个trait的命名冲突

1.使用insteadOf来指定使用哪一个版本;

2.在已经进行insteadOf的前提下，可以使用as操作符来为被隐藏的方法定义别名或可访问修饰符，被隐藏的方法可通过别名访问;

trait MyTrait1
{
  public function sayHello() {
    echo "Hello";
  }
}
trait MyTrait2
{
  public function sayHello() {
    echo "Hi";
  }
}
trait MyTrait3
{
  public function sayHello() {
    echo "你好";
  }
}
class MyClass
{
  use MyTrait1, MyTrait2, MyTrait3 {
    MyTrait1::sayHello insteadOf MyTrait2 , MyTrait3;   // 以分号结尾
  }  // 注意，这里不能添加分号
}

$a = new MyClass();
$a->sayHello();          // Hello

trait MyTrait1
{
  public function sayHello() {
    echo "Hello";
  }
}
trait MyTrait2
{
  public function sayHello() {
    echo "Hi";
  }
}
trait MyTrait3
{
  public function sayHello() {
    echo "你好";
  }
}

class MyClass
{
  use MyTrait1, MyTrait2, MyTrait3 {
    MyTrait1::sayHello insteadOf MyTrait2, MyTrait3;
    MyTrait2::sayHello as sayHi;
    MyTrait3::sayHello as private sayNiHao;  // 如果没有重名问题，也可以只更改可访问修饰符
  }
}

$a = new MyClass();
$a->sayHello();          // Hello
$a->sayHi();             // Hi