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

面向对象认识

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