设计模式

设计模式

  • 0. 概述
  • 1. 设计模式七大原则
    • 1.1 单一职责原则
    • 1.2 接口隔离原则
    • 1.3 依赖倒转原则
    • 1.4 里氏替换原则
    • 1.5 开闭原则
    • 1.6 迪米特法则
    • 1.7 合成复用原则
  • 2. 创建型模式
    • 2.1 概述
    • 2.2 常见创建型模式详解
      • 2.2.1 单例模式
      • 2.2.2 工厂模式
      • 2.2.3 建造者模式
      • 2.2.4 原型模式
  • 3. 结构型模式
    • 3.1 概述
    • 3.2 常见结构型模式详解
      • 3.2.1 适配器模式
      • 3.2.2 代理模式
  • 未完待续

0. 概述

       在软件工程中,设计模式是对软件设计中 普遍存在(反复出现) 的各种问题,所提出的解决方案。

       使用设计模式,是为了让程序具有更好的:

  1. 代码重用性(相同功能的代码,不用多次编写)
  2. 可读性(编程规范性,便于其他程序员的阅读和理解)
  3. 可扩展性(当需要增加新的功能时,非常的方便)
  4. 可靠性(当我们增加新的功能时,对原来的功能没有影响)
  5. 使程序呈现高内聚低耦合的特性

1. 设计模式七大原则

       设计模式的七大原则使设计模式为什么这样设计的依据。

       设计模式常用的七大原则:

  1. 单一职责原则
  2. 接口隔离原则
  3. 依赖倒转原则
  4. 里氏替换原则
  5. 开闭原则
  6. 迪米特法则
  7. 合成复用原则

1.1 单一职责原则

       对类来说,即一个类应该只负责一项职责。如类A负责两个不同的职责:职责1,职责2。当职责1需求变更而改变A时,可能造成职责2执行错误,所以需要将类A的粒度分解为A1A2。(即分解为两个类)

public class SingleResponsibility1 {

    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.run("摩托车");
        vehicle.run("汽车");
        vehicle.run("飞机");
    }
}

// 交通工具类
// 方式1
// 1、在方式1 的run()中,违反了单一职责原则
// 2、根据交通运行方式的不同,分解成不同的类型
class Vehicle {
    public void run(String vehicle){
        System.out.println(vehicle + " 在公路上运行...");
    }
}
public class SingleResponsibility2 {

    public static void main(String[] args) {
        RoadVehicle roadVehicle = new RoadVehicle();
        roadVehicle.run("摩托车");
        roadVehicle.run("汽车");

        AirVehicle airVehicle = new AirVehicle();
        airVehicle.run("飞机");
    }
}

// 方案二的分析
// 1、遵守单一职责原则
// 2、但是这样的改动很大,即将类分解,同时修改了客户端
// 3、改进:直接修改Vehicle 类,改动的代码会比较少 ==》方案三
class RoadVehicle{
    public void run(String vehicle){
        System.out.println(vehicle +" 公路运行");
    }
}

class AirVehicle{
    public void run(String vehicle){
        System.out.println(vehicle +" 天空运行");
    }
}

class WaterVehicle{
    public void run(String vehicle){
        System.out.println(vehicle +" 水中运行");
    }
}

public class SingleResponsibility3 {

    public static void main(String[] args) {
        Vehicle2 vehicle = new Vehicle2();
        vehicle.runRoad("汽车");
        vehicle.runAir("飞机");
        vehicle.runWater("轮船");
    }
}

// 方式3的分析
// 1、这种修改方法没有对原来的类做大的修改,只是增加方法
// 2、这里虽然没有在类这个级别上遵守单一职责原则,但是在方法级别,仍然时遵守单一职责
class Vehicle2 {
    public void runRoad(String vehicle){
        System.out.println(vehicle + " 在公路运行...");
    }

    public void runAir(String vehicle){
        System.out.println(vehicle + " 在天空运行...");
    }

    public void runWater(String vehicle){
        System.out.println(vehicle + " 在水中运行...");
    }
}

       单一职责原则注意事项和细节

  1. 降低类的复杂度,一个类只负责一项职责

  2. 提高类的可读性,可维护性

  3. 降低变更引起的风险

  4. 通常情况下,我们应当遵守单一职责原则,只有逻辑足够简单,才可以在代码级违反单一职责原则;只有类中方法数量足够少,才可以在方法级别保持单一职责原则。

1.2 接口隔离原则

       客户端不应该依赖它不需要的接口,即一个类对另一个类的依赖应该建立在最小的接口上。

设计模式_第1张图片

interface Interface1{
   void operation1();
   void operation2();
   void operation3();
   void operation4();
   void operation5();
}

class B implements Interface1{

    public void operation1() {
        System.out.println("B 实现了operation1");
    }

    public void operation2() {
        System.out.println("B 实现了operation2");
    }

    public void operation3() {
        System.out.println("B 实现了operation3");
    }

    public void operation4() {
        System.out.println("B 实现了operation4");
    }

    public void operation5() {
        System.out.println("B 实现了operation5");
    }
}

class D implements Interface1{

    public void operation1() {
        System.out.println("D 实现了operation1");
    }

    public void operation2() {
        System.out.println("D 实现了operation2");
    }

    public void operation3() {
        System.out.println("D 实现了operation3");
    }

    public void operation4() {
        System.out.println("D 实现了operation4");
    }

    public void operation5() {
        System.out.println("D 实现了operation5");
    }
}

class A{    // 类A通过Interface1,依赖B的1、2、3方法
    public void dependency1(Interface1 i){
        i.operation1();
    }

    public void dependency2(Interface1 i){
        i.operation2();
    }

    public void dependency3(Interface1 i){
        i.operation3();
    }
}

class C{    // 类C通过Interface1,依赖D的1、4、5方法
    public void dependency1(Interface1 i){
        i.operation1();
    }

    public void dependency4(Interface1 i){
        i.operation4();
    }

    public void dependency5(Interface1 i){
        i.operation5();
    }
}

       类A通过接口Interface1依赖类B,类C通过接口Interface1依赖类D,如果接口Interface1对于类A和类C来说不是最小接口,那么类B和类D必须去实现它们不需要的方法。

       按隔离原则应当这样处理

       将接口Interface1拆分为独立的几个接口,类A和类C分别与它们需要的接口建立依赖关系。

设计模式_第2张图片

interface Interface1{
   void operation1();
}

interface Interface2{
    void operation2();
    void operation3();
}

interface Interface3{
    void operation4();
    void operation5();
}

class B implements Interface1,Interface2 {

    public void operation1() {
        System.out.println("B 实现了operation1");
    }

    public void operation2() {
        System.out.println("B 实现了operation2");
    }

    public void operation3() {
        System.out.println("B 实现了operation3");
    }
}

class D implements Interface1,Interface3 {

    public void operation1() {
        System.out.println("D 实现了operation1");
    }

    public void operation4() {
        System.out.println("D 实现了operation4");
    }

    public void operation5() {
        System.out.println("D 实现了operation5");
    }
}

class A{    // 类A通过Interface1、Interface2,依赖B的1、2、3方法
    public void dependency1(Interface1 i){
        i.operation1();
    }

    public void dependency2(Interface2 i){
        i.operation2();
    }

    public void dependency3(Interface2 i){
        i.operation3();
    }
}

class C{    // 类C通过Interface1、Interface3,依赖D的1、4、5方法
    public void dependency1(Interface1 i){
        i.operation1();
    }

    public void dependency4(Interface3 i){
        i.operation4();
    }

    public void dependency5(Interface3 i){
        i.operation5();
    }
}

1.3 依赖倒转原则

       基本介绍:

  1. 高层模块不应该依赖低层模块,二者都应该依赖其抽象。

2.抽象不应该依赖其细节,细节应该依赖抽象

  1. 依赖倒转的中心思想是面向接口编程

  2. 设计理念:相对于细节的多变性,抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在Java中,抽象指的是接口或抽象类,细节就是具体的实现类。

  3. 使用接口或抽象类的目的是制定好规范,而不设计任何具体的操作,把展现细节的任务交给它们的实现类完成。

       Person类接受消息


public class DependencyInversion {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
    }
}

class Email{
    public String getInfo(){
        return "电子邮件信息:hello,world";
    }
}

// 完成Person接收消息的功能
// 方式1分析
// 1、简单,比较容易想到
// 2、如果我们获取的对象是微信,短信等,则新增类,同时Person也要增加新的接受方法
// 3、解决思路:引入一个抽象的接口IReceiver,表示接收者,这样Person类与接口IReceiver发生依赖
//    因为Email、WeChat 等等属于接受的范围,他们各自实现IReceiver接口,这样就符合依赖倒转原则
class Person{
    public void receive(Email email){
        System.out.println(email.getInfo());
    }
}
public class DependencyInversion {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
        person.receive(new WeChat());
    }
}

// 定义接口
interface IReceiver{
    String getInfo();
}

class Email implements IReceiver{
    public String getInfo(){
        return "电子邮件信息:hello,world";
    }
}

class WeChat implements IReceiver{
    public String getInfo(){
        return "微信信息:hello,world";
    }
}

class Person{
    public void receive(IReceiver receiver){
        System.out.println(receiver.getInfo());
    }
}

       依赖关系传递的三种方式和应用案例

  1. 接口传递
// 开关的接口
interface IOpenAndClose{
    void open(ITV tv);  // 抽象方法,接受接口
}

interface ITV{  
   void play(); 
}

class OpenAndClose implements IOpenAndClose{

    public void open(ITV tv) {
        tv.play();
    }
}
  1. 构造方法传递
interface IOpenAndClose{
    void open();  // 抽象方法
}

interface ITV{
    void play();
}

class OpenAndClose implements IOpenAndClose{

    public ITV tv;

    public OpenAndClose(ITV tv){
        this.tv = tv;
    }

    public void open() {
        tv.play();
    }
}
  1. setter方式传递
interface IOpenAndClose{
    void open(); // 抽象方法

    void setTv(ITV tv);
}

interface ITV{
    void play();
}

class OpenAndClose implements IOpenAndClose{

    public ITV tv;

    public void open() {
        tv.play();
    }

    public void setTv(ITV tv) {
        this.tv = tv;
    }
}

       注意事项和细节

  1. 低层模块尽量都要有抽象类或接口,或者两者都有,程序稳定性更好

  2. 变量的声明类型尽量是抽象类或接口,这样我们的变量引用和实际对象间,就存在一个缓冲层,利于程序扩展 和优化

  3. 继承时遵循里氏替换原则

1.4 里氏替换原则

       OO中的继承性的思考和说明

  1. 继承包含这样一层含义:父类中凡是已经实现好的方法,实际上是在设定规范和契约,虽然它不强制要求所有的子类必须遵循这些契约,但是如果子类对这些已经实现的方法任意修改,就会被整个继承体系造成破环。
  2. 继承在给程序设计带来便利的同时,也带来了弊端。如使用继承会给程序带来侵入性,程序的可移植性降低,增加对象间的耦合性,如果一个类被其他的类所继承,则当这个类需要修改时,必须考虑到所有的子类,并且父类修改后,所有涉及到子类的功能都有可能产生故障。
  3. 在编程中,如何正确的使用继承?==》里氏替换原则

       基本介绍

  1. 如果对每个类型为T1的对象o1,都有类型为T2的对象o2,使得以T1定义的所有程序P在所有的对象o1都代换成o2时,程序``P的行为没有发生变化,那么类型T2时类型T1的子类型。即所有引用基类的地方必须能透明的使用其子类的对象

  2. 在使用继承时,遵循里氏替换原则,在子类中尽量不要重写父类的方法。

  3. 里氏替换原则告诉我们,继承实际上让两个类耦合性增强了。在适当的情况下,可以通过聚合,组合,依赖来解决问题


public class Liskov {

    public static void main(String[] args) {
        A a = new A();
        System.out.println("11-3 = " + a.func1(11,3));
        System.out.println("1-8 = " + a.func1(1,8));

        System.out.println("===============");
        B b = new B();
        System.out.println("11-3 = " + b.func1(11,3)); // 这里本意是求出11-3
        System.out.println("1-8 = " + b.func1(1,8));
        System.out.println("11+3+9 = " + b.func2(11,3));
    }
}

// A类
class A{
    // 返回两个数的差
    public int func1(int a,int b){
        return a - b;
    }
}

// B类继承了A
// 增加了新的功能:完成两个数相加,然后和9求和
class B extends A{

    // 无意进行了重写
    @Override
    public int func1(int a, int b) {
        return a + b;
    }

    public int func2(int a, int b){
        return func1(a, b) + 9;
    }
}

       解决方法

  1. 我们发现原来运行正常的相减功能发生了错误。原因是类B无意重写了父类的方法,造成原有功能出现错误。

       在实际编程中,我们常常通过重写父类的玩法完成新的功能,这样写起来虽然简单,但整个继承体系的复用性会变差。特定是多态比较频繁的时候。
2. 通用的做法:令原来的父类和子类都继承一个更通俗的基类,原有的继承关系去掉,采用依赖、聚合、组合等关系代替

public class Liskov {

    public static void main(String[] args) {
        A a = new A();
        System.out.println("11-3 = " + a.func1(11,3));
        System.out.println("1-8 = " + a.func1(1,8));

        System.out.println("===============");
        B b = new B();
        // 因为B类不在继承A类,所以调用者,不会在func1()是求减法
        // 调用完成的功能就会很明确
        System.out.println("11+3 = " + b.func1(11,3)); // 这里本意是求出11+3
        System.out.println("1+8 = " + b.func1(1,8));
        System.out.println("11+3+9 = " + b.func2(11,3));

        // 使用组合仍然可以使用A类相关方法
        System.out.println("11-3 = " + b.func3(11,3));
    }
}

// 创建一个更加继承的基类
class Base{

}

// A类
class A extends Base{
    // 返回两个数的差
    public int func1(int a,int b){
        return a - b;
    }
}

// 增加了新的功能:完成两个数相加,然后和9求和
class B extends Base{

    // 如果B需要使用A类的方法,使用组合关系
    private A a = new A();

    public int func1(int a, int b) {
        return a + b;
    }

    public int func2(int a, int b){
        return func1(a, b) + 9;
    }

    // 我们仍然想使用A的方法c
    public int fun3(int a,int b){
        return a.func1();
    }
}

1.5 开闭原则

  1. 开闭原则(Open Closed Principle)是编程中最基础、最重要的设计原则。
  2. 一个软件实体如类、模块和函数应该对扩展开放(针对提供方)对修改关闭(对使用方)。用抽象构建框架,用实现扩展细节。
  3. 当软件需要变化时,尽量通过扩展软件实体的行为来实现变化,而不是通过修改已有的代码来实现变化。
  4. 编程中遵循其他原则,以及使用设计模式的目的就是遵循开闭原则。
public class Ocp {
    public static void main(String[] args) {
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Rectangle());
        graphicEditor.drawShape(new Circle());
    }
}

// 这是一个用于绘图的类
class GraphicEditor{
    // 接受Shape对象,然后根据type,绘制不同的图形
    public void drawShape(Shape s){
        if(s.m_type == 1){
            drawRectangle(s);
        }else if(s.m_type==2){
            drawCircle(s);
        }
    }

    private void drawCircle(Shape s) {
        System.out.println("绘制圆形");
    }

    private void drawRectangle(Shape s) {
        System.out.println("绘制矩形");
    }
}

// 基类
class Shape{
    int m_type;
}

class Rectangle extends Shape{
    Rectangle(){
        super.m_type = 1;
    }
}

class Circle extends Shape{
    Circle(){
        super.m_type = 2;
    }
}

       方式1的优缺点

  1. 优点时比较好理解,简单易操作。

  2. 缺点是违反了设计模式的ocp原则,即对扩展开放(提供方),对修改关闭(使用方)

  3. 比如我们这时要新增加一个图形种类,我们需要做如下修改,修改的地方较多。

public class Ocp {
    public static void main(String[] args) {
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Rectangle());
        graphicEditor.drawShape(new Circle());
        graphicEditor.drawShape(new Triangle());
    }
}

// 这是一个用于绘图的类 [使用方]
class GraphicEditor{
    // 接受Shape对象,然后根据type,绘制不同的图形
    public void drawShape(Shape s){
        if(s.m_type == 1){
            drawRectangle(s);
        }else if(s.m_type == 2){
            drawCircle(s);
        }else if(s.m_type == 3){
            drawTriangle(s);
        }
    }

    private void drawCircle(Shape s) {
        System.out.println("绘制圆形");
    }

    private void drawRectangle(Shape s) {
        System.out.println("绘制矩形");
    }

    private void drawTriangle(Shape s) {
        System.out.println("绘制三角形");
    }
}

// 基类
class Shape{
    int m_type;
}

class Rectangle extends Shape{
    Rectangle(){
        super.m_type = 1;
    }
}

class Circle extends Shape{
    Circle(){
        super.m_type = 2;
    }
}

// 新增三角形
class Triangle extends Shape{
    Triangle(){
        super.m_type = 3;
    }
}

       改进:把创建的Shape类改为抽象类,并提供一个抽象的draw()方法,让子类去实现即可,这样我们有新的图形种类时,只需要让新的图形继承Shape,并实现draw方法即可。使用方代码不需要改动,满足开闭原则。

public class Ocp {
    public static void main(String[] args) {
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Rectangle());
        graphicEditor.drawShape(new Circle());
        graphicEditor.drawShape(new Triangle());
    }
}

// 这是一个用于绘图的类 [使用方]
class GraphicEditor{
    // 接受Shape对象,调用draw()方法a
    public void drawShape(Shape s){
        s.draw();
    }
}

// 基类
abstract class Shape{
    public abstract void draw(); // 抽象方法
}

class Rectangle extends Shape {
    public void draw() {
        System.out.println("绘制矩形");
    }
}

class Circle extends Shape {
    public void draw() {
        System.out.println("绘制圆形");
    }
}

// 新增三角形
class Triangle extends Shape {
    public void draw() {
        System.out.println("绘制三角形");
    }
}

1.6 迪米特法则

  1. 一个对象应该对其他对象保持最少的了解。
  2. 类与类关系越密切,耦合度越大。
  3. 迪米特法则又叫最少知道原则,即一个类对自己依赖的类知道的越少越好。也就是说,对于被依赖的类不管多么复杂,都尽量将逻辑封装在类的内部。对外除了提供public方法,不对外泄露任何信息。
  4. 迪米特法则还有更简单的定义:只与直接朋友通信。
  5. 直接的朋友:每个对象都会与其他对象有耦合关系,只要两个对象之间有耦合关系,我们就说这两个对象之间是朋友关系。耦合的方式很多,依赖,关联,组合,聚合等。其中,我们称出现成员变量,方法参数,方法返回值中的类为直接的朋友,而出现在局部变量中的类不是直接的朋友。即,陌生的类最好不要以局部变量的形式出现在类的内部。

       有一个学校,下属有各个学院和总部,现要求打印出学校总部员工ID和学院员工的id

// 客户端
public class Demeter1 {

    public static void main(String[] args) {
        // 创建一个SchoolManager
        SchoolManager schoolManager = new SchoolManager();
        // 输出学院的员工id 和 学校总部的员工信息
        schoolManager.printAllEmployee(new CollegeManager());
    }

}

// 学校总部员工
class Employee{
    private String id;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

// 学院员工
class CollegeEmployee{
    private String id;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

// 管理学院员工的类
class CollegeManager{
    // 返回学院的所有员工
    public List<CollegeEmployee> getAllEmployee(){
        List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
        for(int i=0;i<10;i++){
            CollegeEmployee emp = new CollegeEmployee();
            emp.setId("学院员工id= " + i);
            list.add(emp);
        }
        return list;
    }
}

// 管理学校总部员工的类
class SchoolManager{
    public List<Employee> getAllEmployee(){
        List<Employee> list = new ArrayList<Employee>();
        for(int i=0;i<5;i++){
            Employee emp = new Employee();
            emp.setId("学校总部员工id= " + i);
            list.add(emp);
        }
        return list;
    }

    // 该方法完成输出学校总部和学院员工信息(id)
    void printAllEmployee(CollegeManager sub){
        // 获取到学院员工
        List<CollegeEmployee> list1 = sub.getAllEmployee();
        System.out.println("---------学院员工----------");
        for(CollegeEmployee e : list1){
            System.out.println(e.getId());
        }

        // 获取到学校总部员工
        List<Employee> list2 = this.getAllEmployee();
        System.out.println("---------学校总部员工----------");
        for(Employee e : list2){
            System.out.println(e.getId());
        }
    }
}
// 管理学院员工的类
class CollegeManager{
    // 返回学院的所有员工
    public List<CollegeEmployee> getAllEmployee(){
        List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
        for(int i=0;i<10;i++){
            CollegeEmployee emp = new CollegeEmployee();
            emp.setId("学院员工id= " + i);
            list.add(emp);
        }
        return list;
    }
}

// 管理学校总部员工的类

// 分析 SchoolManager 类的直接朋友有  Employee、 CollegeManager
//  CollegeEmployee 不是直接朋友
class SchoolManager{
    public List<Employee> getAllEmployee(){
        List<Employee> list = new ArrayList<Employee>();
        for(int i=0;i<5;i++){
            Employee emp = new Employee();
            emp.setId("学校总部员工id= " + i);
            list.add(emp);
        }
        return list;
    }

    // 该方法完成输出学校总部和学院员工信息(id)
    void printAllEmployee(CollegeManager sub){

        //  1、CollegeEmployee 不是SchoolManager的直接朋友
        //  2、CollegeEmployee 是以局部变量方式出现在SchoolManager
        //  3、违反了迪米特法则

        // 获取到学院员工
        List<CollegeEmployee> list1 = sub.getAllEmployee();
        System.out.println("---------学院员工----------");
        for(CollegeEmployee e : list1){
            System.out.println(e.getId());
        }

        // 获取到学校总部员工
        List<Employee> list2 = this.getAllEmployee();
        System.out.println("---------学校总部员工----------");
        for(Employee e : list2){
            System.out.println(e.getId());
        }
    }
}

       改进:按照迪米特法则,应该避免类中出现这样非直接朋友关系的耦合

// 管理学院员工的类
class CollegeManager{
    // 返回学院的所有员工
    public List<CollegeEmployee> getAllEmployee(){
        List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
        for(int i=0;i<10;i++){
            CollegeEmployee emp = new CollegeEmployee();
            emp.setId("学院员工id= " + i);
            list.add(emp);
        }
        return list;
    }

    // 输出学院员工信息
    public void printAllCollegeEmployee(){
        List<CollegeEmployee> list1 = this.getAllEmployee();
        System.out.println("---------学院员工----------");
        for(CollegeEmployee e : list1){
            System.out.println(e.getId());
        }
    }
}

// 管理学校总部员工的类

// 分析 SchoolManager 类的直接朋友有  Employee、 CollegeManager
//  CollegeEmployee 不是直接朋友
class SchoolManager{
    public List<Employee> getAllEmployee(){
        List<Employee> list = new ArrayList<Employee>();
        for(int i=0;i<5;i++){
            Employee emp = new Employee();
            emp.setId("学校总部员工id= " + i);
            list.add(emp);
        }
        return list;
    }

    // 该方法完成输出学校总部和学院员工信息(id)
    void printAllEmployee(CollegeManager sub){

        // 1、将输出学院的员工方法,封装到CollegeManager
        sub.printAllCollegeEmployee();

        // 获取到学校总部员工
        List<Employee> list2 = this.getAllEmployee();
        System.out.println("---------学校总部员工----------");
        for(Employee e : list2){
            System.out.println(e.getId());
        }
    }
}

       迪米特法则注意事项和细节

  1. 迪米特法则的核心是降低类之间的耦合

  2. 由于每个类都减少了不必要的依赖,因此迪米特法则只是要求降低类间(对象间)耦合关系,并不是要求完全没有依赖关系

1.7 合成复用原则

       它要求在软件复用时,要尽量先使用组合或者聚合等关联关系来实现,其次才考虑使用继承关系来实现。

       如果要使用继承关系,则必须严格遵循里氏替换原则。合成复用原则同里氏替换原则相辅相成的,两者都是开闭原则的具体实现规范。

       类似于我们在里氏替换原则中的示例代码。

2. 创建型模式

2.1 概述

  • 创建型模式(Creational Pattern)对类的实例化过程进行了抽象,能够将软件模块中对象的创建和对象的使用分离。为了使软件的结构更加清晰,外界对于这些对象只需要知道它们共同的接口,而不清楚其具体的实现细节,使整个系统的设计更加符合单一职责原则。
  • 创建型模式在创建什么(What),由谁创建(Who),何时创建(When)等方面都为软件设计者提供了尽可能大的灵活性。创建型模式隐藏了类的实例的创建细节,通过隐藏对象如何被创建和组合在一起达到使整个系统独立的目的。

设计模式_第3张图片

2.2 常见创建型模式详解

2.2.1 单例模式

       单例模式

2.2.2 工厂模式

       工厂模式

2.2.3 建造者模式

       建造者模式

2.2.4 原型模式

       原型模式

3. 结构型模式

3.1 概述

  • 结构型模式(Structural Pattern),描述如何将类或者对象结合在一起形成更大的结构,就像搭积木,可以通过简单积木的组合形成复杂的、功能更为强大的结构

设计模式_第4张图片

  • 结构型模式可以分为类结构型模式和对象结构型模式

    • 类结构型模式关心类的组合,由多个类可以组合成一个更大的系统,在类结构型模式中一般只存在继承关系和实现关系。

    • 对象结构型模式关心类与对象的组合,通过关联关系使得在一个类中定义另一个类的实例对象,然后通过该对象调用其方法。根据“合成复用原则”,在系统中尽量使用关联关系来替代继承关系,因此大部分结构型模式都是对象结构型模式。

设计模式_第5张图片

3.2 常见结构型模式详解

3.2.1 适配器模式

       适配器模式

3.2.2 代理模式

       代理模式

未完待续

你可能感兴趣的:(设计模式,设计模式)