PHP 实例演示类与实例，类属性与类方法，类成员的访问控制， 类的扩展以及扩展的方式

1.类的声明与实例化

<?php
// 类的声明与实例化
// 1. 类的声明
class Goods
{
    // 类成员: 
    // 1. 类属性
    // 2. 类方法
    public $a = 'abc';
    // 类的实例构造方法/器
    public function __construct()
    {
    }
}
// 2. 类的实例化: 就是创建对象的对象
// 类中的构造方法必须用: new 来调用
$goods = new Goods();
var_dump($goods);
var_dump($goods instanceof Goods);
// 实例与对象，在不引起误会的场景下，可以通用
// 动态类, 将类名称放在一个变量中
$className = 'Goods';
$obj = new $className();
echo get_class($obj);

2.类属性与类方法

<?php
// 类中的方法
class User
{
    // public: 访问限定符，用来声明类成员的作用域
    // 类属性
    public $name = 'peter';
    public $age = 18;
    public static $nation = '码农';
    // 类方法
    public function write1()
    {
        // 访问类属性
        // 1. 实例化
        $user = new User;
        // 2 访问类成员
        return "姓名:{$user->name},年龄: {$user->age}";
    }
    // 类方法
    public function write2()
    {
        // 声明一个变量, 声明在方法中的变量，不是属性，是私有变量/局部变量
        $salary = 8000;
        // 访问类属性
        // 1. 实例化
        // 第一个问题： 类的名称被限定,使用self可以引用当前的类名称
        // $user = new self;
        // $this会自动创建, $this是只读的，不能被更新
        // $this = new self;
        // 2 访问类成员
        // 第二个问题: 类的实例，类中并不关心，它也只需要一个实例的引用就可以了
        // 引用当前类实例: $this
        return "姓名:{$this->name},年龄: {$this->age}, 工资 : {$salary}";
        // self: 类引用
        // $this: 类实例引用
    }
    // 类方法中访问(类)外部成员: 变量和函数
    public function write3()
    {
        // 调用外部函数
        $str = hello();
        // 外部变量
        return $str . $GLOBALS['username'];
    }
    // 实际项目中，外部成员应该通过方法参数注入到方法，而不是在方法中直接调用
    // 依赖注入
    public function write4(Closure $hello, string $username)
    {
        return $hello() . $username;
    }
    // 静态方法： 不依赖类实例，可以用类直接调用
    public static function write5()
    {
        // 静态成员属于类，不属性于类实例，所以不能使用类实例的引用$this
        // return "姓名:{$this->name},年龄: {$this->age}";
        return "工作: " . self::$nation;
    }
    // 普通方法中可以访问静态成员， 而反之不行
    public function write6()
    {
        return "工作: " . self::$nation;
    }
}
// 客户端代码
$user = new User;
echo $user->write1();
echo '<hr>';
echo $user->write2();
// 外部函数
function hello()
{
    return 'Hello ';
}
// 匿名函数
$hello = function ()
{
    return 'Hello ';
};
// 外部变量
$username = '灭绝老师';
echo '<hr>';
echo $user->write3();
echo '<hr>';
echo $user->write4($hello, $username);
echo '<hr>';
echo $user->write5();
echo '<hr>';
echo $user->write6();

3.类成员的访问控制

<?php
// 类成员的访问控制
class User
{
// public：公共成员，默认值
public $name = "peter";
// 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 '
';
echo $user->write();
// 3.访问子类
echo '
';
echo (new Rob)->write();
// 4.类的私有成员，年龄private:私有成员 只能本类内部使用，外部和子类都不可以
// 5.protected:受保护成员,外部不能用，内部和子类都可以

4.类的扩展以及扩展方法

<?php
// 类的继承或扩展
// 变量是数据复用，函数是代码复用，继承是类的复用
// final class User:类禁止扩展
class User
{
protected $name = 'peter';
// 方法
// final public function write()方法禁止重写
public function write()
{
return "姓名：{$this->name}";
}
}
// 扩展类/子类
class Rob extends User
{
// 1.扩展
// 属性扩展
protected $age = 18;
// 方法扩展
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();