OOP 面向对象编程（1）：1，类与对象、oop封装性

编辑: admin 分类: 电脑知识 发布时间: 2023-06-14 来源:互联网
4.8 OOP 面向对象编程

面向对象就是把生活中要解决的问题都用对象的方式进行存储：把所有的数据用属性、方法表现出来。对象之间的互动是通过方法的调用完成互动。

4.8.1 类 class
  • 物以类聚，把具有相似特性的对象对垒到一个类中,类定义了这些相似对象拥有的相同的属性和方法
  • 类是相似对象的描述，成为类的定义，是该类对象的蓝图或者原型
  • 类的定义以关键字class开始，后面跟着这个类的名称。类的命名通常每个单词的第一个字母大写，以中括号开始和结束
  • 类的属性和方法统称为类成员
  1. class User
  2. {
  3.   // 成员属性
  4.   public $name;
  5.   private $salary;
  6.   protected $age;
  8.   public function __construct($salary, $age)
  9.   {
  10.     // $this代表本对象
  11.     $this->salary = $salary;
  12.     $this->age = $age;
  13.   }
  15.   // 成员方法
  16.   public function salary()
  17.   {
  18.     return $this->salary;
  19.   }
  20. }
4.8.2 对象 object
  • 类的实例化：通过类定义创建一个类的对象

  • 对象：一个类的实例(Instance)

  • 类的实例化为对象时使用关键字new，new之后紧跟类的名称和一对圆括号

  • 类的定义属性值都是空或默认值，而对象的属性都有具体的值
  • 对象中得成员属性和方法可以通过 -> 符号来访问
  1. $name = '灭绝';
  2. $salary = 20000;
  3. $age = 18;
  4. // new 实例化 得到对象引用
  5. $mj = new User($salary, $age);
  6. // 访问对象的属性和方法
  7. $mj->name = $name;
  8. echo $mj->name;  // 灭绝
  9. echo $mj->salary();  // 20000
4.8.3 对象的组成
  • 属性：用来描述对象的特定的值（组成元素），是对象的数据模型，用于描述对象的数据，也成为对象的成员变量。
  • 方法：定义对象的行为，是对象的行为模型，用于描述对象能够做什么事情，称为对象的成员方法。
4.8.4 对象的特点
  • 每一个对象都是独一无二的
  • 对象是一个特定的事物，他的职能是完成特定功能
  • 对象是可以重复使用，属性和方法的复用。（变量是实现数据的复用，函数是实现了代码块的复用）
4.8.5 访问控制

对象的属性和方法有三种访问权限：

  • public是公有的类成员，可以在任何地方被访问，可以被类以及子类或者对象都可以访问

    1. class User1
    2. {
    3.   public $name;
    5.   public function sayHello()
    6.   {
    7.     echo "Hello " . $this->name;
    8.   }
    9. }
    11. $mj = new User1();
    12. $mj->name = '灭绝';
    13. echo $mj->name;  // 灭绝
    14. echo $mj->sayHello();  //Hello 灭绝

    注意：尽量不要使用公共属性，因为直接访问公共属性不能强制性地检验数据有效性。例如，无法阻止用户给 name 这样赋值：$mj->name = ‘12345’;，解决方法：将属性设为私有属性，然后定义公共方法来调用是由属性。

  • private私有的类成员，只能被自身访问，不能被子类继承，也不能被对象访问，只能在自身通过封装让外界访问（例如在类里面定义一个公开方法来调用私有属性）;

    1. class User
    2. {
    3.   private $name;
    5.   public function setName($name)
    6.   {
    7.     if ($this->validateName($name)){
    8.       $this->name = $name;
    9.     } else {
    10.       echo "name 格式有误！";
    11.     }
    12.   }
    14.   public function getName(){
    15.     echo $this->name;
    16.   }
    18.   // 数据验证方法，仅对象内部可见，外部无法访问
    19.   private function validateName($name){
    20.     if ($name == '' || is_numeric($name)){
    21.       return false;
    22.     } else if (strlen($name) < 2 || strlen($name) > 8){
    23.       return false;
    24.     } else {
    25.       return true;
    26.     }
    27.   }
    28. }
    30. $mj = new User();
    31. $mj->setName('灭绝');
    32. $mj->getName();  // 灭绝

  • protected 受保护的类成员，与 private 类似，区别是可以被子类继承，可以被其自身以及继承的子类访问，但是不能被对象访问，只能通过封装的方式让对象访问

4.8.6 构造方法

构造方法可以在对象实例化时自动运行，作用是：1，创建实例的初始化状态；2，可以给私有/受保护的属性初始化赋值。

构造方法必须是公共方法（public）。

定义构造方法关键字：__construct 

  1. class User
  2. {
  3.   // 成员属性
  4.   public $name;
  5.   private $salary;
  6.   protected $age;
  8.   public function __construct($salary, $age)
  9.   {
  10.     // $this代表本对象
  11.     $this->salary = $salary;
  12.     $this->age = $age;
  13.   }
  15.   // 成员方法
  16.   public function salary()
  17.   {
  18.     return $this->salary;
  19.   }
  20. }
  22. // 实例化时自动调用构造方法，将传入的参数赋值给属性 $salary, $age
  23. $mj = new User($salary, $age);
  24. // 属性 $name 没有在构造方法中赋值，需要手动赋值
  25. $mj->name = $name;
4.8.7 对象的继承

继承的好处：

  • 父类里面定义的类成员可以不用在子类中重复定义，节约了编程的时间和代价;
  • 同一个父类的子类拥有相同的父类定义的类成员，因此外部代码调用他们的时候可以一视同仁;
  • 子类可以修改和调用父类定义的类成员我们称为重写（Overwrite）, 一旦子类修改了，就按照子类修改之后的功能执行;

子类：

  • 子类可以通过$this访问父类的属性
  • 子类的对象可以直接调用父类的方法和属性
  • PHP的单继承特性：类不允许同时继承多个父类（extends后面只能跟一个父类名称）
  • 子类可以扩展自己的属性和方法
  • 通过 extends 关键字实现类的继承
  1. // 父类
  2. class Product
  3. {
  4.   public $name;
  5.   protected $price;
  6.   protected $num;
  8.   public function __construct($name, $price, $num)
  9.   {
  10.     $this->name = $name;
  11.     $this->price = $price;
  12.     $this->num = $num;
  13.   }
  15.   // 普通方法
  16.   public function show()
  17.   {
  18.     // 特殊的对象引用 完成对象成员间的互相访问
  19.     // 注意：界定符结尾标记必须顶行写，前面不能有任何输出，否则出错！
  20.     // 界定符结尾标记后面也不能有注释
  21.     return <<<SHOW
  22.       1. 品名：$this->name
  23.       2. 价格：$this->price
  24.       3. 数量：$this->num
  25. SHOW;
  26.   }
  27. }
  29. // 子类
  30. class Son extends Product
  31. {
  32.   // 扩展
  33.   public $brand;
  35.   // overwrite 重写
  36.   public function __construct($name, $price, $num, $brand)
  37.   {
  38.     // parent:: 调用父类成员
  39.     parent::__construct($name, $price, $num);
  40.     $this->brand = $brand;
  41.   }
  43.   // 重写show方法
  44.   public function show()
  45.   {
  46.     return <<<SHOW
  47.       1. 品名：$this->name
  48.       2. 价格：$this->price
  49.       3. 数量：$this->num
  50.       4. 品牌：$this->brand
  51. SHOW;
  52.   }
  54.   // 功能扩展
  55.   public function total()
  56.   {
  57.     return "$this->name,数量为{$this->num},总计" . ($this->price * $this->num) . '元';
  58.   }
  59. }
  61. // 子类实例化及调用成员
  62. $son1 = new Son('四件套', 289, 400, '法系');
  63. echo $son1->brand;  // 法系
  64. echo $son1->show();  // 1. 品名：四件套 2. 价格：289 3. 数量：400 4. 品牌：法系
  65. echo $son1->total();  // 四件套,数量为400,总计115600元
4.8.8 属性重载和方法重载
  • PHP所提供的”重载”（overloading）是指动态地”创建”类属性和方法。我们是通过魔术方法（magic methods）来实现的。
  • 当调用当前环境下未定义或不可访问的类属性或方法时，重载方法会被调用。
  • 所有的重载方法都必须被声明为 public
  • 注意: PHP中的”重载”与其它绝大多数面向对象语言不同。传统的”重载”是用于提供多个同名的类方法，但各方法的参数类型和个数不同。
  1. class View
  2. {
  3.   /**
  4.    * 模板变量
  5.    */
  6.   protected $data = [];
  8.   // !当访问当前环境下未定义或不可访问的类属性时 ，重载方法__get会被调用。
  9.   public function __get($name)
  10.   {
  11.     return $this->data[$name];
  12.   }
  14.   // !当给当前环境下未定义或不可访问的类属性赋值时 ，重载方法__set会被调用。
  15.   public function __set($name, $value)
  16.   {
  17.     $this->data[$name] = $value;
  18.   }
  20.   // 自定义的赋值方法优先级大于 __set
  21.   public function assign($name, $value = null)
  22.   {
  23.     if (is_array($name)) {
  24.       // array_merge() 将一个或多个数组中的值附加在前一个数组的后面。返回作为结果的数组
  25.       $this->data = array_merge($this->data, $name);
  26.     } else {
  27.       $this->data[$name] = $value;
  28.     }
  30.     return $this;
  31.   }
  33.   // !当访问当前环境下未定义或不可访问的类普通方法时 ，重载方法__call会被调用。
  34.   public function __call($name, $args)
  35.   {
  36.     if ($name == 'show') {
  37.       var_dump($this->data);
  38.     } else if ($name == 'sum') {
  39.       return array_sum($args);
  40.     } else {
  41.       echo '没有这个方法';
  42.     }
  44.   }
  45. }
  47. $v = new View;
  48. // 调用 __set 方法，给未定义属性赋值
  49. $v->username = 'peter';
  50. // 调用 __get 方法，访问未定义属性
  51. echo $v->username;  // peter
  52. // 自定义的赋值方法优先级大于 __set
  53. $v->assign('username', 'admin');
  54. echo $v->username;  // admin
  56. // 调用 __call 方法，访问未定义方法
  57. $v->hello();  // 没有这个方法
  58. // show()、sum() 方法不可以直接访问，通过 __call 方法访问
  59. $v->show();  // array(1) { ["username"]=> string(5) "admin" } 
  60. echo $v->sum(10, 20, 60);  // 90
  62. // 通过回调方法访问 __call 方法
  63. echo call_user_func([$v, 'sum'], 10, 20, 40);  // 70
  64. echo call_user_func_array([$v, 'sum'], [10, 20, 80]);  // 110
4.8.9 类的自动加载器

定义类加载器文件 autoload.php

  1. // autoload.php
  2. spl_autoload_register(function ($className) {
  3.   $classFile = __DIR__ . DS . 'class' . DS . $className . '.php';
  4.   if (is_file($classFile) && file_exists($classFile)) require $classFile;
  5. });

在页面引入加载器，不用一个一个 require 所需的 class 文件

  1. const DS = DIRECTORY_SEPARATOR;
  2. require __DIR__ . DS . 'autoload.php';
  4. // 接下来用到的类都会自动加载
  5. $mj = new User($salary, $age);
  6. $i = new Product('iphone 12 promax', 6000, 12);
  7. $son1 = new Son('四件套', 289, 400, '法系');
【本文由：武汉网页开发公司 http://www.1234xp.com/wuhan.html 复制请保留原URL】
更多阅读