类与对象基础1

类与实例

1. 类的声明

   
   class Goods
   {
    // 类成员：
    // 1.类属性
    // 2.类方法
   }
   

2. 类的实例化

   $goods = new Goods();

   动态类，将类名称放在一个变量中

   
   $className = 'Goods';
   $obj = new $className();
   

类属性与类方法

1. 类的属性分为普通属性、静态属性、抽象属性

   
   class User
   {
    // 类的属性
    // 公共成员：在类的内部和外部都可以访问，都可见
    public $name = '张三';
    public $options = [1,2,3];
    // heredoc,nowdoc都支持
    // 静态属性：如果这个属性仅使用一次，可以不创建类实例，而直接通过类来调用
    public static $nation = 'CHINA';
    // 抽象属性,没被初始化的属性
    public $salary;
   }
   

2. 类的普通属性、抽象属性和静态属性访问方式也不一样

   
   // 普通属性和抽象属性的访问
   print_r($user->options[1]);
   var_dump(is_null($user->salary));
   // 访问静态成员使用双冒号：范围解析符
   echo User::$nation;
   

3. 类方法访问时类名称被限定

   
    // 类方法
    public function write2(){
        // 访问类属性
        // 1.实例化
        // 第一个问题：类的名称被限定，使用self可以引用当前的类名称
        $user = new User;
        //$user = new self;
        // 2.访问类成员
        // 第二个问题：类的实例，类中并不关心，它也只需要一个实例的引用就可以了
        // 引用当前实例用$this
        //return "姓名：{$user->name},年龄：{$user->age}";
        return "姓名：{$this->name},年龄：{$this->age}";
    }
   

   解决方法：self: 类引用、$this: 类实例引用

4. 类方法中访问（类）外部成员：变量与函数
   类方法中可以直接调用外部函数，不能直接调用外部变量

   
    // 类方法中访问(类)外部成员：变量和函数
    public function write3(){
        // 调用外部函数
        $str = hello();
        // return $str.$username; 直接调用访问不到
        return $str.'!'.$GLOBALS['username'];
    }
    // 客户端代码
    $user = new User;
    // 外部变量
    $username = '周杰伦';
    // 外部函数
    function hello()
    {
        return 'Hello';
    }
    echo $user->write3();
   

   
   实际项目中，外部成员应该通过方法参数注入到方法，而不是在方法中直接调用
   首先要声明一个匿名函数，然后通过传参方法调用

   
   // 匿名函数
   $hello = function()
   {
    return 'Hello';
   };
   echo $user->write4($hello,$username);
   

   类方法中通过参数名调用

   
    // 实际项目中，外部成员应该通过方法参数注入到方法，而不是在方法中直接调用
    public function write4(Closure $hello, string $username){
        //调用外部函数和变量
        return $hello().'!'.$username;
    }
   

   得到的结果是一样的(这种方法也叫做’依赖注入’)
   
   静态方法访问内部成员不需要类实例化

   
    // 静态方法：不依赖类实例，可以用类直接调用
    public static function write5()
    {
        // 静态成员属于类，不属于类实例，所以不能使用类实例引用$this
        // return "姓名：{$this->name},年龄：{$this->age}";
        return "国籍：".self::$nation;
    }
   
    echo $user->write5();
   

   
   普通方法中可以访问静态成员，反之不行

   
    // 普通方法中可以访问静态成员，反之不行
    public function write6(){
        return "国籍：".self::$nation;
    }
   

类成员的访问控制

1. public: 公共成员，类外部和内部以及子类中均可使用

   
    class User
    {
        // public:公共成员，默认值
        // public: 公共成员，类外部和内部以及子类中均可使用
        public $name = '蔡徐坤';
   
        // 类内部
        public function write()
        {
            return "姓名：{$this->name}";
        }
    }
   
    // 子类
    class Rob extends User
    {
        public function write()
        {
            return "姓名：{$this->name}";
        }
    }
   
    // 类外部访问
    $user = new User;
    echo $user->name;
    echo '<hr>';
   
    // 类内部访问
    echo $user->write();
    echo '<hr>';
   
    // 子类访问
    $rob = new Rob;
    echo $rob->write();
   

   

2. private：私有成员，仅限于本类内部使用，外部或者子类均不可使用

   
    // private：私有成员，仅限于本类内部使用，外部或者子类均不可使用
    private $age = 35;
   
    // 类外部访问
    $user = new User;
    echo $user->age;
    echo '<hr>';
   

   

   
    // 类内部
    public function write()
    {
        return "姓名：{$this->name},年龄：{$this->age}";
    }
   
    // 类内部访问
    echo $user->write();
    echo '<hr>';
   

   

   
   // 子类访问
   $rob = new Rob;
   echo $rob->write();
   

   

3. protected：受保护成员，除了外部不可见，内部和子类均可见

类的扩展

1. 类的扩展也叫类的继承（变量是数据的复用，函数是代码的复用，继承就是类的复用）

2. 扩展类/子类包含了扩展和重写
   1）扩展包括了：属性扩展、方法扩展

   
    class User
    {
        protected $name = '蔡徐坤';
   
        public function write()
        {
            return "姓名：{$this->name}";
        }
    }
   
    // 扩展类/子类
    class Rob extends User
    {
        // 1.扩展
        // 属性扩展
        protected $age = 50;
   
        // 方法扩展
        public function write()
        {
            return parent::write() . ",年龄：{$this->age}";
        }
    }
   
    // 调用
    $rob = new Rob;
    echo $rob->write();
   

   2）同理，重写也包括了属性重写、方法重写

   
    // 扩展类/子类
    class Rob extends User
    {
        // 1.扩展
        // 属性扩展
        protected $age = 50;
   
        // 方法扩展
        // public function write()
        // {
        //     return "姓名：{$this->name}";
        // }
   
        // 2.重写
        // 属性重写
        protected $name = '王胖子';
        // 方法重写
        public function write()
        {
            return parent::write() . ",年龄：{$this->age}";
        }
    }
   

   3）方法前加final 禁止重写

   
    // final: 方法前加final 禁止重写
    final function write()
    {
        return "姓名：{$this->name}";
    }
   

   
   4）同理，类前加final禁止扩展

   
    // final: 类前加final禁止扩展
    final class User
    {
        // 属性
        protected $name = '蔡徐坤';
   
        // 方法
        public function write()
        {
            return "姓名：{$this->name}";
        }
        // final: 方法前加final 禁止重写
        // final function write()
        // {
        //     return "姓名：{$this->name}";
        // }
    }
   

总结：本节主要学了关于类的声明、成员访问、类的扩展