类声明-实例化-成员-继承-trait特征类

类声明-实例化-成员-继承-trait特征类

1. 实例演示类声明，类的实例化，类的静态成员与类的扩展;
2. 描述trait功能,以及trait与父类的区别与联系,并实例演示trait 的冲突与优先级的解决方案

1. 实例演示类声明，类的实例化，类的静态成员与类的扩展;

// 实例演示类声明，类的实例化，类的静态成员与类的扩展;
// class 声明一个类
class ParentClass
{
    // 私有属性：当前类中使用
    private $id;
    // 受保护的属性：当前和扩展类中使用
    protected $slug;
    // 公开属性：外部可访问
    public $title;
    // 静态属性
    public static $num;
    // 构造方法
    public function __construct($id, $slug, $title, $num)
    {
        $this->id = $id;
        $this->slug = $slug;
        $this->title = $title;
        // 静态成员赋值
        self::$num = $num;
    }
    // 公开方法
    public function show()
    {
        return sprintf('id=%d, slug=%s, title=%s, num=%d', $this->id, $this->slug, $this->title, self::$num);
    }
}
// 类的实例化
$parentClass = new ParentClass(7, 'seven', 'title-seven', 77);
// 访问公开属性
// title-seven
echo $parentClass->title, '<br>';
// 访问公开静态属性
// 77
echo ParentClass::$num, '<br>';
// 访问公开方法
// id=7, slug=seven, title=title-seven, num=77
echo $parentClass->show(), '<br>';
// 声明一个扩展类
class SubClass extends ParentClass
{
    // 子类私有属性
    private $child;
    // 子类构造方法
    public function __construct($id, $slug, $title, $num, $child)
    {
        // 调用父类构造方法
        parent::__construct($id, $slug, $title, $num);
        // 设置私有属性
        $this->child = $child;
    }
    // 子类覆盖父类方法
    public function show()
    {
        // 调用父类方法和自己本身的私有方法
        return parent::show() . ', ' . $this->child();
    }
    // 子类自己的私有方法
    private function child() {
        return $this->child;
    }
}
// 扩展类实例化
$subClass = new SubClass(10, 'ten', 'title-ten', 10, 'has a child');
// id=10, slug=ten, title=title-ten, num=10, has a child
echo $subClass->show(), '<br>';

2. 描述trait功能,以及trait与父类的区别与联系,并实例演示trait 的冲突与优先级的解决方案

• trait 特征类，提供一组公共方法集，借用类的语法实现，特征类本身不能实例化。

• 父类，可以实例化。

• trait 特征类，类使用 use 关键字，实现代码复用特征类中的方法。

• 父类，类使用 extends 扩展父类，实现代码复用父类中的方法。

• 类同时扩展父类，又使用 trait 特征类，同名方法优先级是：类自身中的方法 > trait 特征类 > 扩展的父类

// 描述trait功能,以及trait与父类的区别与联系,并实例演示trait 的冲突与优先级的解决方案
// 描述trait功能,以及trait与父类的区别与联系
// trait 特征类
trait P1
{
    public function hello()
    {
        return 'hello trait!';
    }
}
// 声明一个父类
class P2
{
    public function hello()
    {
        return 'hello parent!';
    }
}
// 声明一个类使用特征类方法
class S1
{
    // 使用 P1 特征类中方法
    use P1;
    // hello trait!
    function show()
    {
        return $this->hello();
    }
}
$s1 = new S1;
// hello trait!
echo $s1->show(), '<br>';
// 声明一个扩展类使用父类方法
class S2 extends P2
{
    public function show()
    {
        // hello parent!
        return $this->hello();
    }
}
$s2 = new S2;
// hello parent!
echo $s2->show(), '<br>';
// 声明一个类，扩展父类，又使用特征类
class S3 extends P2
{
    // 使用特征类中方法
    use P1;
    public function show()
    {
        // hello trait!
        return $this->hello();
    }
}
$s3 = new S3;
// hello trait!
echo $s3->show(), '<br>';
// 实例演示trait 的冲突与优先级的解决方案
trait T1 {
    public function t() {
        return 'Trait T1';
    }
}
trait T2 {
    public function t() {
        return 'Train T2';
    }
}
class S {
    use T1, T2 {
        // 优先级
        T1::t insteadof T2;
        // 别名
        T2::t as t2;
    }
}
// Trait T1
echo (new S)->t(), '<br>';
// Train T2
echo (new S)->t2(), '<br>';