面向对象封装，继承，加载器

面向对象认识

• oop: (Object Oriented Progrmming)面向对象编程
• 面向过程编程: 直接面向变量和函数编程

• oop: 直接面向对象编程(封装了变量和函数的一个编程单元)

  面向过程认识

  <?php
  // 变量
  $n= 100;
  $m=200;
  // 函数
  function sum($a,$b){
    return $a+$b;
  };
  echo sum($n,$m);

• 面向对象封装

• 类的公有属性

  <?php
  // 声明的类与文件一致
  class Product
  {
    // 类成员：属性，方法
    // 属性：变量
    // public 公开指定name是公开属性（公有属性）
    public $name;
    public $price;
    // 方法：函数
    // 构造方法 
    // 双下划线的方法：魔术方法，由系统自动调用
    // 类实例化的时候会调用它
    public function __construct($name, $price)
    {
        // 初始化类成员，让类实例化确定下来
        //this $当前类实例的引用
        $this->name = $name;
        $this->price = $price;
        // 不用return返回
    }
    public function show(): string
    {
        return "$this->name : $this->price 元";
    }
  }

• 类的公有属性面向对象实例

  <?php
  <?php
  // 导入文件
  require 'Product.php';
  $moblie=new Product('电脑',888);
  echo $moblie->name;
  echo '<hr>';
  var_dump($moblie);

• 受保护的私有属性

<?php
// 声明的类与文件一致
class Product
{
    // 类成员：属性，方法
    // 属性：变量
   //protected: 受保护成员,仅限本类以及子类访问
    protected $name;
    protected $price;
    // 方法：函数
    // 构造方法 
    // 双下划线的方法：魔术方法，由系统自动调用
    // 类实例化的时候会调用它
    public function __construct($name, $price)
    {
        // 初始化类成员，让类实例化确定下来
        //this $当前类实例的引用
        $this->name = $name;
        $this->price = $price;
        // 不用return返回
    }
    public function show(): string
    {
        return "$this->name : $this->price 元";
    }
}

• 实例化访问受保护的私有方法

  <?php
  // 导入文件
  require 'Product.php';
  $moblie=new Product('手机',888);
  echo $moblie->show();

• 本质是: 封装
• 目标是: 代码复用
  类的加载器
• 相当于中介

  <?php
  // 类的自动加载
  spl_autoload_register(function($class){
    require $class.'.php';
  });

  在加载器中引入，访问实例化类的方法

  <?php
  // 类的自动加载器
  require 'loader.php';
  // 实例化
  $snack = new Product('冰块',11);
  echo $snack->show();

  静态属性与静态方法
• 静态属性：类中成员并非全部都要使用”类实例’方法,也有可以用”类”访问的成员

<?php
class Staff{
    // 静态属性
    public static $name;
    public static $id;
    // 构造函数
    public function __construct($name,$id)
    {
        self::$name = $name;
        self::$id = $id;
    }
    // 静态方法
    public static function show(){
        return sprintf('%s, 这个月工资: %d', self::$name, self::$id);
    }
}

<?php
require 'loader.php';
$staff = new Staff('刘五',66);
// 访问类的静态属性
echo Staff::$name;
echo' <hr>';
// 访问类的静态方法
echo Staff::show();
echo' <hr>';
// 访问实例的静态方法
echo $staff->show();
// 不能访问实例的静态属性

继承

• 父类

  <?php
  // 声明的类与文件一致
  class Product
  {
    // 类成员：属性，方法
    // 属性：变量
   //protected: 受保护成员,仅限本类以及子类访问
    protected $name;
    protected $price;
    // 方法：函数
    // 构造方法 
    // 双下划线的方法：魔术方法，由系统自动调用
    // 类实例化的时候会调用它
    public function __construct($name, $price)
    {
        // 初始化类成员，让类实例化确定下来
        //this $当前类实例的引用
        $this->name = $name;
        $this->price = $price;
        // 不用return返回
    }
    public function show(): string
    {
        return "$this->name : $this->price 元";
    }
  }

• 子类

<?php
require 'loader.php';
// sub继承product类
class Sub extends Product{
    // 对父类方法重写
    // 对父类的功能的扩展
    #子类构造器
    private $num;
    public function __construct($name,$price,$num)
    {
        // 调用父类构造方法
        parent::__construct($name,$price);
        // 添加子类构造方法
        $this ->num = $num;
    }
    // 输出方法
    public function show():string
    {
        // parent调用父类方法
        return parent::show().", 数量: $this->num 个";
    }
    // 子类里面定义新的方法，与show无关系
    public function total()
    {
        return "$this->name, 总计: ". ($this->price * $this->num) . ' 元';
    }
}

-实例化

<?php
require 'loader.php';
// 20是子类继承父类添加的方法
// 实例化子类sub
$sub =new Sub('好面包',40,20);
echo $sub->show();
echo '<hr>';
// 重新定义的方法，与父类无关系
echo $sub->total();

• trait类的方法集，单继承子类可以从trait引入方法进行继承

<?php
// 当父类,trait,与当前子类中存在同名成员的如何解决?
// 父类
class P 
{
    public function m1()
    {
        return __METHOD__;
    }
}
# trait像类不是类，想当于中介
trait T
{
    // public function m1()
    // {
    //     return __METHOD__;
    // }
}
// 子类
class A extends P
{
    use T;
    // 在子类中将父类的m1进行了重写
    // public function m1()
    // {
    //     return __METHOD__;
    //     // return parent::m1();
    // }
}
// 当子类与父类存在同名成员时,子类优先
echo (new A)->m1(), '<br>';
// 当trait中存在与父类同名的成员时,trait优先
// own > trait > parent