设计模式

GoF23

  • 创建模式
    • 工厂方法 ✅
    • 抽象工厂 ✅
    • 建造者
    • 原型
    • 单例 ✅
  • 结构模式
    • 类适配器
    • 对象适配器
    • 桥接
    • 组合
    • 装饰
    • 外观
    • 享元
    • 代理
  • 行为模式
    • 解释器
    • 模板方法
    • 指责链
    • 命令
    • 迭代器
    • 中介者
    • 备忘录
    • 观察者
    • 状态
    • 策略
    • 访问者

7个设计原则

  • 单一职责

  • 开闭原则：

    对扩展开放，对修改关闭

  • 里氏代换：

    所有引用基类的地方必须能透明地使用其子类的对象

  • 依赖倒转：

    抽象不应该依赖于细节，细节应该依赖于抽象

  • 接口隔离

  • 合成复用

  • 迪米特法则

==开闭原则是目标，里氏代换是基础，依赖倒转是手段。它们相辅相成，目标一致，只是分析问题时所站的角度不同而已。==

我的理解：开闭原则是我们要做什么，里氏代换是为什么能这么做，依赖倒转是要怎么做

创建模式

单例模式

确保一个类只有一个对象

  • 通过私有化构造器保证用户无法在外部直接实例化
  • 提供一个静态方法来暴露这个唯一实例

饿汉式

1
2
3
4
5
6
7
8
9
10
11
12
public class Singleton {

    private static Singleton instance = new Singleton();

    // 私有化构造器
    private Singleton() {
    }

    public static Singleton getInstance () {
        return instance;
    }
}

懒汉式

使用双重检查锁定来保证多线程下的单例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class LazySingleton {

  	// volatile关键字保证多线程正确处理
    private volatile static LazySingleton instance;

    // 私有化构造器
    private LazySingleton() {
    }

    // double-check locking
    public static LazySingleton getInstance () {
        if (instance == null) {
            synchronized (LazySingleton.class) {
                if (instance == null) {
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }
}

简单工厂模式

定义一个工厂类，根据不同参数返回不同的实例，这些实例通常有相同父类

最简单的设计模式之一

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class SimpleFactory {

    public static Animal getAnimal(int arg) {
        Animal animal = null;
        if (arg == 1) {
            animal = new Cat();
        } else if (arg == 2) {
            animal = new Dog();
        }
        return animal;
    }
}

// 抽象产品类
public abstract class Animal {}

public class Cat extends Animal {}

public class Dog extends Animal {}

缺点： 每增加一种产品就要修改工厂类的代码，不满足开闭原则

工厂方法模式

工厂类和产品类都是抽象的，由具体工厂决定具体产品

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// 抽象产品
public interface Logger {
    public void writeLog();
}

// 具体产品1
public class DatabaseLogger implements Logger {
    @Override
    public void writeLog() {
        System.out.println("记录数据库日志");
    }
}

// 具体产品2
public class FileLogger implements Logger {
    @Override
    public void writeLog() {
        System.out.println("记录文件日志");
    }
}

// 抽象工厂
public interface LoggerFactory {
    public Logger getLogger();
}

// 具体工厂1
public class DatabaseLoggerFactory implements LoggerFactory {
    @Override
    public Logger getLogger() {
        return new DatabaseLogger();
    }
}

// 具体产工厂2
public class FileLoggerFactory implements LoggerFactory {
    @Override
    public Logger getLogger() {
        return new FileLogger();
    }
}

  • 优点：满足开闭原则

  • 缺点：每引入一个新的具体产品，具体工厂类和具体产品类会成对增加，增加了系统复杂度

抽象工厂模式

工厂方法模式的演进，一个工厂创建一系列产品

1
2
3
4
5
// 抽象工厂
public interface AbstracyFactory {
    public AbstractProductA createProductA();
  	public AbstractProductB createProductB();
}

此模式下开闭原则的倾斜性：对于增加新的产品族很容易，无需修改代码；但对于增加新的产品等级结构时需要修改代码

原型模式

结构模式

适配器模式

外观模式

代理模式

行为模式

策略模式

定义一系列算法，将每个算法单独封装起来，并让它们可以相互替换

其实就是一个接口的多种实现类。我的评价是：八十岁奶奶都会

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 折扣接口，充当抽象策略类
public interface Discount {
    public void calculate();
}

// 学生票折扣类，充当具体策略类
public class StudentDiscount implements Discount {
    @Override
    public void calculate() {
        System.out.println("按学生价打折");
    }
}

// 儿童票折扣类，充当具体策略类
public class ChildrenDiscount implements Discount {
    @Override
    public void calculate() {
        System.out.println("按儿童价打折");
    }
}

模板方法模式

定义一个操作算法的框架，而将其中一些步骤延迟到子类中

结构最简单的行为型设计模式，只存在父子间的继承关系。本质上就是基于继承的代码复用

  • 模板方法：将基本方法组合在一起形成一个总算法
  • 基本方法：
    • 抽象方法：由抽象类声明，必须由实现类实现
    • 具体方法：由抽象类声明并实现，子类可以直接继承或自己覆盖
    • 钩子方法：由抽象类声明，通常由父类给出一个空实现或默认实现，子类可以直接继承或自己覆盖。意义在于子类可以通过钩子方法改变模板方法的流程（这类钩子方法的返回值通常是boolean），即使子类不覆盖也可以编译通过
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// 账户类，充当抽象类
public abstract class Account {
    
    // 模板方法
    public void handle(String password) {
        if (!validate(password)) {
            System.out.println("密码错误");
            return;
        }
        calculateInterest();
        display();
    }
    
    // 基本方法-钩子方法
   	// 校验密码
    public boolean validate(String password) {
        return "123".equals(password);
    }
    
    // 基本方法-抽象方法
  	// 计算利息
    public abstract void calculateInterest();

    // 基本方法-具体方法
  	// 显示利息
    public void display() {
        System.out.println("显示利息");
    }
}

// 活期账户类，充当具体实现类
public class CurrentAccount extends Account {
    @Override
    public void calculateInterest() {
        System.out.println("按活期利率计算");
    }
}

// 定期账户类，充当具体实现类
public class SavingAccount extends Account {
    @Override
    public void calculateInterest() {
        System.out.println("按定期利率计算");
    }
}

赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家