欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

类与对象基础1

程序员文章站 2022-03-16 08:25:00
...

类与实例

  1. 类的声明
    1. class Goods
    2. {
    3. // 类成员:
    4. // 1.类属性
    5. // 2.类方法
    6. }
  2. 类的实例化
    1. $goods = new Goods();
    动态类,将类名称放在一个变量中
    1. $className = 'Goods';
    2. $obj = new $className();

类属性与类方法

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

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

    1. // 普通属性和抽象属性的访问
    2. print_r($user->options[1]);
    3. var_dump(is_null($user->salary));
    4. // 访问静态成员使用双冒号:范围解析符
    5. echo User::$nation;
  3. 类方法访问时类名称被限定

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

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

  4. 类方法中访问(类)外部成员:变量与函数
    类方法中可以直接调用外部函数,不能直接调用外部变量

    1. // 类方法中访问(类)外部成员:变量和函数
    2. public function write3(){
    3. // 调用外部函数
    4. $str = hello();
    5. // return $str.$username; 直接调用访问不到
    6. return $str.'!'.$GLOBALS['username'];
    7. }
    8. // 客户端代码
    9. $user = new User;
    10. // 外部变量
    11. $username = '周杰伦';
    12. // 外部函数
    13. function hello()
    14. {
    15. return 'Hello';
    16. }
    17. echo $user->write3();

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

    1. // 匿名函数
    2. $hello = function()
    3. {
    4. return 'Hello';
    5. };
    6. echo $user->write4($hello,$username);

    类方法中通过参数名调用

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

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

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

    类与对象基础1
    普通方法中可以访问静态成员,反之不行

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

类成员的访问控制

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

    1. class User
    2. {
    3. // public:公共成员,默认值
    4. // public: 公共成员,类外部和内部以及子类中均可使用
    5. public $name = '蔡徐坤';
    6. // 类内部
    7. public function write()
    8. {
    9. return "姓名:{$this->name}";
    10. }
    11. }
    12. // 子类
    13. class Rob extends User
    14. {
    15. public function write()
    16. {
    17. return "姓名:{$this->name}";
    18. }
    19. }
    20. // 类外部访问
    21. $user = new User;
    22. echo $user->name;
    23. echo '<hr>';
    24. // 类内部访问
    25. echo $user->write();
    26. echo '<hr>';
    27. // 子类访问
    28. $rob = new Rob;
    29. echo $rob->write();

    类与对象基础1

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

    1. // private:私有成员,仅限于本类内部使用,外部或者子类均不可使用
    2. private $age = 35;
    3. // 类外部访问
    4. $user = new User;
    5. echo $user->age;
    6. echo '<hr>';

    类与对象基础1

    1. // 类内部
    2. public function write()
    3. {
    4. return "姓名:{$this->name},年龄:{$this->age}";
    5. }
    6. // 类内部访问
    7. echo $user->write();
    8. echo '<hr>';

    类与对象基础1

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

    类与对象基础1

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

类的扩展

  1. 类的扩展也叫类的继承(变量是数据的复用,函数是代码的复用,继承就是类的复用)
  2. 扩展类/子类包含了扩展和重写
    1)扩展包括了:属性扩展、方法扩展

    1. class User
    2. {
    3. protected $name = '蔡徐坤';
    4. public function write()
    5. {
    6. return "姓名:{$this->name}";
    7. }
    8. }
    9. // 扩展类/子类
    10. class Rob extends User
    11. {
    12. // 1.扩展
    13. // 属性扩展
    14. protected $age = 50;
    15. // 方法扩展
    16. public function write()
    17. {
    18. return parent::write() . ",年龄:{$this->age}";
    19. }
    20. }
    21. // 调用
    22. $rob = new Rob;
    23. echo $rob->write();

    2)同理,重写也包括了属性重写、方法重写

    1. // 扩展类/子类
    2. class Rob extends User
    3. {
    4. // 1.扩展
    5. // 属性扩展
    6. protected $age = 50;
    7. // 方法扩展
    8. // public function write()
    9. // {
    10. // return "姓名:{$this->name}";
    11. // }
    12. // 2.重写
    13. // 属性重写
    14. protected $name = '王胖子';
    15. // 方法重写
    16. public function write()
    17. {
    18. return parent::write() . ",年龄:{$this->age}";
    19. }
    20. }

    3)方法前加final 禁止重写

    1. // final: 方法前加final 禁止重写
    2. final function write()
    3. {
    4. return "姓名:{$this->name}";
    5. }

    类与对象基础1
    4)同理,类前加final禁止扩展

    1. // final: 类前加final禁止扩展
    2. final class User
    3. {
    4. // 属性
    5. protected $name = '蔡徐坤';
    6. // 方法
    7. public function write()
    8. {
    9. return "姓名:{$this->name}";
    10. }
    11. // final: 方法前加final 禁止重写
    12. // final function write()
    13. // {
    14. // return "姓名:{$this->name}";
    15. // }
    16. }

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