PHP - 类的成员访问控制

dream518

// 类的成员访问控制：作用域
// public: 公开成员，默认值，类外部类内部以及类的子类中均可使用
// protected :受保护成员，禁止类外部使用，类内部及子类可使用
// private : 私有成员，仅在当前类中可使用，类外部及子类均禁止使用
// 类的上下文环境：当前类以及他的扩展类/子类，构成的一个具有层级结构的类家庭

class User
{
    public $name = 'michael';
    protected $age = 30;
    private $gender = '男';
    // 当前类访问私有成员
    public function func()
    {
        return "性别：{$this->gender}";
    }
}
// 访问一下
$user = new User;
echo $user->name;
// echo $user->age; 报错无法访问受保护的
// echo $user->gender;  报错 无法访问私有的
echo $user->func();  //输出性别：男

// 创建子类
class Ser extends User
{
// 创建一个方法访问父类中的受保护成员
 public function class()
{
    return "年龄：{$this->age}";
}

// 子类访问父类私有成员
public function class1()
{
     return "性别：{$this->gender}";
}
}
$ser = new Ser;
echo $ser->class();
// 输出年龄:3

// 输出父类私有成员
// echo $ser->class1();  报错：未定义的属性

类的继承

// 面向对象   OOP：封装，继承，多态
// 封装 public protected private
// 继承 extends
// 多态 方法的重写是实现方法级的多态，面向接口开发是实现对象级的多态

// 类的继承
// 二类成员：父类的public protected
// 三种操作：继承，重写，扩展
// 继承：父类的二类成员自动成为子类的成员
// 重写：覆盖与父类同名的成员（属性、方法）
// 扩展：子类添加自身的方法来扩展父类的功能
// 父类也叫基类，子类也叫扩展类

// 创建父类
class User
{
    public $name = 'michael';
    protected $age = 30;
    private $gender = '男';
    public static $nationality = '加拿大';
    // 创建方法
    public function Name()
    {
        return $this->name;
    }
}

// 创建子类
class Ser extends User
{
    // 重写父类属性
    public $name = "kaiwen";
    // 重写方法
    public function Name(){
        return parent::Name().'不是中国人';
    }
    // 扩展属性
    public $hibby = 'shoot';
    // 扩展方法
    public function means(){
        return parent::Name()."爱好：{$this->hibby}";
    }
}

// 子类实例化
$ser = new Ser;
// 直接继承父类方法，在子类输出
echo $ser->Name();  //输出 michael
// 重写父类name属性，输出
echo $ser->Name();   //输出 kaiwen不是中国人 因为上面已经重写了name的值 所以不是michael
echo '<hr>';
// 扩展
echo $ser->means();  //输出kaiwen爱好：shoot

// 最终方法最终类 在前面加 final

抽象类

// 抽象类：部分分离了设计（抽象类的完成）与实现（工作类的完成）
// 只要一个类中有一个抽象方法 那么这个类就是抽象类
// 抽象方法：没有方法体

// 创建一个抽象类
abstract class User
{
    public $name = 'michael';
    protected $age = 30;
    private $gender = '男';
    public static $nationality = '加拿大';
    // 创建方法
    public function Name()
    {
        return $this->name;
    }
    // 创建抽象方法:没有方法体
    abstract public function class();
}

// 子类叫做实现类或者工作类 父类中的抽象方法必须在子类中实现
// 实现类、工作类：是一个可以被实例化的普通类
// 工作类不一定是一个可以被实现的普通类，他也可以是一个抽象类
// 抽象类也可以被继承，也可以被用在继承上下文环境中、
// 抽象类中允许有抽象成员，但不是强制的，也可以没有
abstract class Ser extends User
{
    // 创建一个受保护的属性
    protected $hibby = 'shoot';
    // 必须将父类中的抽象方法实现
    public function class(){
        return "姓名：{$this->name} 兴趣：{$this->hibby}";
    }
}

// 最终工作类:允许被实例化

class Er extends Ser
{
    public function class(){
        return parent::class();
    }
}

// 实例化
$er =  new Er;
echo $er->class();
// 输出姓名：michael 兴趣：shoot