目录

一. 面向对象基本知识

1.1 面向对象概念

1.2 什么是类

1.3 什么是对象

1.4 类与对象的关系

1.5 PHP创建类的示例

二、类、属性、方法的修饰符

2.1 类的修饰符

2.2 成员方法的修饰符

2.3 成员属性修饰符

2.4 访问控制修饰符 

2.5 static 静态修饰符

2.6 final 修饰符

2.7 abstract 抽象修饰符

2.8 interface 接口修饰符

三. 面向对象三大特性

3.1 封装

3.2 继承

3.3 多态 

四. 面向对象七大原则 

4.1 单一职责原则

4.2 开放封闭原则

4.3 里式替换原则

4.4 依赖倒置原则

4.5 接口隔离原则

4.6 迪米特原则

4.7 合成/聚合复用原则

---

一. 面向对象基本知识

1.1 面向对象概念

点击查看“某”度“某”科的解释

面向对象程序设计一种计算机编程架构_百度百科

1.2 什么是类

类是事物相关属性特征和行为特征的集合。

•     属性特征: 就是该事物的状态。比如 用户性别、用户的身高。
•     行为特征: 就是该事物能够做什么。比如 用户下单、用户评论。

⚠️ 注意

•         属性特征在类中被称为 成员属性或成员变量
•         行为特征在类中被称为 成员方法

1.3 什么是对象

对象是客户存在的一个实例是事物的具体实现。可以通过对象调用类的属性 与 行为。 

1.4 类与对象的关系

• 类是对对象抽象的一个描述
• 对象是客观存在的一个实体

1.5 PHP创建类的示例

<?php
    # 类: 创建名为 Car 的类
    public class Car
	{
    	# 成员属性
    	public $default_config;
    	static $default_name;
    
    	# 成员方法
    	public function get_config()
        {
            // 需要完成的功能
        }
    	static function get_name()
        {
            // 需要完成的功能
        }
	}

	# 对象: $car_obj 就是 Car 类的一个实例
	# 对象 = new 类名();
	$car_obj = new Car();


	# static 静态修饰符访问示例
        # 格式: 类名::属性名 , 示例: 
        $default_name = Car::default_name;

        # 格式: 类名::方法名 , 示例: 
        $name = Car::get_name(); 

        # 格式: $对象名->静态属性名 , 示例:
        $default_name = $car_obj->default_name;

        # 格式: $对象名->静态方法名 , 示例:
        $name =$car_obj->get_name();

二、类、属性、方法的修饰符

2.1 类的修饰符

类的修饰符有: abstract、final、interface、trait 

2.2 成员方法的修饰符

成员方法的修饰符有: public、protected、private、static、abstract、final 

2.3 成员属性修饰符

属性修饰符有: public、protected、private、static、var

 

var 与 public 作用相同, var 是 public 的别名。

2.4 访问控制修饰符 

 

2.5 static 静态修饰符

示例请看上边的代码

    static 静态修饰符 : 用于修饰类的成员属性和成员方法 。

    static 关键字 : 修饰的成员方法称为静态方法修饰的成员属性称为静态属性。

调用方法:

        可以不用 new实例化就可以直接调用, 格式 类名::属性名
        静态方法在实例化后的对象也可以访问, 格式 对象名->属性名

⚠️注意:

        在静态方法中不可以使用非静态的内容。就是不让使用 $this
        在类的方法中可以使用其他静态属性和静态方法不过要使用self关键字如 self::静态属性名 或 self::静态方法名

2.6 final 修饰符

类使用时: 如果类使用 final关键字修饰时 表示这个类不可以有子类即不能被 继承。

 

成员方法使用时: 如果成员方法 使用 final 关键字修饰时表示这个成员方法不可以在子类中被覆盖即不能被 重写。

2.7 abstract 抽象修饰符

类使用时:

<?php
abstract class ClassName{
    public function functionName();
}

1. 抽象类中的成员方法没有方法体以 (); 结束。
2. 该类不能被实例化
3. 若想使用抽象类就必须定义一个类去继承这个抽象类并定义覆盖父类的抽象方法(实现抽象方法)。

 成员方法使用时:

<?php
	abstract class ClassName{
		abstract function functionName();
	}

1. 称为抽象方法使用关键字 abstract 定义
2. 包含抽象方法的类必须是抽象类类也要使用关键字abstract加以声明。

⚠️注意 : 含有抽象方法的类肯定是抽象类但是不是所有的抽象类都必须包含抽象方法。 

2.8 interface 接口修饰符

假如一个抽象类中所有的方法都是抽象的那么我们可以使用另外一种方式定义接口。 

接口使用关键字interface来定义接口中只能有常量与抽象方法。

<?php
	# 接口定义格式
	interface interfaceName{
		# 常量定义
		const USERLEVEL = 'TOP';

		# 抽象方法定义, 注意抽象方法不需要有 abstract 关键字, 且以 (); 结尾
		function funName();
	}

 

<?php
	# 接口实现, 定义一个类, 使用 implements 关键字实现
	class 类名 implements 接口名1, 接口名2
	{
		# 必须将 接口 中的所有方法全部重写实现
	}

三. 面向对象三大特性

三大特性: 封装、继承、多态。 

3.1 封装

我理解的 封装 就是 类的定义, 将事物相关属性特征和行为特征的集合在一起形成一个 类这就是封装。 

3.2 继承

继承 顾名思义就是 B类 继承 A类继承后 B类 就可以调用访问 A类 非私有的成员属性与成员方法。通过继承创建的类被称为 “子类” 或 “派生类”。被继承的类称为 “基类” 或 “父类”。

⚠️ PHP 通过 extends 关键字继承且一个类只能继承一个父类。

<?php

    # 父类
    class A{

	}

	# 子类
	class B extends A{

    }

3.3 多态 

我理解的多态就是: 同一个方法传入不同的对象实现不同的效果。

<?php

# 注意: 该部分代码没有实际运行, 不保证运行结果可以成功。
# 但是这个逻辑。

	class BuyCar{
		function buyFunc($obj){
         if ($obj instanceof Car){
             $obj->buy();
         } else {
             echo 'No Buy';
         }
     }
	}

	/**
	 * 定义 Car 接口
	 */
	interface Car{
        function buy();
    }

	/**
	 * 定义奔驰类
	 */
	class Benz implements Car{
        function buy(){
            echo 'Benz buy';
        }
    }

	/**
	 * 定义宝马类
	 */
	class Bmw implements Car{
        function buy(){
            echo 'Bmw buy';
        }
    }

	# 实例化 BuyCar 类
	$BuyCar_obj = new BuyCar();

	# 调用 buyFunc
	$BuyCar_obj->buyFunc(new Benz());

	$BuyCar_obj->buyFunc(new Bmw());

四. 面向对象七大原则 

1. 单一职责原则、
2. 开放封闭原则、
3. 里式替换原则、
4. 依赖倒置原则、
5. 接口隔离原则、
6. 迪米特原则、
7. 合成/聚合复用原则 

4.1 单一职责原则

单一职责原则(Single Responsibility PrincipleSRP): 一个类应仅有一个职责。

 

通俗的讲就是一个类当中的所有成员方法完成的工作相关性是相同的。

 

例: 一个类不能即完成用户的注册, 又完成商品的购买。

4.2 开放封闭原则

开放封装原则(Open-Closed PrincipleOCP): 即对扩展开放对修改关闭。

 

通俗的讲就是 在不修改源代码的情况下对其扩展不影响原有功能。

4.3 里式替换原则

里式替换原则(Liskov Substitution Principle LSP): 所有引用基类的地方必须能透明地使用其子类的对象。

 

通俗的讲就是 子类可扩展父类, 而不是覆盖父类或改变父类原有的功能。

4.4 依赖倒置原则

依赖倒置原则(Dependency Inversion Principle DIP): 依赖于抽象。

 

通俗的讲:

1. 高层次模块不应该依赖于低层次模块两者都应依赖于抽象
2. 抽象不应该依赖细节细节应该依赖于抽象。

4.5 接口隔离原则

接口隔离原则(Interface Segregation Principle, ISP): 使用多个小且专门的接口, 不要使用一个大的总接口。

 

通俗的讲就是: 不要把所有功能都写在一个接口中干啥的就是干啥的且不应该依赖那些不需要用不着的接口。

4.6 迪米特原则

迪米特原则(Law of Demeter LoD): 降低类与类之间的耦合。

 

通俗的讲就是: 没有关系的类别硬往一起扯减少没用的交际。

4.7 合成/聚合复用原则

合成/聚合复用原则(Composite/Aggregate Reuse Principle CARP): 尽量使用对象组合而不是继承来达到复用的目的。

 

通俗的讲就是: PHP类之间的关系尽可能的多使用 trait和 use 少使用 extends。