类的扩展、抽象及接口和命名空间

类的扩展、抽象及接口

protected 可继承成员
extends 类成员的来源
parent父类引用

class Person
{
    // 1. 属性
    // public: 公共成员, 当前类, 类外部
    // public string $email = 'a@qq.com';
    // private: 私有成员, 仅限当前类,类外部不可见
    private int $id = 10;
    // protected: 受保护的, 用在当前类,以及他的子类
    protected string $name;
    // public > protected > private
    // 类中,类外,子类: public
    // 类中,子类: protected
    // 类中: private
    // 2. 方法
    public function __construct($name)
    {
        $this->name = $name;
    }
    // 自定义方法
    protected function getInfo(): string
    {
        return $this->name;
    }
}

扩展

class Stu extends Person
{
    // extends: 相当于把父类代码复制到当前类中(除Private成员外)
    // 只需要扩展父类中的:"属性和方法"
    // 1. 属性扩展
    // 之前
    // protected string $name;
    // 扩展的
    private string $lesson;
    private int $score;
    // 2. 方法扩展
    // 构造方法
    public function __construct($name, $lesson, $score)
    {
        // parent: 引用父类
        parent::__construct($name);
        $this->lesson = $lesson;
        $this->score = $score;
    }
    // protected -> public
    public function getInfo(): string
    {
        return  parent::getInfo() . '同学, (' . $this->lesson . 
' ) , 成绩: ' . $this->score .'<br>';
    }
}
$stu = new Stu('小张', 'php', 90);
echo $stu->getInfo() ;

抽象类

禁用父类, 仅允许通过它的子类来访问父类成员
把当前类,声明为”抽象类”: abstract
如果类中有抽象方法,则这个类必须声明为抽象类

abstract class Demo1
{
    public string $name = 'admin';
    // 如果某个方法没有具体实现,应该声明成抽象方法
    abstract public static function getInfo($name);
}
class Demo2 extends Demo1
{
    // 在子类中, 必须将父类中的抽象方法实现了
    public static function getInfo($name)
    {
        return 'Hello, ' .$name;
    }
}
echo Demo2::getInfo('朱老师');

接口类

升级版的”抽象类”

 // 接口类
interface iUser
{
    // 常量
    public const NATION = 'CHINA';
    // 方法: public
    public function m1();
    public function m2();
}
// 工作类: 实现了接口的类
class Demo1 implements iUser
{
    // 接口的抽象方法,必须在工作类中全部实现
    public function m1()
    {
    }
    public function m2()
    {
    }
}
// 如果实现类仅实现了接口的一部分抽象方法,应该声明为抽象类
abstract class Demo2 implements iUser
{
    public function m1()
    {
    }
}
class Demo3 extends Demo2
{
    public function m2()
    {
    }
}
// php是单继承
interface A
{
}
interface B
{
}
interface C
{
}
// Test类,同时从三个接口中获取成员,间接实现了"多继承"
class Test implements A, B, C
{
}
interface iDb
{
    // insert
    public static function insert(array $data);
    // update
    public static function update(array $data, string $where);
    // delete
    public static function delete(string $where);
    // select
    public static function select(array $options);
}
abstract class aDb
{
    // insert
    public static function insert(array $data)
    {
    }
    // update
    public static function update(array $data, string $where)
    {
    }
    // delete
    public static function delete(string $where)
    {
    }
}
class Db extends aDb
{
}

命名空间

全局成员

全局成员: 函数, 常量, 类/接口,全局有效, 禁止重复声明

function hello()
{
}
const A =1;
class D
{
}
// 将第二个hello 声明到另一个空间中,不会重名了
namespace _0815_1;
function hello()
{
}
const A = 2;
class D
{
}

跨空间

class Demo1
{
    public static string $name = 'admin';
}
// 当存在命名空间时, 全局成员应该使用完整的名称
// 完整类名 = 空间名称\类名
// ::class 获取类的完整名称
echo Demo1::class . '<br>';
echo \two\Demo1::$name;
namespace two;
class Demo1
{
    public static string $name = '猪老师';
}
echo Demo1::class . '<br>';
// 跨空间访问
// echo one\Demo1::$name;
// 跨空间访问时,必须从根空间/全局空间开始查询: \
echo \one\Demo1::$name;
// 实际访问的是: 'two\one\Demo1'