关于访问类中属性

<?php
class User
{
    public $name = 'maichael';
    public $age = 30;
    // 访问类中属性
    // 方法1.
    public function class1(){
        // 创建类实例
        $class1 = new user;
        return '姓名：'.$class1->name.'年龄：'.$class1->age;
    }
    // 方法2.
    public function class2(){
        // $this始终与当前类绑定，为PHP系统进行维护和赋值
        return "姓名：{$this->name} 年龄：{$this->age}";
    }
    // 类种方法变量与类属性区别
    // 简单说 该变量需要在多个方法中使用时，创建为类属性
    // 该变量仅在当前方法中使用时，创建为类中方法变量
    public function class3(){
        $city = '成都';
        return "姓名：{$this->name} 年龄：{$this->age} 城市：{$city}";
    }
    // 类方法访问外部成员 函数直接访问 变量用global访问
    public function class4(){
        $func = func();
        global $a;
        return func() . $a;
    }
    // 改进类中方法
    public function class5(string $a , Closure $closure){
            return $closure().$a;
    }
    // 静态方法直接用类调用被所有示例所共享
    static public $nationality = '加拿大';
    static public function class6(){
        return '国籍是'. self::$nationality;
    }
}
$user = new User;
// 方法1
echo $user->class1();
// 输出姓名：maichael年龄：30
// 方法2
echo $user->class2();
// 输出姓名：maichael年龄：30
echo '<hr>';
// 类中变量
 echo $user->class3();
 // 输出 姓名：maichael 年龄：30 城市：成都
//  类种方法访问外部成员
function func(){
    return 'PHP';
}
$a = '中文网';
echo $user->class4();
// 输出PHP中文网
// 改进类中方法
$func = function (){
    return 'PHP';
};
echo $user->class5($a,$func);
// 静态方法
echo $user->class6();
// 输出国籍是加拿大

类的成员访问控制

// 类的成员访问控制：作用域
// 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

接口

// 接口：完成分离了“设计与实现”
// 关键字：interface
// 使用与类相似的语法：抽象方法，常量，构造方法（魔术方法的一种）
// 默认访问控制必须是public
// 接口允许多继承，从而实现了PHP的多继承
// 子类继承父类使用 implements
// 创建接口
interface User{
    // 接口常量 const
    const NAME = 'michael';
    // 接口方法
    public static function class();
}
// 访问一下接口常量
echo User::NAME;
// 工作类实现接口
class Ser implements User{
 protected static $age =  17;
 public static function class(){
     return '姓名： '.User::NAME. '年龄： '.self::$age;
    //  注意 这个地方不能用“” 双引号
 }
}
echo Ser::class();
// 输出姓名： michael年龄： 17