一、类的声明与实例化

1. 类成员：1.类属性， 2.类方法

实例就是对象，实例与对象在不引起误会的场景下，可以通用
类中的构造方法用new来调用
动态类：将类名称放在一个变量中

<?php
class Goods
{
    public $a = 1;
    public function __construct()
    {
    }
}
$goods = new Goods();
var_dump($goods);
// var_dump($goods instanceof Goods);
// 动态类：将类名称放在一个变量中
// $className = 'Goods';
// $obj = new $className();

2. 类中的成员访问:public function write()、echo $user->write();

<?php
// 类中的方法
class User
{
    // 1.类属性
    public $name = "小芳";
    public $age = "20";
    public static $nation = 'CHINA';
    // 2.类方法
    public function write1()
    {
        // 访问类属性
        // 1.实例化,User是写死
        $user = new User;
        // 2.访问类成员
        return "姓名:{$user->name},年龄:{$user->age}";
    }
    public function write2()
    {
        // 声明了一个变量,工资1万，它不是属性，是私有变量，局部变量
        $salary = 10000;
        // 访问类属性
        // 1.实例化
        // 问题1：类的名称被限定，使用self可以引用当前的类名称
        $user = new self;
        // $this会自动创建，$this = new self;
        // 2.访问类成员
        // 问题2：类的实例，只需要一个实例的引用
        // 引用当前类的实例：$this
        return "姓名:{$this->name},年龄:{$this->age}, 工资：{$salary}";
    }
    // 类方法中访问 类的外部成员：变量和函数
    public function write3()
    {
        // 调用外部函数
        $str = hello();
        // 调用外部变量GLOBALS
        return $str . $GLOBALS['username'];
    }
    // 实际项目中，外部成员应该通过方法参数注入到方法，而不是在方法中直接调用
    // 依赖注入
    public function write4(Closure $hello, string $username)
    {
        // 调用外部函数和变量
        return $hello() . $username;
    }
    // 静态方法：用类直接调用,只能访问静态成员,国籍
    public static function write5()
    {
        return "国籍：" . self::$nation;
    }
}
// 客户端代码
$user = new User;
echo $user->write1();
echo '<hr>';
echo $user->write2();
echo '<hr>';
// 外部函数
function hello()
{
    return 'word';
}
$hello = function () {
    return 'word';
};
// 外部变量
$username = '小刘';
echo $user->write3();
echo '<hr>';
echo $user->write4($hello, $username);
echo '<hr>';
echo $user->write5();

3. 类成员的访问控制

<?php
// 类成员的访问控制
class User
{
    // public：公共成员，默认值
    public $name = "小芳";
    // private:私有成员，只能本类内部使用，外部和子类都不可以
    private $age = 20;
    // protected:受保护成员,外部不能用，内部和子类都可以
    protected $salary = 9500;
    // 类内部访问
    public function write()
    {
        echo $user->salary;
        return "姓名：{$this->name}, 年龄：{$this->age}, 工资：{$this->salary}";
    }
}
// 子类,只有public和protected可见
class Rob extends User
{
    public function write()
    {
        return "姓名：{$this->name}, 工资：{$this->salary}";
    }
}
// 1.类的外部访问
$user = new User;
echo $user->name;
// 2.类内部访问
echo '<hr>';
echo $user->write();
// 3.访问子类
echo '<hr>';
echo (new Rob)->write();
// 4.类的私有成员，年龄private:私有成员 只能本类内部使用，外部和子类都不可以
// 5.protected:受保护成员,外部不能用，内部和子类都可以

4. 类的继承/扩展,及方法

<?php
// 类的继承或扩展
// 变量是数据复用，函数是代码复用，继承是类的复用
// final class User:类禁止扩展
class User
{
    protected $name = '小李';
    // 方法
    // final public function write()方法禁止重写
    public function write()
    {
        return "姓名：{$this->name}";
    }
}
// 扩展类/子类
class Rob extends User
{
    // 1.扩展
    // 属性扩展
    protected $age = 30;
    // 方法扩展
    public function write()
    {
        return parent::write() . ", 年龄：{$this->age}";
    }
    // 2.重写
    // 属性重写
    // protected $name = '小明';
    // 方法重写
    // public function write()
    // {
    //     return "{$this->name} : {$this->age} 岁";
    // }
}
// 调用
$rob = new Rob;
echo $rob->write();