面向过程和面向对象

1. 历史因素

  • 只要是高级编程语言，面向对象永远都是绕不开的话题。早期的编程都是为了追求速度，而没有考虑可理解性和可扩展性。现在我们考虑的更多是可维护性和重用性。
  • PHP2：PHP其实一开始也没考虑对象，他是PHP的创建者们后来才想要引进的，PHP起源于Rasmus Lerdorf用Perl开发的两个工具，这时候PHP是 Personal Homepage Tool的简写，意为“个人主页工具”，而FI就是 From Interpreter“表单解释器”。只是用来处理表单数据到数据库，简单的控制下流程。
  • PHP3：此时PHP还是没有加入对类的支持. 1997.8.27 加入的
  • PHP4：算是PHP比较重大的改变，此时PHP的大部分核心代码都被重写了。Zend引擎开始为PHP提供助力
  • PHP5：PHP开始拥抱未来，支持了面向对象的程序设计
  • PHP7：弱语言类型也可以声明变量的类型，效率也大大提升了

2. 面向过程

我们用编写的程序来完成一件事/一个功能，需要哪些功能就建立哪些函数。管理起来非常混乱

3. 面向对象

我们不在仅仅只是想着去完成这件事就好了，将需要完成的事情分配给对象，每个对象各司其职。对象是执行者，干事的还是函数。这样我们可以更好的描述在解决问题和完成这件事中的行为，明显更符合人的思维习惯，同时也大大提升了代码的重用性和扩展性。

对象基础

1. 类和对象

  • 类：人类、车、宠物，我们可以按照人的划分习惯，将某一些具有相同特性的都是抽象化，这就是类。这就像是一个集合的概念。
  • 对象：是类的实例，比如人有很多，有人叫张三有人叫李四，他可能就有唯一一张ID卡，我们根据某些特性将类中的集合分离成一个个，对象是个体的概念。

1.1 最简单的类和对象

  1. <?php
  3. // 如，我们可以编写出一个，最简单的类
  4. class ShopProduct
  5. {
  6.     // 类体
  7. }
  8. // 对象
  9. $product1 = new ShopProduct();
  10. $product2 = new ShopProduct();
  12. // 我很好奇这样一个几乎为空的对象有什么
  13. var_dump($product1); // object(ShopProduct)[1]
  14. // 除了告诉我这个一个对象，和是谁创建的模板也没啥了，哈哈

1.2 设置属性

  1. <?php
  2. class ShopProduct
  3. {
  4.     // 此时，我们设置了4个属性
  5.     public $title = 'default product';
  6.     public $producerMainName = 'main name';
  7.     public $producerFirstName = 'first name';
  8.     public $price = 0;
  9. }
  11. // 访问其中的 title 属性
  12. print ((new ShopProduct)->title) . '<br>'; // default product
  14. // 也可以设置 属性的值
  15. $product1 = new ShopProduct();
  16. $product1->title = 'My Antonia';
  17. var_dump($product1);
  19. /*
  20. object(ShopProduct)[2]
  21.   public 'title' => string 'My Antonia' (length=10)
  22.   public 'producerMainName' => string 'main name' (length=9)
  23.   public 'producerFirstName' => string 'first name' (length=10)
  24.   public 'price' => int 0
  26. */
  28. // 实际上PHP没有强制所有属性都必须在类中声明,我们也可以动态的给对象添加属性
  29. $product1->arbitaryAddition = 'treehouse';
  30. var_dump($product1);
  31. // 但这并不是一个好的习惯，我们几乎不用。动态添加的属性可能会遇到种种问题。
  33. /*
  34. object(ShopProduct)[1]
  35.   public 'title' => string 'My Antonia' (length=10)
  36.   public 'producerMainName' => string 'main name' (length=9)
  37.   public 'producerFirstName' => string 'first name' (length=10)
  38.   public 'price' => int 0
  39.   public 'arbitaryAddition' => string 'treehouse' (length=9)
  40. */

1.3 设置方法

  1. <?php
  2. class ShopProduct
  3. {
  4.     public $title = 'default product';
  5.     public $producerMainName = 'main name';
  6.     public $producerFirstName = 'first name';
  7.     public $price = 0;
  9.     // 这里我们并没有添加，访问权限符号，因为默认的就是 public
  10.     function getProducer()
  11.     {
  12.         return $this->producerMainName . '_' . $this->producerFirstName;
  13.     }
  14. }
  16. $product1 = new ShopProduct();
  17. echo $product1->getProducer() . '<br>'; // main name_first name

1.4 设置构造函数

  1. <?php
  2. class ShopProduct
  3. {
  4.     public $title;
  5.     public $producerMainName;
  6.     public $producerFirstName;
  7.     public $price = 0;
  9.     /**
  10.      * 我们添加构造方法,创建对象时构造方法会被自动调用。
  11.      * PHP5之前，构造方法使用和类相同的名字，像是java一样。
  12.      * 但现在我们一般, __construct()
  13.      **/
  14.     public function __construct($title, $firstName, $mianName, $price)
  15.     {
  16.         $this->title = $title;
  17.         $this->producerFirstName = $firstName;
  18.         $this->producerMainName = $mianName;
  19.         $this->price = $price;
  20.     } 
  23.     public function getProducer()
  24.     {
  25.         return $this->producerMainName . '_' . $this->producerFirstName;
  26.     }
  27. }
  29. $procuct1 = new ShopProduct('My Antonia', 'Willa', 'Cather', 5.99);
  30. var_dump($procuct1);
  31. /*
  32. object(ShopProduct)[1]
  33.   public 'title' => string 'My Antonia' (length=10)
  34.   public 'producerMainName' => string 'Cather' (length=6)
  35.   public 'producerFirstName' => string 'Willa' (length=5)
  36.   public 'price' => float 5.99 
  37. */

1.5 PHP中的基本数据类型

  • 数据类型：PHP中也有八大基本数据类型，我也已经实在是不想写了。权当复习
    • 布尔型 boolead is_bool()
    • 整形 integer is_integer()
    • 浮点型 float is_double()
    • 字符型 strting is_string()
    • 数组 array is_array()
    • 对象 object is_object()
    • 资源 resource is_resource()
    • 空类型 null is_null()

1.6 继承

  • 继承是一从一个基类获取到更多派生类的机制
  • 基类也叫做父类，继承基类的就是子类，子类就可以增加父类之外的功能，这就是扩展性
  1. <?php
  2. // 如果我们有两种产品，我们将所有的属性都设置在一个类中，会显得十分臃肿。如下
  3. class ShopProduct
  4. {
  5.     public $numPages;
  6.     public $playLength;
  7.     public $title;
  8.     public $producerMainName;
  9.     public $producerFirstName;
  10.     public $price;
  12.     function __construct($title, $firstName, $mianName, $price, $numPages = 0, $playLength = 0)
  13.     {
  14.         $this->title = $title;
  15.         $this->producerFirstName = $firstName;
  16.         $this->producerMainName = $mianName;
  17.         $this->price = $price;
  18.         $this->numPages = $numPages;
  19.         $this->playLength = $playLength;
  20.     }
  22.     function getNumberOfPages()
  23.     {
  24.         return $this->numPages;
  25.     }
  27.     function getPlayLength()
  28.     {
  29.         return $this->playLength;
  30.     }
  32.     function getProducer()
  33.     {
  34.         return $this->producerFirstName . $this->producerMainName;
  35.     }
  36. }
  1. <?php
  2. // 如果分开变成两个类，就会发现解决了不存在的属性。但是大量的代码重复还是让人感觉不是很愉快
  3. class cdProduct
  4. {
  5.     public $playLength;
  6.     public $title;
  7.     public $producerFirstName;
  8.     public $producerMainName;
  9.     public $price;
  11.     function __construct($title, $firstName, $mianName, $price, $playLength)
  12.     {
  13.         $this->title = $title;
  14.         $this->producerFirstName = $firstName;
  15.         $this->producerMainName = $mianName;
  16.         $this->price = $price;
  17.         $this->playLength = $playLength;
  18.     }
  20.     function getPlayLength ()
  21.     {
  22.         return $this->playLength;
  23.     }
  25.     function getSummaryLine()
  26.     {
  27.         $base = "{$this->title} | {$this->producerMainName} , ";
  28.         $base .= "{$this->producerFirstName} , ";
  29.         $base .= ": playing time - {this->playLength}";
  30.         return $base; 
  31.     }
  33.     function getProducer()
  34.     {
  35.         return $this->producerFirstName . $this->producerMainName;
  36.     }
  38. }
  40. class BookProduct 
  41. {
  42.     public $numPages;
  43.     public $title;
  44.     public $producerMainName;
  45.     public $producerFirstName;
  46.     public $price;
  48.     function __construct($numPages, $title, $firstName, $mianName, $price)
  49.     {
  50.         $this->numPages = $numPages;
  51.         $this->title = $title;
  52.         $this->producerFirstName = $firstName;
  53.         $this->producerMainName = $mianName;
  54.         $this->price = $price;
  55.     }
  57.     function getNumberOfPages()
  58.     {
  59.         return $this->numPages;
  60.     }
  62.     function getSummaryLine()
  63.     {
  64.         $base = "{$this->title} | {$this->producerMainName} , ";
  65.         $base .= "{$this->producerFirstName} , ";
  66.         $base .= ": playing time - {this->playLength}";
  67.         return $base; 
  68.     }
  70.     function getProducer()
  71.     {
  72.         return $this->producerFirstName . $this->producerMainName;
  73.     }
  74. }
  1. <?php
  3. // 使用继承 - 父类产品
  4. class ShopProduct
  5. {
  6.     public $numPages;
  7.     public $playLength;
  8.     public $title;
  9.     public $producerMainName;
  10.     public $producerFirstName;
  11.     public $prrice;
  13.     function __construct($numPages = 0, $title, $playLength = 0, $firstNmae, $mianName, $price)
  14.     {
  15.         $this->title = $title;
  16.         $this->numPages = $numPages;
  17.         $this->producerFirstName = $firstNmae;
  18.         $this->producerMainName = $mianName;
  19.         $this->playLength = $playLength;
  20.         $this->price = $price;
  21.     }
  23.     function getProducer()
  24.     {
  25.         return $this->producerFirstName . $this->producerMainName;
  26.     }
  28.     function getSummaryLine()
  29.     {
  30.         return $this->title . ':' .
  31.             $this->producerMainName . ',' .
  32.             $this->producerFirstName;
  33.     }
  34. }
  36. // 子类-cd
  37. class CdProduct extends ShopProduct
  38. {
  40.     function getPlayLength()
  41.     {
  42.         return $this->playLength;
  43.     }
  45.     function getSummaryLine()
  46.     {
  47.         return $this->title . ':' .
  48.             $this->producerMainName . ','  .
  49.             $this->producerFirstName . ',' .
  50.             $this->playLength;
  51.     }
  52. }
  54. // 子类书
  55. class BookProduct extends ShopProduct
  56. {
  57.     function getNumberOfPages()
  58.     {
  59.         return $this->numPages;
  60.     }
  62.     function getSummaryLine()
  63.     {
  64.         return $this->title . ':' .
  65.             $this->producerMainName . ','  .
  66.             $this->producerFirstName . ',' .
  67.             $this->numPages;
  68.     }
  69. }
  71. // 两个子类都会继承父类中的公共部分
  • 在子类中定义构造方法时需要传递参数给父类的构造方法，否则你得到的可能是一个不完整的对象
  • 子类调用父类的方法，使用parent 关键字 parent::__construct();
  • 我们依照parent关键字去添加子类的构造函数，并且从新改造父类和子类。
    • 我们通常把子类会用到的相同的属性提取到父类
    • 子类再去创建自己独有的属性，因为子类也可以访问到父类的属性
  1. <?php
  2. class ShopProduct
  3. {
  4.     public $title;
  5.     public $producerMainName;
  6.     public $producerFirstName;
  7.     public $prrice;
  9.     function __construct($title,$firstNmae, $mianName, $price)
  10.     {
  11.         $this->title = $title;
  12.         $this->producerFirstName = $firstNmae;
  13.         $this->producerMainName = $mianName;
  14.         $this->price = $price;
  15.     }
  17.     function getProducer()
  18.     {
  19.         return $this->producerFirstName . $this->producerMainName;
  20.     }
  22.     function getSummaryLine()
  23.     {
  24.         return $this->title . ':' .
  25.             $this->producerMainName . ',' .
  26.             $this->producerFirstName;
  27.     }
  28. }
  30. class CdProduct extends ShopProduct
  31. {
  33.     public $playLength;
  35.     function __construct($title,$firstNmae, $mianName, $price, $playLength)
  36.     {
  37.         parent::__construct($title,$firstNmae, $mianName, $price);
  38.         $this->playLength = $playLength;
  39.     }
  41.     function getPlayLength()
  42.     {
  43.         return $this->playLength;
  44.     }
  46.     function getSummaryLine()
  47.     {
  48.         return $this->title . ':' .
  49.             $this->producerMainName . ','  .
  50.             $this->producerFirstName . ',' .
  51.             $this->playLength;
  52.     }
  53. }
  55. class BookProduct extends ShopProduct
  56. {
  57.     public $numPages;
  59.     function __construct($title,$firstNmae, $mianName, $price, $numPages)
  60.     {
  61.         parent::__construct($title,$firstNmae, $mianName, $price);
  62.         $this->numPages = $numPages;
  63.     }
  65.     function getNumberOfPages()
  66.     {
  67.         return $this->numPages;
  68.     }
  70.     function getSummaryLine()
  71.     {
  72.         return $this->title . ':' .
  73.             $this->producerMainName . ','  .
  74.             $this->producerFirstName . ',' .
  75.             $this->numPages;
  76.     }
  77. }
  • 此时，结构清晰了很多，但我们还是发现，子类和父类还是有 getSummaryLine()这个方法
  • 重写这个方法是我们也 用上 parent 关键字
  1. <?php
  2. class ShopProduct
  3. {
  4.     public $title;
  5.     public $producerMainName;
  6.     public $producerFirstName;
  7.     public $prrice;
  9.     function __construct($title, $firstNmae, $mianName, $price)
  10.     {
  11.         $this->title = $title;
  12.         $this->producerFirstName = $firstNmae;
  13.         $this->producerMainName = $mianName;
  14.         $this->price = $price;
  15.     }
  17.     function getProducer()
  18.     {
  19.         return $this->producerFirstName . $this->producerMainName;
  20.     }
  22.     function getSummaryLine()
  23.     {
  24.         return $this->title . ':' .
  25.             $this->producerMainName . ',' .
  26.             $this->producerFirstName;
  27.     }
  28. }
  30. class CdProduct extends ShopProduct
  31. {
  33.     public $playLength;
  35.     function __construct($title, $firstNmae, $mianName, $price, $playLength)
  36.     {
  37.         parent::__construct($title, $firstNmae, $mianName, $price);
  38.         $this->playLength = $playLength;
  39.     }
  41.     function getPlayLength()
  42.     {
  43.         return $this->playLength;
  44.     }
  46.     function getSummaryLine()
  47.     {
  48.         $base = parent::getSummaryLine();
  49.         return $base . 'playing time:' . $this->playLength;
  50.     }
  51. }
  53. class BookProduct extends ShopProduct
  54. {
  55.     public $numPages;
  57.     function __construct($title, $firstNmae, $mianName, $price, $numPages)
  58.     {
  59.         parent::__construct($title, $firstNmae, $mianName, $price);
  60.         $this->numPages = $numPages;
  61.     }
  63.     function getNumberOfPages()
  64.     {
  65.         return $this->numPages;
  66.     }
  68.     function getSummaryLine()
  69.     {
  70.         $base = parent::getSummaryLine();
  71.         return $base . 'number of pages:' . $this->numPages;
  72.     }
  73. }

1.7 类的访问管理

  • 三种基本的权限访问修饰符

    • public：公共的，任何地方都可以访问public修饰的属性和方法
    • protected：受保护的，只有当前类和子类才可以访问
    • private：私有的，只有当前类才可以访问，子类也不可以访问

  • 小技巧

    • private 、 protectedt 通常是用来保护用的，我们通常用 private 来修饰属性让外部无法去更改，从而达到保护的作用
    • 简而言之，有些类方法和类属性本身只为该类提供方法，不对外提供，我们就应该设置权限为 private 或者是protected的

  • 我们依照权限访问符，加入商品打折的属性，从写改写一下 父类和子类

  • 父类-商品类

    1. <?php
    2. class ShopProduct
    3. {   
    4.   // 私有化属性
    5.   private $title;
    6.   private $producerMainName;
    7.   private $producerFirstName;
    8.   private $discount = 1; // 1 就表示不打折
    9.   protected $prrice;
    11.   // 构造函数
    12.   public function __construct($title, $firstNmae, $mianName, $price)
    13.   {
    14.       $this->title = $title;
    15.       $this->producerFirstName = $firstNmae;
    16.       $this->producerMainName = $mianName;
    17.       $this->price = $price;
    18.   }
    20.   // 获取商品的 firstName
    21.   public function getProducerFirstName()
    22.   {
    23.       return $this->producerFirstName;
    24.   }
    26.   // 获取商品的 mainName
    27.   public function getProducerMainName()
    28.   {
    29.       return $this->producerMainName;
    30.   }
    32.   // 获取商品的title
    33.   public function getTitle()
    34.   {
    35.       return $this->title;
    36.   }
    38.   // 获取商品的价格
    39.   public function getPrice()
    40.   {
    41.       return $this->prrice;
    42.   }
    44.   // 获取折扣
    45.   public function getDisCount()
    46.   {
    47.       return $this->discount;
    48.   }
    50.   // 设置折扣
    51.   public function setDisCount($num)
    52.   {
    53.       $this->discount = $num;  
    54.   }
    56.   // getProducer
    57.   public function getProducer()
    58.   {
    59.       return $this->producerFirstName . $this->producerMainName;
    60.   }
    62.   // getSummaryLine
    63.   public function getSummaryLine()
    64.   {
    65.       return $this->title . ':' .
    66.           $this->producerMainName . ',' .
    67.           $this->producerFirstName;
    68.   }
    69. }

  • 子类-书

    1. <?php
    2. class BookProduct extends ShopProduct
    3. {
    4.   private $numPages;
    6.   function __construct($title, $firstNmae, $mianName, $price, $numPages)
    7.   {
    8.       parent::__construct($title, $firstNmae, $mianName, $price);
    9.       $this->numPages = $numPages;
    10.   }
    12.   function getNumberOfPages()
    13.   {
    14.       return $this->numPages;
    15.   }
    17.   function getSummaryLine()
    18.   {
    19.       $base = parent::getSummaryLine();
    20.       return $base . 'number of pages:' . $this->numPages;
    21.   }
    22. }

  • 子类-cd

    1. <?php
    2. class CdProduct extends ShopProduct
    3. {
    5.   private $playLength;
    7.   function __construct($title, $firstNmae, $mianName, $price, $playLength)
    8.   {
    9.       parent::__construct($title, $firstNmae, $mianName, $price);
    10.       $this->playLength = $playLength;
    11.   }
    13.   function getPlayLength()
    14.   {
    15.       return $this->playLength;
    16.   }
    18.   function getSummaryLine()
    19.   {
    20.       $base = parent::getSummaryLine();
    21.       return $base . 'playing time:' . $this->playLength;
    22.   }
    23. }

    2. 测试访问权限修饰符

    2.1 测试一 对象访问本类的非静态属性和非静态方法

    ```php <?php class Father { public $a = ‘a 属性’; protected $b = ‘b 属性’; private $c = ‘c 属性’;

    public function a() {

    1.   echo "function a <br/>";

    }

    protected function b() {

    1.   echo "function b <br/>";

    }

    private function c() {

    1.   echo "function c <br/>";

    } }

$fa = new Father(); echo $fa->a; // a 属性 // echo $fa->b; // Fatal error: Uncaught Error: Cannot access protected property Father::$b // echo $fa->c; // Fatal error: Uncaught Error: Cannot access private property Father::$c

$fa->a(); // function a // $fa->b(); // Fatal error: Uncaught Error: Call to protected method Father::b() // $fa->c(); // Fatal error: Uncaught Error: Call to private method Father::c() 

  1. <a name="ic3Vt"></a>
  2. #### 2.2 测试二  本类访问静态属性和静态方法
  3. ```php
  4. <?php
  5. class Father
  6. {
  7.     public static $a = 'a 属性';
  8.     protected static $b = 'b 属性';
  9.     private  static $c = 'c 属性';
  11.     public static function a()
  12.     {
  13.         echo "function a <br/>";
  14.     }
  16.     protected static function b()
  17.     {
  18.         echo "function b <br/>";
  19.     }
  21.     private static function c()
  22.     {
  23.         echo "function c <br/>";
  24.     }
  25. }
  27. echo Father::$a; // a 属性
  28. // echo Father::$b; // Fatal error: Uncaught Error: Cannot access protected property Father::$b 
  29. // echo Father::$c; // Fatal error: Uncaught Error: Cannot access private property Father::$c 
  31. Father::a(); // function a
  32. // Father::b(); // Uncaught Error: Call to protected method Father::b()
  33. // Father::c(); // Fatal error: Uncaught Error: Call to private method Father::c()

2.3 测试三 子类访问父类的属性和方法

  1. <?php
  2. //父类
  3. class Father
  4. {
  5.     public  $a = 'a 属性';
  6.     protected  $b = 'b 属性';
  7.     private   $c = 'c 属性';
  9.     public function a()
  10.     {
  11.         echo "function a <br/>";
  12.     }
  14.     protected function b()
  15.     {
  16.         echo "function b <br/>";
  17.     }
  19.     private function c()
  20.     {
  21.         echo "function c <br/>";
  22.     }
  23. }
  25. class Son extends Father
  26. {
  27.     public function method_1()
  28.     {
  29.         echo parent::$a . '<br>';
  30.     }
  31.     public function method_2()
  32.     {
  33.         echo parent::$b . '<br>';
  34.     }
  35.     public function method_3()
  36.     {
  37.         echo parent::$c . '<br>';
  38.     }
  40.     public function method_4()
  41.     {
  42.         parent::a();
  43.     }
  44.     public function method_5()
  45.     {
  46.         parent::b();
  47.     }
  48.     public function method_6()
  49.     {
  50.         parent::c();
  51.     }
  52. }
  54. $son = new Son();
  55. // $son->method_1(); // Fatal error: Uncaught Error: Access to undeclared static property: Father::$a
  56. // $son->method_2(); // Fatal error: Uncaught Error: Access to undeclared static property: Father::$b
  57. // $son->method_3(); // Fatal error: Uncaught Error: Cannot access private property Father::$c
  59. $son->method_4(); // function a
  60. $son->method_5(); // function b
  61. // $son->method_6(); // Fatal error: Uncaught Error: Call to private method Father::c() from context 'Son'


2.4 测试小结

  • 对象无论是访问本类的非静态的属性还是访问非静态的方法都只能访问 public ，protected和privated 都不行
    • 为什么PHP中，本类创建的对象连protected修饰的方法和属性都无法访问？
    • 这是我自己理解的问题！！！！ 使用方式就像局部变量定义，但是超出了使用范围

  • 上一条对于静态修饰的方法和属性一样适用

  • 子类使用parent 关键字只能访问父类的 public 方法和 protected方法，并不能访问非静态的属性

    • parent :: 那么对于子类访问父类的静态属性呢？
      • public 和 protected 可以访问到
      • privated 访问不到
  1. <?php
  2. class Father
  3. {
  4.     public $a = 'a 属性';
  5.     protected $b = 'b 属性';
  6.     private  $c = 'c 属性';
  8.     public function a()
  9.     {
  10.         echo "function a <br/>";
  11.     }
  13.     protected function b()
  14.     {
  15.         echo "function b <br/>";
  16.     }
  18.     private function c()
  19.     {
  20.         echo "function c <br/>";
  21.     }
  22. }
  24. class Son extends Father
  25. {
  26.     public function index()
  27.     {
  28.         $son = new Son();
  29.         $son->b(); // al
  30.     }
  31. }
  33. $son = new Son();
  34. $son->index(); // function b