实践学习php，thinkphp，Redis，vue，uni-app等技术，推荐开源电商系统likeshop，可以借鉴思路，可去版权免费商用，gitee下载地址：
点击进项目地址

面向对象：OOP（objected oriented programming）编程

面向过程是一种编程思想

面向对象编程的本质是增加数据和功能的操作主体，即对象

面向对象中的所有的数据和功能多是由主体（对象）来调用和操作

面向对象基础

面向过程和面向对象区别

面向对象关键字

• 类：class，定义面向对象主体的最外层结构，用来包裹主体的数据和功能（函数）
• 对象：object，某类事务的具体代表，又称为实例
• 实例化：new，类产生对象的过程
• 类成员：member
  • 方法：method，本质是在类class结构中创建的函数，称之为成员方法或者成员函数
  • 属性：property，本质是在类class结构中创建的变量，称之为成员变量
  • 类常量：const，本质是在类class结构中创建的常量

创建对象

?phpclass People{
}
    $man=new People();
    # 实例化类，man就是对象var_dump($man);
    ?>

    # 输出object(People)#1 (0) {
 }

    #1表示：对象编号，与类无关，是整个脚本中对象的序号(0)表示：成员变量（属性）个数{
}
表示：具体成员变量信息（键值对）

类对象

?phpclass Buyer{
    
    # 常量声明
    const BIG_NAME='BUYER';
    
    # 常量不需要加 $

    # 属性声明
    # $name;
    
    # 错误的，类内部属性必须使用访问修饰限定符
    public $name;
    
    public $money=0;

    
    # 方法声明
    function display(){
    
        echo __CLASS__;

        # 魔术常量，输出类名
        # 方法内部变量属于局部变量
    }
}
    # 实例化$a = new Buyer();
    # 属性操作，增删改查echo $a->
    money;
    $a->
    money='20';
    $a->
    sex='male';
    unset($a->
    name);
    echo 'br>
    ';
    # 方法操作$a->
    display();
    echo 'br>
    ';
    var_dump($a);
    ?>

    # 输出0Buyerobject(Buyer)#1 (2) {
     ["money"]=>
     string(2) "20" ["sex"]=>
 string(4) "male" }

注意：类常量不是由对象来进行访问

访问修饰限定符

在属性或者方法前的修饰关键字，用来控制属性或者方法的访问位置

• public：公有，类内和类外都可以访问
• protected：受保护，只允许在相关类内部访问
• private：私有，只允许在定义类内部访问

属性必须有访问修饰限定符，方法可以没有访问修饰限定符，默认就是 public

类内部对象

$this，方法内部内置的一个对象，会自动指向来调用的方法的对象

$this 存在于方法内部（仅限内部使用），所以相当于在类的结构内部

• 可以访问任意访问修饰限定符修饰的成员
• 私有成员都是通过公有方法来实现访问（公有方法可以在类外部访问）

?phpclass Article{
    
    protected $name = 'a';
    
    private $type = 'art';


    public function get_name()
    {
    
        var_dump($this);

    }
}
    $a = new Article();
    var_dump($a);
    ?>

    # 输出object(Article)#1 (2) {
     ["name:protected"]=>
     string(1) "a" ["type:private"]=>
 string(3) "art" }

$this 代表的是对象，而 $this 所在环境为类内部的方法内部，所以 $this 对象是在类内部访问，因此所有的属性和方法，不受访问修饰限定符限制

构造方法

• __construct() 是一种系统内置的魔术方法，该方法的特性是在对象实例化之后，对象立即自动调用

• 构造方法的目的就是为了初始化资源，包括对象属性和其他资源

• 一旦构造方法定义好后，且构造方法自带参数，那么就只能使用 new 类名(参数列表) 方式才能正确实例化

• 魔术方法也可以通过对象直接调用的方式调用，不过没有实际用处

?phpclass Article{
    
    public $name='xiaoli';
    
    private $sex="male";


    public function __construct($name,$sex)
    {
    
        $this->
    name = $name;
    
        $this->
    sex = $sex;

    }
}
    $a = new Article('xiaowang', 'famale');
    var_dump($a);
    ?>

析构方法

• __destruct()，对象在被销毁时自动调用，释放资源
• 对象销毁
  1. 对象无变量指向（变量指向其他数据）
  2. 对象被主动销毁（unset销毁对象变量）
  3. 脚本执行结束（自动释放资源）
• PHP 脚本执行结束会释放所有资源，所以一般较少用析构方法

?phpclass Article{
    
    protected $name = 'xiaoli';
    
    private $sex = 'famale';


    public function __destruct()
    {
    
        // TODO: Implement __destruct() method.
        echo __FUNCTION__;

    }
}
    $a=new Article();
    # 销毁对象$a=1;
    unset($a);
    # __destructendecho 'end';
    ?>

    # 不销毁对象，php在运行结束也会释放资源# end__destruct

对象传值

定义：将保存对象的变量赋值给另外一个变量

在 PHP 中，对象的传值是引用传递：即一个对象变量赋值给另外一个变量，两个变量指向同一个对象地址，即只有一个对象

?phpclass Article{
    
    public $name = 'xiaoli';
    
    public $sex = 'famale';
}
    $a=new Article();
    $b=$a;
    var_dump($a,$b);
    echo 'br>
    ';
    $a->
    name="wangxiaohu";
    var_dump($a,$b);
    echo 'br>
    ';
    ?>

    # 输出object(Article)#1 (2) {
     ["name"]=>
     string(6) "xiaoli" ["sex"]=>
 string(6) "famale" }
 object(Article)
    #1 (2) {
     ["name"]=>
     string(6) "xiaoli" ["sex"]=>
 string(6) "famale" }
object(Article)
    #1 (2) {
     ["name"]=>
     string(10) "wangxiaohu" ["sex"]=>
 string(6) "famale" }
 object(Article)
    #1 (2) {
     ["name"]=>
     string(10) "wangxiaohu" ["sex"]=>
 string(6) "famale" }

范围解析操作符（类常量访问）

有两个冒号组成 “::” ，专门用于类实现类成员操作，可以实现类直接访问类成员

• 范围解析操作符是用于给类（类名）访问类成员使用的

  类名::类成员

• 范围解析操作符也可以被对象用来当作类使用（不建议）

  $对象名::类成员

• 类常量只能被类访问

?phpclass Article{
    
    const  NAME='ocean';
}
    echo Article::NAME;
    
    # 常量是不能通过 Article->
    NAME 来进行访问的$a=new Article();
    echo $a::NAME;
    
    # 范围解析操作符兼容对象，找到对象所属类最终进行访问，效率降低，灵活性提高?>

类常量是固定的，而对象的属性是不同对象不同的

静态成员

定义：使用 static 关键字修饰的类成员，表示该成员属于类访问

• 静态成员
  • 静态属性
  • 静态方法
• 静态成员是明确用来给类访问的，而不是对象
• 静态成员只是多了一个 static 关键字修饰，本身也可以被对象访问
• 静态成员同样可以使用不同的访问修饰限定符限定，效果一致

?phpclass Article{
    
    public static $name = 'hlm';
    
    public static $type = 'art';


    public static function getName()
    {
    
        return self::$name;

    }
}
    # 静态属性$a = new Article();
    echo Article::$name;
    # 静态方法echo Article::getName();
    ?>

self关键字

• 在类的内部（方法里面）使用，代替类名的写法
• self 如同 $this 代表内部对象一样，能够在方法内部代替当前类名
• 能够保障用户方便修改类名字
• self 关键字是代替类名，所以需要配合范围解析操作符 ::

?phpclass Article{

    public static function getInstance1()
    {
    
        return new self();

    }


    public static function getInstance2()
    {
    
        return new Article();

    }
}
    $a = Article::getInstance1();
    $b = Article::getInstance2();
    var_dump($a,$b);
    ?>

    # 输出object(Article)
    #1 (0) {
 }
 object(Article)
    #2 (0) {
 }

类加载

类的访问必须保证类在内存中已经存在，所以需要再用类之前将类所在的 PHP 文件加载到内存中

• 类的加载分为两种

  • 手动加载：在需要使用类之间通过 include 将包含类的文件引入到内存
  • 自动加载：提前定义好类结构和位置，写好引入类文件代码，在系统需要类而内存不存在的时候想办法让写好的加载类的代码执行（自动加载是自动运行写好的加载类的代码）

• 自动加载两种方式

  • 魔术函数 __autoload：系统自动调用，需要传入类名，在函数内部实现类的手动加载（PHP7及之后不建议使用此方法）

  function __autoload($classname){
  
      # 找到对应的文件路径和命名规范，手动加载}
  

  • 自定义函数：自己定义类的加载实现，然后通过 spl_autoload_register 注册到自动加载机制（可注册多个自动加载）

  # 自定义类加载函数function 自定义函数($classname){
  
      # 找到对应的文件和命名规范，手动加载}
  #注册自动加载sql_autoload_register('自定义函数名字')

自动加载要求在声明类的时候有良好的规范

• 类名与文件名一致：类名.php 或者 类名.class.php
• 类文件分类放好

例：手动加载

Article.php

?phpclass Article{

    public function getName(){
    
        return __METHOD__;

    }
}
    

mian.php

?php# include 'Article.php';
# 直接加载比较消耗资源，而且如果类已经在内存中存在，直接include会报错，建议判断后再加载if(!class_exists('Article')){
    
    include 'Article.php';
}
    $a=new Article();
    var_dump($a->
    getName());

    # outputstring(16) "Article::getName"

自动加载

• __autoload（不建议使用）

一个系统中，可能类文件会放到不同的路径下，因此一个完整的自动加载函数，应该要进行文件判定功能

?php
function __autoload($classname){
    
    # 形参代指 类名
    #组织文件路径，假设当前路径下，有两个文件夹下都有类c和类m
    $c_file = 'c/' . $classname . '.php';

    if (file_exists($c_file)) {
    
        include_once($c_file);
    
        return true;

    }
 
    //if 语句如果只有一行不需要加 {
}
    
    //include_once 只加载一次

    $m_file = 'm/' . $classname . '.php';

    if (file_exists($m_file)) {
    
        include_once($m_file);
    
        return true;

    }

}
    


$a=new Article();
    
$b=new Article();

• spl_autoload_register

?phpfunction autoload01($classname){

    if(!class_exists($classname)){
    
        $file_name=$classname.'.php';
    
        if(file_exists($file_name)) include_once $file_name;

    }
}
    spl_autoload_register('autoload01');
    $a=new Article();

对象克隆

通过已有的对象复制一个新的同样的对象，但两者之间并非同一个对象

面向对象高级

面向对象三大特性

封装、继承、多态

类的封装

类的继承

inherit，子类合法拥有父类的某些权限

• 继承必须满足继承关系：即存在合理的包含关系
• 继承的本质是子类通过继承可以直接使用父类已经存在的数据和数据操作
• PHP 使用 extends 关键字表示继承

子类也称派生类

父类也称基类

# 父类class Human{
}
# 子类继承class Man extends Human{
}

类的多态

多态性是指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果

• 需要发生类的继承，同时出现方法的重写（override），即子类拥有与父类同名的方法
• 在实例化对象的时候让父类对象指向子类对象（强制类型，PHP不支持，PHP 弱类型很灵活）
• 结果：父类对象表现的子类对象的特点

—PHP继承—

?phpclass Human{

    public function show(){
    
        echo __METHOD__;

    }
}
class Man extends Human{
}
    $m=new Man;
    $m->
    show();

有限继承

子类在继承父类的成员时，并非继承所有内容，而是继承并使用父类部分内容

• PHP 中继承的本质是对象继承
• PHP 中继承的内容：父类所有公有成员、受保护成员和私有属性，私有方法不能继承
• 受保护（protected）成员专于继承，可以在父类或者子类内部访问
• 私有成员的访问只能在所属类中设定公有或者受保护方法实现访问
• 构造方法和析构方法可以被子类继承，

重写 Override

override，子类中定义了与父类重名的成员

parent 关键字

一种明确访问父类成员的表达方式

方法被重写后，访问调用的是子类方法，如果想要访问父类方法，可以通过在子类方法中使用 parent 来强制访问父类方法

parent 不能用于访问父类的属性（静态属性可以）

PHP 继承特点

• PHP 只能单继承，只有一个父类（若继承多个类，可以使用链式继承）
• PHP 继承中，只有私有方法不能继承
• PHP 允许继承父类中的构造方法和析构方法

静态延迟绑定

最终类 Final

使用 final 关键字修饰类名，表示此类不可以被继承

final 关键字还能修饰方法，表示方法不能被重写（通常此时类不会使用 final 关键字）

抽象类 Abstract

使用 abstract 关键字修饰的类，表示该类只能被继承，不能被实例化

abstract 关键字可以修饰方法，表示方法为抽象方法，抽象方法没有方法体（没有{ } ）

抽象方法存在的类必须为抽象类

继承抽象类的类要么为抽象类，要么实现抽象类里所有的抽象方法

trait 代码复用

适用于，不同类之间有公共代码，但是类彼此关系不存在继承关系，此时可以将公共代码存储到 trait 中

trait 内部可以拥有一个类能拥有的成员属性（包括静态），成员方法（包括静态和抽象方法），但不能有类常量

trait 用来代码复用，不能被实例化，不能被继承

trait 同名

一个类中可能需要引入多个 trait ，而不同 trait 中可能出现同名

接口

Interface，专门用来规范一些共性类必须实现的方法

• 接口不是类，但是与类有类似的结构
• 接口不能实例化，类可以实现接口

interface 接口名字{ }

class 类名 implements 接口名字{ }

接口成员

接口成员只能有两类

• 接口常量：const
• 共有的接口方法（普通方法和静态方法）

PHP 重载

overload，指在一个类中可以出现多个同名方法，彼此之间的参数个数和类型不一样

用来容错

属性重载

当对象访问不存在的或者权限不够的属性的时候，自动触发魔术方法让代码不出错

属性重载魔术方法

• __get(属性名)：访问不存在或者权限不够的属性时触发
• __set(属性名,属性值)：设置不存在或者权限不够的属性时触发
• __isset(属性名)：判定不存在或者权限不够的属性是触发
• __unset(属性名)：删除不存在或者权限不够的属性时触发
• __tostring()： 当作字符串

方法重载

对象或者类访问不存在或者权限不够的方法，自动触发的魔术方法让代码不出错

• __cal(方法名，方法参数列表)：调用不存在或者权限不够的方法时触发
• __callStatic(方法名，方法参数列表)：调用不存在或者权限不够的静态方法时触发

对象遍历

将对象中的所有属性以键值对的形式取出并进行访问

• 对象是一种复合数据类型，对象中真正保存的内容是属性

• 对象的属性本质也是一种键值对关系：名字 = 值

• 对象遍历就是利用 foreach 对对象中的属性进行取出解析

• 对象遍历遵循访问修饰限定符的限定：即类外只能遍历所有共有属性

  foreach(对象变量 as [属性名变量 =>
  ] 属性值变量){
  
      #属性名变量代表取出的每个属性的名字
      #属性值变量代表取出的每个属性的值}
      

Iterator 迭代器

生成器

yield 关键字

设计模式

design pattern，是软件开发人员在软件开发过程中问题的解决方法

单例模式

singleton，是一种类的设计只会最多产生一个对象的设计思想

保证资源唯一性

工厂模式

。。。。。。

命名空间

namespace，指人为的将内存进行分隔，让不同内存区域的同名结构共存，从而解决在大型项目能出现重名结构问题

基础语法：

namespace 关键字定义空间

命名规则

字母、数字、下划线，不能以数字开头

命名空间必须写在所有代码之前，定义了一个，之后可以定义多个

子空间

subspace，即在已有空间之上，再在内部进行空间划分

子空间直接通过 namespace+路径符号 \ 实现

非限定名称

直接访问元素本身，代表当前所属空间（当前目录）

限定名称

使用空间名+原名，代表访问当前空间子空间（当前目录子目录）

完全限定名称

从根目录（全局空间）开始访问，使用 \ 作为全局空间开始符号（根目录）

全局空间元素访问：使用完全限定名称访问

命名空间引入

、