【PHP】类的静态成员和继承

类的静态成员和继承

1.类的静态成员
2.类的继承
3.接口
4.静态成员/动态绑定成员的调用者

1.类的静态成员

<?php
use Demo as GlobalDemo;
class Demo
{
    // 类常量
    public const courses = ['前端', '后端', '全栈'];
    //静态成员:属性,方法
    //静态属性
    public static string $siteName = 'PHP中文网';
    //静态方法
    public static function say()
    {
        //使用类访问,this是需要实例化的
        //self:类引用
        return self::$siteName . join(',', self::courses) . '课程';
    }
    //拦截非静态方法
    public function __call($name, $arguments)
    {
        return '这是非静态方法返回';
    }
    //拦截静态方法
    public static function __callStatic($name, $arguments)
    {
        return $name .' (' .implode(',',$arguments) . ')';
    }
}
//换行,PHP_EOL
echo Demo::say() . PHP_EOL;
//外部非法访问静态属性,不能被自动拦截/委托
//但是静态方法或被拦截/委托
echo Demo::filed('id','name','email') .PHP_EOL;
//访问一个不存的方法
echo (new Demo())->hello() .PHP_EOL;

2.类的继承

<?PHP
// protected:受保护成员
// extends:继承
// parent:父类引用
class Demo1
{
    //public:公开成员,本类,子类,类外均可访问无限制
    public string $name;
    //private:私有成员,仅限本类访问
    private float $buyCost;
    //protected:受保护成员,仅限当前类/子类使用,外部不可见
    protected int $num;
    //构造器
    public function __construct($name, $buyCost, $num)
    {
        $this->name = $name;
        $this->buyCost = $buyCost;
        $this->num = $num;
    }
    //格式化输出
    public function show()
    {
        return <<< SHOW
        1.品名: $this->name
        2.价格: $this->buyCost
        3.数量: $this->num\n
        SHOW;
    }
}
$obj1 = new Demo1('手机', 5000, 3);
echo $obj1->show() . PHP_EOL;
//----------------------------
echo '-------------------------'.PHP_EOL;
//子类
class Demo2 extends Demo1
{
    //子类:扩展父类功能
    public string $brand;
    //重写构造器,扩展更多属性和方法
    public function __construct($name, $buyCost, $num, $brand)
    {
        parent::__construct($name, $buyCost, $num);
        $this->brand = $brand;
    }
    //重写输出
    public function show()
    {
        return parent::show(). <<< SON
        4.品~牌: $this->brand
        SON;
    }
}
$obj2 = new Demo2('电脑', 10000, 2,'联想');
echo $obj2->show() . PHP_EOL;

3.接口

<?php
/**
 * 1.interface:定义接口
 * 2.implements:实现接口
 * 3.abstract:声明抽象类,抽象方法
 * 4.trait:组合式继承
 */
// 接口
interface idemo
{
    //所有成员必须公开
    public const GENDER = '男';
    //所有方法全部抽象(只有声明,没有实现)
    public function sum($a, $b);
    public function sub($a, $b);
    public function mul($a, $b);
    public function div($a, $b);
}
//接口不能直接用,必须要用到工作类来实现它
// 实现类 /工作类
class Work implements idemo
{
    //接口中的抽象方法全部实现
    public function sum($a, $b)
    {
        return $a + $b;
    }
    public function sub($a, $b)
    {
        return $a - $b;
    }
    public function mul($a, $b)
    {
        return $a * $b;
    }
    public function div($a, $b)
    {
        return $b !== 0 ? $a / $b : '除0错';
    }
}
// 实现类 /抽象类
abstract class aWork implements idemo
{
    //接口中的抽象方法全部实现
    public function sum($a, $b)
    {
        return $a + $b;
    }
    public function sub($a, $b)
    {
        return $a - $b;
    }
    //没有实现的方法,在抽象类中可声明为抽象方法
    //包含抽象方法的类,一定是抽象类,不能直接实例化使用
    //必须使用它的子类,将抽象方法功能完善后,才能实例化
    abstract public function mul($a, $b);
    abstract public function div($a, $b);
}
//抽象类不能直接实例化使用,必须使用它的子类来使用
//工作类
class Work1 extends aWork
{
    //接口中的抽象方法全部实现
    public function mul($a, $b)
    {
        return $a * $b;
    }
    public function div($a, $b)
    {
        return $b !== 0 ? $a / $b : '除0错';
    }
}
echo (new Work())->mul(3, 5) . PHP_EOL;
echo (new Work())->div(4, 0) . PHP_EOL;
//实例化子类后,调用父类的方法
echo (new Work1())->sum(5, 7) . PHP_EOL;
echo (new Work1())->sub(8, 2) . PHP_EOL;
// 接口:全抽象
// 抽象类:部分抽象
// 工作类:没有抽象
// PHP 默认单继承: 只能从一个父类中继承成员
// PHP 也能实现类似的多继承: PHP允许从多个接口中获取成员
// 多接口 -> 多继承
// interface iTest1
// {
//     public cosnt A = 1;
// }
// interface iTest2
// {
//     public cosnt B = 2;
// }
// interface iTest3
// {
//     public cosnt C = 3;
// }
// class Show implements iTest1,iTest2,iTest3
// {
// }
// echo Show::A .PHP_EOL;
// echo Show::B .PHP_EOL;
// echo Show::C .PHP_EOL;
// 接口:工作清单
interface iCURD
{
    public static function insert();
    public static function delete();
    public static function update();
    public static function select();
}
// 由功能组合式实现多继承 trait
// trait : 工具箱,基于类的语法,但和接口一样,不能实例化
trait t1
{
    public function d($data)
    {
        // var_dump($date);
    }
}
trait t2
{
    public function sum($a, $b, ...$args)
    {
        return $a + $b + array_sum($args);
    }
}
// 工作类
class Work2 extends Work1
{
    //引入工具箱: t2 后,就会屏蔽 Work1 类中的方法
    // * 优先级说明: 当前类 同名成员 > trait成员 > 继承成员
    use t2;
    public function sum($a, $b)
    {
        return $a + $b;
    }
}
echo (new Work2)->sum(10, 20) .PHP_EOL;
echo (new Work2)->sum(10, 20, 30, 40) .PHP_EOL;

4.静态成员/动态绑定成员的调用者

<?php
//static::静态成员/动态绑定成员的调用者
use Demo1 as GlobalDemo1;
class Demo1{
    public static function getMethod()
    {
        return __METHOD__ .'()';
    }
    public static function show()
    {
        $resule = '';
        // self:静态绑定,永远和当前类进行绑定,也叫编译绑定
        // static:动态绑定,和调用类进行绑定,也叫运行时绑定
        $result = '静态绑定: '.self::getMethod();
        $result = '动态绑定: '.static::getMethod();
        return $result;
    }
}
class Demo2 extends Demo1
{
    public static function getMethod()
    {
        return __METHOD__ .'()';
    }
}
//类的静态方法可以直接访问
echo Demo1::getMethod() .PHP_EOL;
echo Demo1::show() .PHP_EOL;
echo Demo2::Show() .PHP_EOL;