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

<
4000
br />