Java常用设计模式知识全面总结（有这一篇就够了！！！）

一、什么是设计模式？

• 概念：设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。

1.1 设计模式分类

• 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

• 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

• 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代器模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

1.2 设计模式原则

1. 开闭原则（Open Close Principle）

开闭原则的意思是：对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

2. 里氏代换原则（Liskov Substitution Principle）

里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

3. 依赖倒转原则（Dependence Inversion Principle）

这个原则是开闭原则的基础，要面向接口编程，不要面向实现编程

4. 接口隔离原则（Interface Segregation Principle）

要求程序员尽量将臃肿庞大的接口拆分成更小的和更具体的接口，让接口中只包含客户感兴趣的方法。

5. 迪米特法则，又称最少知道原则（Demeter Principle）

最少知道原则是指：一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。

6. 合成复用原则（Composite Reuse Principle）

合成复用原则是指：尽量使用合成/聚合的方式，而不是使用继承

7.单一职责原则

单一职责原则规定一个类应该有且仅有一个引起它变化的原因，否则类应该被拆分

二、单例模式

2.1 定义（what）

定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式

2.2 说明（why）

**作用：**而使用单例模式能够保证整个应用中有且只有一个实例

最简单的模式之一。通常，普通类的构造函数是公有的，外部类可以通过“new 构造函数()”来生成多个实例。但是，如果将类的构造函数设为私有的，外部类就无法调用该构造函数，也就无法生成多个实例。这时该类自身必须定义一个静态私有实例，并向外提供一个静态的公有函数用于创建或获取该静态私有实例。

单例模式的主要角色如下：

• 单例类：包含一个实例且能自行创建这个实例的类。

• 访问类：使用单例的类。

  

2.3 使用（how）

2.3.1 饿汉式

// 第一种
/**
 * @author Fantic
 * @create 2021-09-02 16:42
 */

//单例模式：保证一个类只有一个实例，并且提供一个访问该实例的全局访问点
// 饿汉式单例
public class Hungry {
    
    

    // 可能会浪费空间
    private byte[] data1 = new byte[1024*1024];
    private byte[] data2 = new byte[1024*1024];
    private byte[] data3 = new byte[1024*1024];
    private byte[] data4 = new byte[1024*1024];

    // 单例模式核心思想：构造器私有
    private Hungry(){
    
    

    }


    private final static Hungry HUNGRY = new Hungry();

    public static Hungry getInstance(){
    
    
        return HUNGRY;
    }

    public static void main(String[] args) {
    
    
        System.out.println(Hungry.getInstance());
    }

}



// 第二种，采用静态代码块
public class Singleton{
    
    
 
	private static Singleton instance = null;
	
	static {
    
    
		instance = new Singleton();
	}
 	//空参构造器
	private Singleton() {
    
    };
 
	public static Singleton getInstance() {
    
    
		return instance;
	}
}

• 优点：从它的实现中我们可以看到，这种方式的实现比较简单，在类加载的时候就完成了实例化，避免了线程的同步问题。

• 缺点：由于在类加载的时候就实例化了，所以没有达到Lazy Loading(懒加载)的效果，也就是说可能我没有用到这个实例，但是它也会加载，会造成内存的浪费(但是这个浪费可以忽略，所以这种方式也是推荐使用的)。

2.3.2 懒汉式

/**
 * @author Fantic
 * @create 2021-09-02 19:09
 */
// 懒汉式单例,用synchronized防止线程安全问题
public class LazyMan {
    
    
    //构建空参构造器
    private LazyMan() {
    
    
        System.out.println(Thread.currentThread().getName() + " ok");
    }

    private  volatile static LazyMan lazyMan; // volatile 为了避免指令重排

    // 双重检测锁模式的懒汉式单例  DCL 懒汉式
    public static LazyMan getInstance() {
    
    
        if (lazyMan == null) {
    
    
            synchronized (LazyMan.class) {
    
    
                if (lazyMan == null) {
    
    
                    lazyMan = new LazyMan();// 不是一个原子性操作
                    /*
                    1、分配内存空间
                    2、执行构造方法，初始化对象
                    3、把这个对象指向这个空间

                    123
                    132 A
                        B // 此时B线程进来会认为lazyman不为null
                          // 直接返回 此时lazyman 还没有完成构造
                          // 为了避免指令重排
                       */
                }
            }
        }

        return lazyMan;
    }
//没有加锁情况下的懒汉式，容易出现线程安全问题
//    public static LazyMan getInstance() {
    
    
//        if (lazyMan == null) {
    
    
//            lazyMan = new LazyMan();
//        }
//        return lazyMan;
//    }

    // 单线程下确实单例ok,但是多线程并发
    public static void main(String[] args) {
    
    
        for (int i = 0; i < 10; i++) {
    
    
            //利用1.8之后的新特性，来实现的，对输出语句的省略
            new Thread(() -> {
    
    
                LazyMan.getInstance();
            }).start();
        }
    }
}

2.3.3 静态内部类

/**
 * @author Fantic
 * @create 2021-09-02 19:25
 */
// 静态内部类实现单例模式，不安全
public class Holder {
    
    
    //单例模式的标配，空参构造器
    private Holder(){
    
    

    }

    public static Holder getInstance(){
    
    
        return InnerClass.HOLDER;
    }

    //建立静态内部类
    public static class InnerClass{
    
    
        private static final Holder HOLDER = new Holder();
    }

    public static void main(String[] args) {
    
    
        System.out.println(Holder.getInstance());
    }
}

这种方式跟饿汉式方式采用的机制类似，但又有不同。两者都是采用了类装载的机制来保证初始化实例时只有一个线程。不同的地方在饿汉式方式是只要Singleton类被装载就会实例化，没有Lazy-Loading的作用，而静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonHolder类，从而完成Singleton的实例化。

类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

优点：避免了线程不安全，延迟加载，效率高。

2.3.4 枚举

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * @author Fantic
 * @create 2021-09-02 19:28
 */
//枚举没有无参构造，只有有参构造
// enum 本身也是一个 class 类
public enum  EnumSingle {
    
    

    INSTANCE;

    public EnumSingle getInstance(){
    
    
        return INSTANCE;
    }
}

class Test{
    
    
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    
    
        EnumSingle instance1 = EnumSingle.INSTANCE;
        //Constructor<EnumSingle> declaredConstructor=EnumSingle.class.getDeclaredConstructor(null);
        // 枚举没有无参构造，只有有参构造 getDeclaredConstructor(String.class,int.class)
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        //获取访问权限
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();

        // java.lang.NoSuchMethodException: com.kuang.single.EnumSingle.<init> 没有空参的构造方法
        // java.lang.IllegalArgumentException: Cannot reflectively create enum objects  反射不能破坏枚举的单例
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

书写非常简单，访问也很简单在这里直接访问EnumSingle getInstance的得到INSTANCE就可以调用枚举中的方法了。

2.4 总结

优缺点：

• 单例模式的主要优点如下：
• (1) 单例模式提供了对唯一实例的受控访问。
• (2)节约系统资源、提高系统的性能.

• 单例模式的主要缺点如下：
• (1) 由于单例模式中没有抽象层，因此单例类的扩展有很大的困难；
• (2) 单例类的职责过重，在一定程度上违背了“单一职责原则”

单例模式的应用场景：

• 系统只需要一个实例对象，如系统要求提供一个唯一的序列号生成器或资源管理器，或者需要考虑资源消耗太大而只允许创建一个对象。

• 客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该实例

三、简单工厂模式

3.1 定义

简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。

工厂设计模式的原则（OOP七大原则）：

• 开闭原则：一个软件的实体应当对扩展开放，对修改关闭
• 依赖倒转原则：要针对接口编程，不要针对实现编程
• 迪米特法则：只与你直接的朋友通信，而避免和陌生人通信

核心本质：

• 实例化对象不使用new，用工厂方法代替 factory
• 将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类解耦

3.2 说明

在简单工厂模式结构图中包含如下几个角色：

**● Factory（工厂角色）：**工厂角色即工厂类，它是简单工厂模式的核心，负责实现创建所有产品实例的内部逻辑；工厂类可以被外界直接调用，创建所需的产品对象；在工厂类中提供了静态的工厂方法factory Method()，它的返回类型为抽象产品类型Product。

● Product（抽象产品角色）：它是工厂类所创建的所有对象的父类，封装了各种产品对象的公有方法，它的引入将提高系统的灵活性，使得在工厂类中只需定义一个通用的工厂方法，因为所有创建的具体产品对象都是其子类对象。

● Concrete Product（具体产品角色）：它是简单工厂模式的创建目标，所有被创建的对象都充当这个角色的某个具体类的实例。每一个具体产品角色都继承了抽象产品角色，需要实现在抽象产品中声明的抽象方法。

简单工厂模式的主要优点如下：

3.3 使用

举例说明：

package Factory;

/**
 * @author Fantic
 * @create 2021-09-03 15:26
 */

//抽象图表接口：抽象产品类
interface Chart {
    
    
    public void display();
}

//柱状图类：具体产品类
class HistogramChart implements Chart {
    
    
    public HistogramChart() {
    
    
        System.out.println("创建柱状图！");
    }

    public void display() {
    
    
        System.out.println("显示柱状图！");
    }
}


//饼状图类：具体产品类
class PieChart implements Chart {
    
    
    public PieChart() {
    
    
        System.out.println("创建饼状图！");
    }

    public void display() {
    
    
        System.out.println("显示饼状图！");
    }
}


//折线图类：具体产品类
class LineChart implements Chart {
    
    
    public LineChart() {
    
    
        System.out.println("创建折线图！");
    }

    public void display() {
    
    
        System.out.println("显示折线图！");
    }
}



//图表工厂类：工厂类
class ChartFactory {
    
    
    //静态工厂方法
    public static Chart getChart(String type) {
    
    
        Chart chart = null;
        if (type.equalsIgnoreCase("histogram")) {
    
    
            chart = new HistogramChart();
            System.out.println("初始化设置柱状图！");
        } else if (type.equalsIgnoreCase("pie")) {
    
    
            chart = new PieChart();
            System.out.println("初始化设置饼状图！");
        } else if (type.equalsIgnoreCase("line")) {
    
    
            chart = new LineChart();
            System.out.println("初始化设置折线图！");
        }
        return chart;


    }
    
    //方法二:
    public static Chart getHistogramChart(){
    
    
        return new HistogramChart();
    }

    public static Chart getPieChart(){
    
    
        return new PieChart();
    }

    public static Chart getLineChart(){
    
    
        return  new LineChart();
    }


}


// 客户端测试
public class Client {
    
    
    public static void main(String args[]) {
    
    
        Chart chart;
        chart = ChartFactory.getChart("histogram"); //通过静态工厂方法创建产品
        chart.display();


//        PieChart pieChart = new PieChart();
//        pieChart.display();
    }
}
/*
测试结果
创建柱状图！
初始化设置柱状图！
显示柱状图！
*/

3.4 总结

简单工厂模式优点:

1. 工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责，很方便的创建出相应的产品。工厂和产品的职责区分明确。

2. 客户端无需知道所创建具体产品的类名，只需知道参数即可。

3. 也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类

简单工厂模式最大的缺点:

1. 是当有新产品要加入到系统中时，必须修改工厂类，需要在其中加入必要的业务逻辑，这违背了“开闭原则”。
2. 此外，在简单工厂模式中，所有的产品都由同一个工厂创建，工厂类职责较重，业务逻辑较为复杂，具体产品与工厂类之间的耦合度高，严重影响了系统的灵活性和扩展性.

应用场景:

对于产品种类相对较少的情况，考虑使用简单工厂模式。使用简单工厂模式的客户端只需要传入工厂类的参数，不需要关心如何创建对象的逻辑，可以很方便地创建所需产品。

如何实现增加新产品而不影响已有代码？工厂方法模式应运而生，本文将介绍第二种工厂模式——工厂方法模式。

四、工厂方法模式

4.1 定义

工厂方法模式（FACTORY METHOD）是一种常用的类创建型设计模式,此模式的核心精神是封装类中变化的部分，提取其中个性化善变的部分为独立类，通过依赖注入以达到解耦、复用和方便后期维护拓展的目的。

4.2 说明

在工厂方法模式结构图中包含如下几个角色：

● Product（抽象产品）：它是定义产品的接口，是工厂方法模式所创建对象的超类型，也就是产品对象的公共父类。

● Concrete Product（具体产品）：它实现了抽象产品接口，某种类型的具体产品由专门的具体工厂创建，具体工厂和具体产品之间一一对应。

● Factory（抽象工厂）：在抽象工厂类中，声明了工厂方法(Factory Method)，用于返回一个产品。抽象工厂是工厂方法模式的核心，所有创建对象的工厂类都必须实现该接口。

● Concrete Factory（具体工厂）：它是抽象工厂类的子类，实现了抽象工厂中定义的工厂方法，并可由客户端调用，返回一个具体产品类的实例。

与简单工厂模式相比，工厂方法模式最重要的区别是引入了抽象工厂角色，抽象工厂可以是接口，也可以是抽象类

4.3 使用

举例：

//日志记录器接口：抽象产品
interface Logger {
    
    
	public void writeLog();
}
 
//数据库日志记录器：具体产品
class DatabaseLogger implements Logger {
    
    
	public void writeLog() {
    
    
		System.out.println("数据库日志记录。");
	}
}
 
//文件日志记录器：具体产品
class FileLogger implements Logger {
    
    
	public void writeLog() {
    
    
		System.out.println("文件日志记录。");
	}
}
 
//日志记录器工厂接口：抽象工厂
interface LoggerFactory {
    
    
	public Logger createLogger();
}
 
//数据库日志记录器工厂类：具体工厂
class DatabaseLoggerFactory implements LoggerFactory {
    
    
	public Logger createLogger() {
    
    
			//连接数据库，代码省略
			//创建数据库日志记录器对象
			Logger logger = new DatabaseLogger(); 
			//初始化数据库日志记录器，代码省略
			return logger;
	}	
}
 
//文件日志记录器工厂类：具体工厂
class FileLoggerFactory implements LoggerFactory {
    
    
	public Logger createLogger() {
    
    
            //创建文件日志记录器对象
			Logger logger = new FileLogger(); 
			//创建文件，代码省略
			return logger;
	}	
}


// 客户端
class Client {
    
    
	public static void main(String args[]) {
    
    
		LoggerFactory factory;
		Logger logger;
		factory = new FileLoggerFactory(); //可引入配置文件实现
		logger = factory.createLogger();
		logger.writeLog();
	}
}

// 文件日志记录

4.4 总结

工厂方法模式的主要优点:

1. 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。

2. 灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。

3. 典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则

工厂方法模式的主要缺点：

• 类的个数容易过多，增加复杂度
• 增加了系统的抽象性和理解难度
• 抽象产品只能生产一种产品，此弊端可以使用抽象工厂

应用场景：

• 客户只知道创建产品的工厂名，而不知道具体的产品名。如 TCL 电视工厂、海信电视工厂等。
• 创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。
• 客户不关心创建产品的细节，只关心产品的品牌

工厂方法模式通过引入工厂等级结构，解决了简单工厂模式中工厂类职责太重的问题，但由于工厂方法模式中的每个工厂只生产一类产品，可能会导致系统中存在大量的工厂类，势必会增加系统的开销。此时，我们可以考虑将一些相关的产品组成一个“产品族”，由同一个工厂来统一生产，这就是我们将要学习的抽象工厂模式的基本思想。

五、抽象工厂模式

5.1 定义

抽象工厂模式（Abstract Factory Pattern）隶属于设计模式中的创建型模式，用于产品族的构建。抽象工厂是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂是指当有多个抽象角色时使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体情况下，创建多个产品族中的产品对象

5.2 说明

抽象工厂模式的主要角色如下。

1. 抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 new Product()，可以创建多个不同等级的产品。
2. 具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
3. 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
4. 具体产品（Concrete Product）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

5.3 使用

举例说明：

//在本实例中我们对代码进行了大量简化，实际使用时，界面组件的初始化代码较为复杂，还需要使用JDK中一些已有类，为了突出核心代码，在此只提供框架代码和演示输出。
//按钮接口：抽象产品
interface Button {
    
    
	public void display();
}
 
//Spring按钮类：具体产品
class SpringButton implements Button {
    
    
	public void display() {
    
    
		System.out.println("显示浅绿色按钮。");
	}
}
 
//Summer按钮类：具体产品
class SummerButton implements Button {
    
    
	public void display() {
    
    
		System.out.println("显示浅蓝色按钮。");
	}	
}
 
//文本框接口：抽象产品
interface TextField {
    
    
	public void display();
}
 
//Spring文本框类：具体产品
class SpringTextField implements TextField {
    
    
	public void display() {
    
    
		System.out.println("显示绿色边框文本框。");
	}
}
 
//Summer文本框类：具体产品
class SummerTextField implements TextField {
    
    
	public void display() {
    
    
		System.out.println("显示蓝色边框文本框。");
	}	
}
 
//组合框接口：抽象产品
interface ComboBox {
    
    
	public void display();
}
 
//Spring组合框类：具体产品
class SpringComboBox implements ComboBox {
    
    
	public void display() {
    
    
		System.out.println("显示绿色边框组合框。");
	}
}
 
//Summer组合框类：具体产品
class SummerComboBox implements ComboBox {
    
    
	public void display() {
    
    
		System.out.println("显示蓝色边框组合框。");
	}	
}
 
//界面皮肤工厂接口：抽象工厂
interface SkinFactory {
    
    
	public Button createButton();
	public TextField createTextField();
	public ComboBox createComboBox();
}
 
//Spring皮肤工厂：具体工厂
class SpringSkinFactory implements SkinFactory {
    
    
	public Button createButton() {
    
    
		return new SpringButton();
	}
 
	public TextField createTextField() {
    
    
		return new SpringTextField();
	}
 
	public ComboBox createComboBox() {
    
    
		return new SpringComboBox();
	}
}
 
//Summer皮肤工厂：具体工厂
class SummerSkinFactory implements SkinFactory {
    
    
	public Button createButton() {
    
    
		return new SummerButton();
	}
 
	public TextField createTextField() {
    
    
		return new SummerTextField();
	}
 
	public ComboBox createComboBox() {
    
    
		return new SummerComboBox();
	}
}


// 客户端
public class abstractfactorytext {
    
    
    public static void main(String args[]) {
    
    
        //使用抽象层定义
        Button bt;
        TextField tf;
        ComboBox cb;
        SummerSkinFactory factory = new SummerSkinFactory();
        bt = factory.createButton();
        tf = factory.createTextField();
        cb = factory.createComboBox();
        bt.display();
        tf.display();
        cb.display();
    }

}

5.4 总结

抽象工厂模式的优点：

• 可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
• 当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。
• 抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。

抽象工厂模式的缺点：

• 产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度

应用场景：

1. 当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。
2. 系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
3. 系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。

六、模板方法模式

6.1 定义

模板方法模式定义了一个算法的步骤，并允许子类别为一个或多个步骤提供其实践方式

6.2 说明

模板方法模式包含如下两个角色：

1）抽象类/抽象模板（Abstract Class）

抽象模板类，负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成。这些方法的定义如下。

1. **模板方法：**定义了算法的骨架，按某种顺序调用其包含的基本方法。

2. **基本方法：**是整个算法中的一个步骤，包含以下几种类型。

   • 抽象方法：在抽象类中声明，由具体子类实现。
   • 具体方法：在抽象类中已经实现，在具体子类中可以继承或重写它。
   • 钩子方法：在抽象类中已经实现，包括用于判断的逻辑方法和需要子类重写的空方法两种。

2）具体子类/具体实现（Concrete Class）

具体实现类，实现抽象类中所定义的抽象方法和钩子方法，它们是一个顶级逻辑的一个组成步骤。

6.3 使用

在模板方法模式中，抽象类的典型代码如下：

    public class TemplateMethodPattern {
    
    
        public static void main(String[] args) {
    
    
            AbstractClass tm = new ConcreteClass();
            tm.TemplateMethod();
        }
    }
    //抽象类
    abstract class AbstractClass {
    
    
        //模板方法
        public void TemplateMethod() {
    
    
            SpecificMethod();
            abstractMethod1();
            abstractMethod2();
        }
        //具体方法
        public void SpecificMethod() {
    
    
            System.out.println("抽象类中的具体方法被调用...");
        }
        //抽象方法1
        public abstract void abstractMethod1();
        //抽象方法2
        public abstract void abstractMethod2();
    }
    //具体子类
    class ConcreteClass extends AbstractClass {
    
    
        public void abstractMethod1() {
    
    
            System.out.println("抽象方法1的实现被调用...");
        }
        public void abstractMethod2() {
    
    
            System.out.println("抽象方法2的实现被调用...");
        }
    }

//输出结果
/*
*抽象类中的具体方法被调用...
抽象方法1的实现被调用...
抽象方法2的实现被调用...
*/

钩子方法的使用：

    public class HookTemplateMethod {
    
    
        public static void main(String[] args) {
    
    
            HookAbstractClass tm = new HookConcreteClass();
            tm.TemplateMethod();
        }
    }
    //含钩子方法的抽象类
    abstract class HookAbstractClass {
    
    
        //模板方法
        public void TemplateMethod() {
    
    
            abstractMethod1();
            HookMethod1();
            if (HookMethod2()) {
    
    
                SpecificMethod();
            }
            abstractMethod2();
        }
        //具体方法
        public void SpecificMethod() {
    
    
            System.out.println("抽象类中的具体方法被调用...");
        }
        //钩子方法1
        public void HookMethod1() {
    
    
        }
        //钩子方法2
        public boolean HookMethod2() {
    
    
            return true;
        }
        //抽象方法1
        public abstract void abstractMethod1();
        //抽象方法2
        public abstract void abstractMethod2();
    }
    //含钩子方法的具体子类
    class HookConcreteClass extends HookAbstractClass {
    
    
        public void abstractMethod1() {
    
    
            System.out.println("抽象方法1的实现被调用...");
        }
        public void abstractMethod2() {
    
    
            System.out.println("抽象方法2的实现被调用...");
        }
        public void HookMethod1() {
    
    
            System.out.println("钩子方法1被重写...");
        }
        public boolean HookMethod2() {
    
    
            return false;
        }
    }
    
    /**输出方式结果
 *
 * 抽象方法1的实现被调用...
 * 钩子方法1被重写...
 * 抽象方法2的实现被调用...
 */

6.4 总结

模板方法模式的主要优点：

1. 它封装了不变部分，扩展可变部分。它把认为是不变部分的算法封装到父类中实现，而把可变部分算法由子类继承实现，便于子类继续扩展。
2. 它在父类中提取了公共的部分代码，便于代码复用。
3. 部分方法是由子类实现的，因此子类可以通过扩展方式增加相应的功能，符合开闭原则。

主要缺点：

1. 对每个不同的实现都需要定义一个子类，这会导致类的个数增加，系统更加庞大，设计也更加抽象，间接地增加了系统实现的复杂度。
2. 父类中的抽象方法由子类实现，子类执行的结果会影响父类的结果，这导致一种反向的控制结构，它提高了代码阅读的难度。
3. 由于继承关系自身的缺点，如果父类添加新的抽象方法，则所有子类都要改一遍。

应用场景：

1. 算法的整体步骤很固定，但其中个别部分易变时，这时候可以使用模板方法模式，将容易变的部分抽象出来，供子类实现。
2. 当多个子类存在公共的行为时，可以将其提取出来并集中到一个公共父类中以避免代码重复。首先，要识别现有代码中的不同之处，并且将不同之处分离为新的操作。最后，用一个调用这些新的操作的模板方法来替换这些不同的代码。
3. 当需要控制子类的扩展时，模板方法只在特定点调用钩子操作，这样就只允许在这些点进行扩展。

七、适配器模式

7.1 定义

将一个类的接口转换成客户希望的另外一个接口，使接口不兼容的那些类可以一起工作。

7.2 说明

适配器模式（Adapter）包含以下主要角色。

1. 目标（Target）接口：当前系统业务所期待的接口，它可以是抽象类或接口。
2. 适配者（Adaptee）类：它是被访问和适配的现存组件库中的组件接口。
3. 适配器（Adapter）类：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者。

7.3 使用

(1) 类适配器模式的代码如下

//目标接口
interface Target
{
    
    
    public void request();
}
//适配者接口
class Adaptee
{
    
    
    public void specificRequest()
    {
    
           
        System.out.println("适配者中的业务代码被调用！");
    }
}
//类适配器类
class ClassAdapter extends Adaptee implements Target
{
    
    
    public void request()
    {
    
    
        specificRequest();
    }
}
//客户端代码
public class ClassAdapterTest
{
    
    
    public static void main(String[] args)
    {
    
    
        System.out.println("类适配器模式测试：");
        Target target = new ClassAdapter();
        target.request();
    }
}

(2)对象适配器模式的代码如下

//对象适配器类
class ObjectAdapter implements Target
{
    
    
    private Adaptee adaptee;
    public ObjectAdapter(Adaptee adaptee)
    {
    
    
        this.adaptee=adaptee;
    }
    public void request()
    {
    
    
        adaptee.specificRequest();
    }
}
//客户端代码
public class ObjectAdapterTest
{
    
    
    public static void main(String[] args)
    {
    
    
        System.out.println("对象适配器模式测试：");
        Adaptee adaptee = new Adaptee();
        Target target = new ObjectAdapter(adaptee);
        target.request();
    }
}

适配器模式（Adapter）可扩展为双向适配器模式，双向适配器类既可以把适配者接口转换成目标接口，也可以把目标接口转换成适配者接口

//目标接口
interface TwoWayTarget
{
    
    
    public void request();
}
//适配者接口
interface TwoWayAdaptee
{
    
    
    public void specificRequest();
}
//目标实现
class TargetRealize implements TwoWayTarget
{
    
    
    public void request()
    {
    
           
        System.out.println("目标代码被调用！");
    }
}
//适配者实现
class AdapteeRealize implements TwoWayAdaptee
{
    
    
    public void specificRequest()
    {
    
           
        System.out.println("适配者代码被调用！");
    }
}
//双向适配器
class TwoWayAdapter  implements TwoWayTarget,TwoWayAdaptee
{
    
    
    private TwoWayTarget target;
    private TwoWayAdaptee adaptee;
    public TwoWayAdapter(TwoWayTarget target)
    {
    
    
        this.target=target;
    }
    public TwoWayAdapter(TwoWayAdaptee adaptee)
    {
    
    
        this.adaptee=adaptee;
    }
    public void request()
    {
    
    
        adaptee.specificRequest();
    }
    public void specificRequest()
    {
    
           
        target.request();
    }
}
//客户端代码
public class TwoWayAdapterTest
{
    
    
    public static void main(String[] args)
    {
    
    
        System.out.println("目标通过双向适配器访问适配者：");
        TwoWayAdaptee adaptee=new AdapteeRealize();
        TwoWayTarget target=new TwoWayAdapter(adaptee);
        target.request();
        System.out.println("-------------------");
        System.out.println("适配者通过双向适配器访问目标：");
        target=new TargetRealize();
        adaptee=new TwoWayAdapter(target);
        adaptee.specificRequest();
    }
}

7.4 总结

该模式的主要优点：

• 客户端通过适配器可以透明地调用目标接口。
• 复用了现存的类，程序员不需要修改原有代码而重用现有的适配者类。
• 将目标类和适配者类解耦，解决了目标类和适配者类接口不一致的问题。
• 在很多业务场景中符合开闭原则。

缺点：

• 适配器编写过程需要结合业务场景全面考虑，可能会增加系统的复杂性。
• 增加代码阅读难度，降低代码可读性，过多使用适配器会使系统代码变得凌乱

应用场景：

• 以前开发的系统存在满足新系统功能需求的类，但其接口同新系统的接口不一致。
• 使用第三方提供的组件，但组件接口定义和自己要求的接口定义不同。

八、责任链模式

8.1 定义

避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。职责链模式是一种对象行为型模式。

8.2 说明

职责链模式主要包含以下角色。

1. 抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
2. 具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
3. 客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。

8.3 使用

职责链模式的实现代码如下：

public class ChainOfResponsibilityPattern {
    
    
    public static void main(String[] args) {
    
    
        //组装责任链
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        handler1.setNext(handler2);
        //提交请求
        handler1.handleRequest("two");
    }
}
//抽象处理者角色
abstract class Handler {
    
    
    private Handler next;
    public void setNext(Handler next) {
    
    
        this.next = next;
    }
    public Handler getNext() {
    
    
        return next;
    }
    //处理请求的方法
    public abstract void handleRequest(String request);
}
//具体处理者角色1
class ConcreteHandler1 extends Handler {
    
    
    public void handleRequest(String request) {
    
    
        if (request.equals("one")) {
    
    
            System.out.println("具体处理者1负责处理该请求！");
        } else {
    
    
            if (getNext() != null) {
    
    
                getNext().handleRequest(request);
            } else {
    
    
                System.out.println("没有人处理该请求！");
            }
        }
    }
}
//具体处理者角色2
class ConcreteHandler2 extends Handler {
    
    
    public void handleRequest(String request) {
    
    
        if (request.equals("two")) {
    
    
            System.out.println("具体处理者2负责处理该请求！");
        } else {
    
    
            if (getNext() != null) {
    
    
                getNext().handleRequest(request);
            } else {
    
    
                System.out.println("没有人处理该请求！");
            }
        }
    }
}

实例：请假流程

public class LeaveApprovalTest {
    
    
    public static void main(String[] args) {
    
    
        //组装责任链
        Leader teacher1 = new ClassAdviser();
        Leader teacher2 = new DepartmentHead();
        Leader teacher3 = new Dean();
        //Leader teacher4=new DeanOfStudies();
        teacher1.setNext(teacher2);
        teacher2.setNext(teacher3);
        //teacher3.setNext(teacher4);
        //提交请求
        teacher1.handleRequest(8);
    }
}
//抽象处理者：领导类
abstract class Leader {
    
    
    private Leader next;
    public void setNext(Leader next) {
    
    
        this.next = next;
    }
    public Leader getNext() {
    
    
        return next;
    }
    //处理请求的方法
    public abstract void handleRequest(int LeaveDays);
}
//具体处理者1：班主任类
class ClassAdviser extends Leader {
    
    
    public void handleRequest(int LeaveDays) {
    
    
        if (LeaveDays <= 2) {
    
    
            System.out.println("班主任批准您请假" + LeaveDays + "天。");
        } else {
    
    
            if (getNext() != null) {
    
    
                getNext().handleRequest(LeaveDays);
            } else {
    
    
                System.out.println("请假天数太多，没有人批准该假条！");
            }
        }
    }
}
//具体处理者2：系主任类
class DepartmentHead extends Leader {
    
    
    public void handleRequest(int LeaveDays) {
    
    
        if (LeaveDays <= 7) {
    
    
            System.out.println("系主任批准您请假" + LeaveDays + "天。");
        } else {
    
    
            if (getNext() != null) {
    
    
                getNext().handleRequest(LeaveDays);
            } else {
    
    
                System.out.println("请假天数太多，没有人批准该假条！");
            }
        }
    }
}
//具体处理者3：院长类
class Dean extends Leader {
    
    
    public void handleRequest(int LeaveDays) {
    
    
        if (LeaveDays <= 10) {
    
    
            System.out.println("院长批准您请假" + LeaveDays + "天。");
        } else {
    
    
            if (getNext() != null) {
    
    
                getNext().handleRequest(LeaveDays);
            } else {
    
    
                System.out.println("请假天数太多，没有人批准该假条！");
            }
        }
    }
}
//具体处理者4：教务处长类
class DeanOfStudies extends Leader {
    
    
    public void handleRequest(int LeaveDays) {
    
    
        if (LeaveDays <= 20) {
    
    
            System.out.println("教务处长批准您请假" + LeaveDays + "天。");
        } else {
    
    
            if (getNext() != null) {
    
    
                getNext().handleRequest(LeaveDays);
            } else {
    
    
                System.out.println("请假天数太多，没有人批准该假条！");
            }
        }
    }
}

8.4 总结

责任链模式是一种对象行为型模式，主要优点：

1. 降低了对象之间的耦合度。该模式使得一个对象无须知道到底是哪一个对象处理其请求以及链的结构，发送者和接收者也无须拥有对方的明确信息。
2. 增强了系统的可扩展性。可以根据需要增加新的请求处理类，满足开闭原则。
3. 增强了给对象指派职责的灵活性。当工作流程发生变化，可以动态地改变链内的成员或者调动它们的次序，也可动态地新增或者删除责任。
4. 责任链简化了对象之间的连接。每个对象只需保持一个指向其后继者的引用，不需保持其他所有处理者的引用，这避免了使用众多的 if 或者 if···else 语句。
5. 责任分担。每个类只需要处理自己该处理的工作，不该处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。

主要缺点：

1. 不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理。
2. 对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能将受到一定影响。
3. 职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用。

应用场景：

前边已经讲述了关于责任链模式的结构与特点，下面介绍其应用场景，责任链模式通常在以下几种情况使用。

1. 多个对象可以处理一个请求，但具体由哪个对象处理该请求在运行时自动确定。
2. 可动态指定一组对象处理请求，或添加新的处理者。
3. 需要在不明确指定请求处理者的情况下，向多个处理者中的一个提交请求。

九、观察者模式

9.1 定义

指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

9.2 说明

观察者模式的主要角色如下。

1. 抽象主题（Subject）角色：也叫抽象目标类，它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。
2. 具体主题（Concrete Subject）角色：也叫具体目标类，它实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。
3. 抽象观察者（Observer）角色：它是一个抽象类或接口，它包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。
4. 具体观察者（Concrete Observer）角色：实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。

9.3使用

import java.util.*;
public class ObserverPattern {
    
    
    public static void main(String[] args) {
    
    
        Subject subject = new ConcreteSubject();
        Observer obs1 = new ConcreteObserver1();
        Observer obs2 = new ConcreteObserver2();
        subject.add(obs1);
        subject.add(obs2);
        subject.notifyObserver();
    }
}
//抽象目标
abstract class Subject {
    
    
    protected List<Observer> observers = new ArrayList<Observer>();
    //增加观察者方法
    public void add(Observer observer) {
    
    
        observers.add(observer);
    }
    //删除观察者方法
    public void remove(Observer observer) {
    
    
        observers.remove(observer);
    }
    public abstract void notifyObserver(); //通知观察者方法
}
//具体目标
class ConcreteSubject extends Subject {
    
    
    public void notifyObserver() {
    
    
        System.out.println("具体目标发生改变...");
        System.out.println("--------------");
        for (Object obs : observers) {
    
    
            ((Observer) obs).response();
        }
    }
}
//抽象观察者
interface Observer {
    
    
    void response(); //反应
}
//具体观察者1
class ConcreteObserver1 implements Observer {
    
    
    public void response() {
    
    
        System.out.println("具体观察者1作出反应！");
    }
}
//具体观察者1
class ConcreteObserver2 implements Observer {
    
    
    public void response() {
    
    
        System.out.println("具体观察者2作出反应！");
    }
}

举例：人名币升值对进出口公司影响：

import java.util.*;
public class RMBrateTest {
    
    
    public static void main(String[] args) {
    
    
        Rate rate = new RMBrate();
        Company watcher1 = new ImportCompany();
        Company watcher2 = new ExportCompany();
        rate.add(watcher1);
        rate.add(watcher2);
        rate.change(10);
        rate.change(-9);
    }
}
//抽象目标：汇率
abstract class Rate {
    
    
    protected List<Company> companys = new ArrayList<Company>();
    //增加观察者方法
    public void add(Company company) {
    
    
        companys.add(company);
    }
    //删除观察者方法
    public void remove(Company company) {
    
    
        companys.remove(company);
    }
    public abstract void change(int number);
}
//具体目标：人民币汇率
class RMBrate extends Rate {
    
    
    public void change(int number) {
    
    
        for (Company obs : companys) {
    
    
            ((Company) obs).response(number);
        }
    }
}
//抽象观察者：公司
interface Company {
    
    
    void response(int number);
}
//具体观察者1：进口公司
class ImportCompany implements Company {
    
    
    public void response(int number) {
    
    
        if (number > 0) {
    
    
            System.out.println("人民币汇率升值" + number + "个基点，降低了进口产品成本，提升了进口公司利润率。");
        } else if (number < 0) {
    
    
            System.out.println("人民币汇率贬值" + (-number) + "个基点，提升了进口产品成本，降低了进口公司利润率。");
        }
    }
}
//具体观察者2：出口公司
class ExportCompany implements Company {
    
    
    public void response(int number) {
    
    
        if (number > 0) {
    
    
            System.out.println("人民币汇率升值" + number + "个基点，降低了出口产品收入，降低了出口公司的销售利润率。");
        } else if (number < 0) {
    
    
            System.out.println("人民币汇率贬值" + (-number) + "个基点，提升了出口产品收入，提升了出口公司的销售利润率。");
        }
    }
}

在java 中，通过 java.util.Observable 类和 java.util.Observer 接口定义了观察者模式，只要实现它们的子类就可以编写观察者模式实例。

1. Observable类

Observable 类是抽象目标类，它有一个 Vector 向量，用于保存所有要通知的观察者对象，下面来介绍它最重要的 3 个方法。

1. void addObserver(Observer o) 方法：用于将新的观察者对象添加到向量中。
2. void notifyObservers(Object arg) 方法：调用向量中的所有观察者对象的 update() 方法，通知它们数据发生改变。通常越晚加入向量的观察者越先得到通知。
3. void setChange() 方法：用来设置一个 boolean 类型的内部标志位，注明目标对象发生了变化。当它为真时，notifyObservers() 才会通知观察者。

2. Observer 接口

Observer 接口是抽象观察者，它监视目标对象的变化，当目标对象发生变化时，观察者得到通知，并调用 void update(Observable o,Object arg) 方法，进行相应的工作。

import java.util.Observer;
import java.util.Observable;
public class CrudeOilFutures {
    
    
    public static void main(String[] args) {
    
    
        OilFutures oil = new OilFutures();
        Observer bull = new Bull(); //多方
        Observer bear = new Bear(); //空方
        oil.addObserver(bull);
        oil.addObserver(bear);
        oil.setPrice(10);
        oil.setPrice(-8);
    }
}
//具体目标类：原油期货
class OilFutures extends Observable {
    
    
    private float price;
    public float getPrice() {
    
    
        return this.price;
    }
    public void setPrice(float price) {
    
    
        super.setChanged();  //设置内部标志位，注明数据发生变化
        super.notifyObservers(price);    //通知观察者价格改变了
        this.price = price;
    }
}
//具体观察者类：多方
class Bull implements Observer {
    
    
    public void update(Observable o, Object arg) {
    
    
        Float price = ((Float) arg).floatValue();
        if (price > 0) {
    
    
            System.out.println("油价上涨" + price + "元，多方高兴了！");
        } else {
    
    
            System.out.println("油价下跌" + (-price) + "元，多方伤心了！");
        }
    }
}
//具体观察者类：空方
class Bear implements Observer {
    
    
    public void update(Observable o, Object arg) {
    
    
        Float price = ((Float) arg).floatValue();
        if (price > 0) {
    
    
            System.out.println("油价上涨" + price + "元，空方伤心了！");
        } else {
    
    
            System.out.println("油价下跌" + (-price) + "元，空方高兴了！");
        }
    }
}

9.4 总结

观察者模式是一种对象行为型模式，主要优点：

1. 降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。符合依赖倒置原则。
2. 目标与观察者之间建立了一套触发机制。

主要缺点：

1. 目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。
2. 当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。

应用场景：

1. 对象间存在一对多关系，一个对象的状态发生改变会影响其他对象。
2. 当一个抽象模型有两个方面，其中一个方面依赖于另一方面时，可将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
3. 实现类似广播机制的功能，不需要知道具体收听者，只需分发广播，系统中感兴趣的对象会自动接收该广播。
4. 多层级嵌套使用，形成一种链式触发机制，使得事件具备跨域（跨越两种观察者类型）通知。

十、建造者模式

10.1 定义

将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成

10.2 说明

建造者（Builder）模式的主要角色如下。

1. 产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。
2. 抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。
3. 具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。
4. 指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

10.3 使用

   //产品角色：包含多个组成部件的复杂对象。
   class Product {
    
    
        private String partA;
        private String partB;
        private String partC;
        public void setPartA(String partA) {
    
    
            this.partA = partA;
        }
        public void setPartB(String partB) {
    
    
            this.partB = partB;
        }
        public void setPartC(String partC) {
    
    
            this.partC = partC;
        }
        public void show() {
    
    
            //显示产品的特性
        }
    }
    // 抽象建造者：包含创建产品各个子部件的抽象方法。 
        abstract class Builder {
    
    
        //创建产品对象
        protected Product product = new Product();
        public abstract void buildPartA();
        public abstract void buildPartB();
        public abstract void buildPartC();
        //返回产品对象
        public Product getResult() {
    
    
            return product;
        }
    }
    
    //具体建造者：实现了抽象建造者接口。
        public class ConcreteBuilder extends Builder {
    
    
        public void buildPartA() {
    
    
            product.setPartA("建造 PartA");
        }
        public void buildPartB() {
    
    
            product.setPartB("建造 PartB");
        }
        public void buildPartC() {
    
    
            product.setPartC("建造 PartC");
        }
    }
    
    
    //指挥者：调用建造者中的方法完成复杂对象的创建。
        class Director {
    
    
        private Builder builder;
        public Director(Builder builder) {
    
    
            this.builder = builder;
        }
        //产品构建与组装方法
        public Product construct() {
    
    
            builder.buildPartA();
            builder.buildPartB();
            builder.buildPartC();
            return builder.getResult();
        }
    }
    //客户类。
        public class Client {
    
    
        public static void main(String[] args) {
    
    
            Builder builder = new ConcreteBuilder();
            Director director = new Director(builder);
            Product product = director.construct();
            product.show();
        }
    }

10.4 总结

该模式的**主要优点**：

1. 封装性好，构建和表示分离。
2. 扩展性好，各个具体的建造者相互独立，有利于系统的解耦。
3. 客户端不必知道产品内部组成的细节，建造者可以对创建过程逐步细化，而不对其它模块产生任何影响，便于控制细节风险。

缺点：

1. 产品的组成部分必须相同，这限制了其使用范围。
2. 如果产品的内部变化复杂，如果产品内部发生变化，则建造者也要同步修改，后期维护成本较大。

应用场景：

• 相同的方法，不同的执行顺序，产生不同的结果。
• 多个部件或零件，都可以装配到一个对象中，但是产生的结果又不相同。
• 产品类非常复杂，或者产品类中不同的调用顺序产生不同的作用。
• 初始化一个对象特别复杂，参数多，而且很多参数都具有默认值。

通过前面的学习，我们已经了解了建造者模式，那么它和工厂模式有什么区别呢？

• 建造者模式更加注重方法的调用顺序，工厂模式注重创建对象。
• 创建对象的力度不同，建造者模式创建复杂的对象，由各种复杂的部件组成，工厂模式创建出来的对象都一样
• 关注重点不一样，工厂模式只需要把对象创建出来就可以了，而建造者模式不仅要创建出对象，还要知道对象由哪些部件组成。
• 建造者模式根据建造过程中的顺序不一样，最终对象部件组成也不一样。

十一、代理模式

11.1 定义

由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。

11.2 说明

代理模式的主要角色如下：

1. Subject（抽象主题角色）：它声明了真实主题和代理主题的共同接口，这样一来在任何使用真实主题的地方都可以使用代理主题，客户端通常需要针对抽象主题角色进行编程。

2. 真实主题（Real Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。

3. 代理（Proxy）类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。

11.3 使用

静态代理模式的实现代码如下：

public class ProxyTest {
    
    
    public static void main(String[] args) {
    
    
        Proxy proxy = new Proxy();
        proxy.Request();
    }
}
//抽象主题
interface Subject {
    
    
    void Request();
}
//真实主题
class RealSubject implements Subject {
    
    
    public void Request() {
    
    
        System.out.println("访问真实主题方法...");
    }
}
//代理
class Proxy implements Subject {
    
    
    private RealSubject realSubject;
    public void Request() {
    
    
        if (realSubject == null) {
    
    
            realSubject = new RealSubject();
        }
        preRequest();
        realSubject.Request();
        postRequest();
    }
    public void preRequest() {
    
    
        System.out.println("访问真实主题之前的预处理。");
    }
    public void postRequest() {
    
    
        System.out.println("访问真实主题之后的后续处理。");
    }
}

举例二：

package Proxy;

/**
 * @author Fantic
 * @create 2021-09-03 10:49
 */
public class StaticProxy2{
    
    
/*
分析：在这个过程中，你直接接触的就是中介，就如同现实生活中的样子，你看不到房东，
但是你依旧租到了房东的房子通过代理，这就是所谓的代理模式，程序源自于生活，
所以学编程的人，一般能够更加抽象的看待生活中发生的事情。
 */

    //客户类，一般客户都会去找代理！
        public static void main(String[] args) {
    
    
            //房东要租房
            Host host = new Host();
            //中介帮助房东
            StaticProxy proxy = new StaticProxy(host);

            //你去找中介！
            proxy.rent();
        }

}

//抽象角色：租房
interface Rent {
    
    
    public void rent();
}

//真实角色: 房东，房东要出租房子
class Host implements Rent{
    
    
    public void rent() {
    
    
        System.out.println("房屋出租");
    }
}

//代理角色：中介
class StaticProxy implements Rent {
    
    

    private Host host;
    public StaticProxy() {
    
    

    }
    public StaticProxy(Host host) {
    
    
        this.host = host;
    }

    //租房
    public void rent(){
    
    
        seeHouse();
        host.rent();
        fare();
    }
    //看房
    public void seeHouse(){
    
    
        System.out.println("带房客看房");
    }
    //收中介费
    public void fare(){
    
    
        System.out.println("收中介费");
    }
}

静态代理案例3：

package Proxy;

/**
 * @author Fantic
 * @create 2021-09-03 14:12
 */
//创建一个抽象角色，比如咋们平时做的用户业务，抽象起来就是增删改查！
//抽象角色：增删改查业务
interface UserService {
    
    
    void add();
    void delete();
    void update();
    void query();
}

//需要一个真实对象来完成这些增删改查操作
//真实对象，完成增删改查操作的人
class UserServiceImpl implements UserService {
    
    

    //对接口的方法进行重写
    public void add() {
    
    
        System.out.println("增加了一个用户");
    }

    public void delete() {
    
    
        System.out.println("删除了一个用户");
    }

    public void update() {
    
    
        System.out.println("更新了一个用户");
    }

    public void query() {
    
    
        System.out.println("查询了一个用户");
    }
}


//代理角色，在这里面增加日志的实现
class UserServiceProxy implements UserService {
    
    
    //使用组合形式调用真实对象为成员变量
    private UserServiceImpl userService;

    public void setUserService(UserServiceImpl userService) {
    
    
        this.userService = userService;
    }

    public void add() {
    
    
        log("add");
        userService.add();
    }

    public void delete() {
    
    
        log("delete");
        userService.delete();
    }

    public void update() {
    
    
        log("update");
        userService.update();
    }

    public void query() {
    
    
        log("query");
        userService.query();
    }

    public static void log(String msg){
    
    
        System.out.println("执行了"+msg+"方法");
    }

}


//虽然以上代码较为繁复，但是并没有修改原有代码，只是通过代理的方式进行调用
public class StaticProxy3 {
    
    
    public static void main(String[] args) {
    
    
        //真实业务
        UserServiceImpl userService = new UserServiceImpl();
        //代理类
        UserServiceProxy proxy = new UserServiceProxy();
        //使用代理类实现日志功能！
        proxy.setUserService(userService);

        proxy.add();
        System.out.println();
        proxy.delete();
        System.out.println();
        proxy.query();
        System.out.println();
        proxy.update();
    }
}

动态代理：

JDK的动态代理需要了解两个类

核心 : InvocationHandler 和 Proxy ， 打开JDK帮助文档看看

​ InvocationHandler：调用处理程序

InvocationHandler是由代理实例的调用处理程序实现的接口,每个代理实例都有一个关联的调用处理程序。

Proxy提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超级类。

可以进入java常用类的API中寻找，了解相关内容：

loader -类加载器来定义代理类

interfaces -代理类实现的接口列表

h -调度方法调用的调用处理函数

代码实现举例1：

package Proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @author Fantic
 * @create 2021-09-03 10:29
 */
public class DynamicProxy {
    
    
    public static void main(String[] args) {
    
    
        //真实角色
        Host host = new Host();
        //代理实例的调用处理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setRent(host); //将真实角色放置进去！
        Rent proxy = (Rent)pih.getProxy(); //动态生成对应的代理类！
        proxy.rent();
    }
}


//抽象角色和真实角色不变，直接调用静态变量中的
// 动态代理只是使用改变了代理模式，将特有功能的代理模式改为公共的


//代理角色
class ProxyInvocationHandler implements InvocationHandler {
    
    
    //都是采用组合的方式将
    private Rent rent;
    public void setRent(Rent rent) {
    
    
        this.rent = rent;
    }

    //生成代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色
    public Object getProxy(){
    
    
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                rent.getClass().getInterfaces(),this);
    }

    // proxy : 代理类 method : 代理类的调用处理程序的方法对象.
    // 处理代理实例上的方法调用并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
    
        seeHouse();
        //核心：本质利用反射实现！
        Object result = method.invoke(rent, args);
        fare();
        return result;
    }

    //看房
    public void seeHouse(){
    
    
        System.out.println("带房客看房");
    }
    //收中介费
    public void fare(){
    
    
        System.out.println("收中介费");
    }

}

动态代理通用代码：

package Proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @author Fantic
 * @create 2021-09-03 15:10
 */

//利用了UserServiceImpl的真是对应抽象角色
public class DynamicProxy2 {
    
    
    public static void main(String[] args) {
    
    
        //真实对象
        UserServiceImpl userService = new UserServiceImpl();
        //代理对象的调用处理程序
        ProxyInvocationHandler2 pih = new ProxyInvocationHandler2();
        pih.setTarget(userService); //设置要代理的对象
        UserService proxy = (UserService)pih.getProxy(); //动态生成代理类！
        proxy.delete();
        proxy.add();
        proxy.query();
        proxy.update();
    }
}



class ProxyInvocationHandler2 implements InvocationHandler {
    
    
    private Object target;

    public void setTarget(Object target) {
    
    
        this.target = target;
    }

    //生成代理类
    public Object getProxy(){
    
    
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this);
    }

    // proxy : 代理类
    // method : 代理类的调用处理程序的方法对象.
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
    
        //利用反射的方法直接调用出对应的方法名
        log(method.getName());
        Object result = method.invoke(target, args);
        return result;
    }

    public void log(String methodName){
    
    
        System.out.println("执行了" + methodName + "方法");
    }

}

我们可以对InvocationHandler看做一个中介类，中介类持有一个被代理对象，在invoke方法中调用了被代理对象的相应方法。通过聚合方式持有被代理对象的引用，把外部对invoke的调用最终都转为对被代理对象的调用。

代理类调用自己方法时，通过自身持有的中介类对象来调用中介类对象的invoke方法，从而达到代理执行被代理对象的方法。也就是说，动态代理通过中介类实现了具体的代理功能。

动态代理也叫 JDK 代理或接口代理，有以下特点：

• 代理对象不需要实现接口
• 代理对象的生成是利用 JDK 的 API 动态的在内存中构建代理对象
• 能在代码运行时动态地改变某个对象的代理，并且能为代理对象动态地增加方法、增加行为

11.4 总结

代理模式的主要优点：

• 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；
• 代理对象可以扩展目标对象的功能；
• 代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度，增加了程序的可扩展性

主要缺点：

• 代理模式会造成系统设计中类的数量增加
• 在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢；
• 增加了系统的复杂度；

应用场景：

• 远程代理，这种方式通常是为了隐藏目标对象存在于不同地址空间的事实，方便客户端访问。例如，用户申请某些网盘空间时，会在用户的文件系统中建立一个虚拟的硬盘，用户访问虚拟硬盘时实际访问的是网盘空间。

• 虚拟代理，这种方式通常用于要创建的目标对象开销很大时。例如，下载一幅很大的图像需要很长时间，因某种计算比较复杂而短时间无法完成，这时可以先用小比例的虚拟代理替换真实的对象，消除用户对服务器慢的感觉。

• 安全代理，控制对一个对象的访问，可以给不同的用户提供不同级别的使用权限。

十二、装饰者模式

12.1 定义

指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。

12.2 说明

装饰器模式主要包含以下角色。

1. 抽象构件（Component）角色：定义一个抽象接口以规范准备接收附加责任的对象。
2. 具体构件（Concrete Component）角色：实现抽象构件，通过装饰角色为其添加一些职责。
3. 抽象装饰（Decorator）角色：继承抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能。
4. 具体装饰（Concrete Decorator）角色：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任。

12.3 使用

//抽象界面构件类：抽象构件类，为了突出与模式相关的核心代码，对原有控件代码进行了大量的简化
abstract class Component
{
    
    
    public  abstract void display();
}

//窗体类：具体构件类
class Window extends Component
{
    
    
    public  void display()
    {
    
    
        System.out.println("显示窗体！");
    }
}

//文本框类：具体构件类
class TextBox extends Component
{
    
    
    public  void display()
    {
    
    
        System.out.println("显示文本框！");
    }
}

//列表框类：具体构件类
class ListBox extends Component
{
    
    
    public  void display()
    {
    
    
        System.out.println("显示列表框！");
    }
}

//构件装饰类：抽象装饰类
class ComponentDecorator extends Component
{
    
    
    private Component component;  //维持对抽象构件类型对象的引用
    
    public ComponentDecorator(Component  component)  //注入抽象构件类型的对象
    {
    
    
        this.component = component;
    }
    public void display()
    {
    
    
        component.display();
    }
}

//滚动条装饰类：具体装饰类
class ScrollBarDecorator extends  ComponentDecorator

{
    
    
    public ScrollBarDecorator(Component  component)
    {
    
    
        super(component);
    }

    
    public void display()
    {
    
    
        this.setScrollBar();
        super.display();
    }
    
    public  void setScrollBar()
    {
    
    
        System.out.println("为构件增加滚动条！");
    }
}

//黑色边框装饰类：具体装饰类
class BlackBorderDecorator extends  ComponentDecorator
{
    
    
    public BlackBorderDecorator(Component  component)
    {
    
    
        super(component);
    }
    public void display()
    {
    
    
        this.setBlackBorder();
        super.display();
    }
    public  void setBlackBorder()
    {
    
    
        System.out.println("为构件增加黑色边框！");
    }

}
class Client {
    
    
    public  static void main(String args[])
    {
    
    
        Component  component,componentSB,componentBB; //全部使用抽象构件定义
        component = new Window();
        componentSB = new  ScrollBarDecorator(component);
        componentBB = new  BlackBorderDecorator(componentSB); //将装饰了一次之后的对象继续注入到另一个装饰类中，进行第二次装饰
        componentBB.display();

    }

}

12.4 总结

装饰器模式的**主要优点**：

• 装饰器是继承的有力补充，比继承灵活，在不改变原有对象的情况下，动态的给一个对象扩展功能，即插即用
• 通过使用不用装饰类及这些装饰类的排列组合，可以实现不同效果
• 装饰器模式完全遵守开闭原则

其**主要缺点**是：装饰器模式会增加许多子类，过度使用会增加程序得复杂性。

应用场景：

• 当需要给一个现有类添加附加职责，而又不能采用生成子类的方法进行扩充时。例如，该类被隐藏或者该类是终极类或者采用继承方式会产生大量的子类。
• 当需要通过对现有的一组基本功能进行排列组合而产生非常多的功能时，采用继承关系很难实现，而采用装饰器模式却很好实现。
• 当对象的功能要求可以动态地添加，也可以再动态地撤销时。

装饰器模式在 Java语言中的最著名的应用莫过于 Java I/O 标准库的设计了。例如，InputStream 的子类 FilterInputStream，OutputStream 的子类 FilterOutputStream，Reader 的子类 BufferedReader 以及 FilterReader，还有 Writer 的子类 BufferedWriter、FilterWriter 以及 PrintWriter 等，它们都是抽象装饰类。

十三、策略模式

13.1 定义

该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户

13.2 说明

策略模式是准备一组算法，并将这组算法封装到一系列的策略类里面，作为一个抽象策略类的子类。策略模式的重心不是如何实现算法，而是如何组织这些算法，从而让程序结构更加灵活，具有更好的维护性和扩展性，现在我们来分析其基本结构和实现方法。

策略模式的主要角色如下。

1. 抽象策略（Strategy）类：定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，环境角色使用这个接口调用不同的算法，一般使用接口或抽象类实现。
2. 具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现。
3. 环境（Context）类：持有一个策略类的引用，最终给客户端调用。

13.3 实现

    public class StrategyPattern {
    
    
        public static void main(String[] args) {
    
    
            Context c = new Context();
            Strategy s = new ConcreteStrategyA();
            c.setStrategy(s);
            c.strategyMethod();
            System.out.println("-----------------");
            s = new ConcreteStrategyB();
            c.setStrategy(s);
            c.strategyMethod();
        }
    }
    //抽象策略类
    interface Strategy {
    
    
        public void strategyMethod();    //策略方法
    }
    //具体策略类A
    class ConcreteStrategyA implements Strategy {
    
    
        public void strategyMethod() {
    
    
            System.out.println("具体策略A的策略方法被访问！");
        }
    }
    //具体策略类B
    class ConcreteStrategyB implements Strategy {
    
    
        public void strategyMethod() {
    
    
            System.out.println("具体策略B的策略方法被访问！");
        }
    }
    //环境类
    class Context {
    
    
        private Strategy strategy;
        public Strategy getStrategy() {
    
    
            return strategy;
        }
        public void setStrategy(Strategy strategy) {
    
    
            this.strategy = strategy;
        }
        public void strategyMethod() {
    
    
            strategy.strategyMethod();
        }
    }

13.4 总结

策略模式的**主要优点**：

1. 多重条件语句不易维护，而使用策略模式可以避免使用多重条件语句，如 if…else 语句、switch…case 语句。
2. 策略模式提供了一系列的可供重用的算法族，恰当使用继承可以把算法族的公共代码转移到父类里面，从而避免重复的代码。
3. 策略模式可以提供相同行为的不同实现，客户可以根据不同时间或空间要求选择不同的。
4. 策略模式提供了对开闭原则的完美支持，可以在不修改原代码的情况下，灵活增加新算法。
5. 策略模式把算法的使用放到环境类中，而算法的实现移到具体策略类中，实现了二者的分离。

其**主要缺点**：

1. 客户端必须理解所有策略算法的区别，以便适时选择恰当的算法类。
2. 策略模式造成很多的策略类，增加维护难度。

策略模式在很多地方用到，如Java SE 中的容器布局管理就是一个典型的实例，Java SE 中的每个容器都存在多种布局供用户选择。在程序设计中，通常在以下几种情况中使用策略模式较多。

应用场景：

1. 一个系统需要动态地在几种算法中选择一种时，可将每个算法封装到策略类中。
2. 一个类定义了多种行为，并且这些行为在这个类的操作中以多个条件语句的形式出现，可将每个条件分支移入它们各自的策略类中以代替这些条件语句。
3. 系统中各算法彼此完全独立，且要求对客户隐藏具体算法的实现细节时。
4. 系统要求使用算法的客户不应该知道其操作的数据时，可使用策略模式来隐藏与算法相关的数据结构
5. 多个类只区别在表现行为不同，可以使用策略模式，在运行时动态选择具体要执行的行为。

十四、迭代器

14.1 定义

提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。迭代器模式是一种对象行为型模式。

14.2 说明

迭代器模式是通过将聚合对象的遍历行为分离出来，抽象成迭代器类来实现的，其目的是在不暴露聚合对象的内部结构的情况下，让外部代码透明地访问聚合的内部数据。现在我们来分析其基本结构与实现方法。

迭代器模式主要包含以下角色。

1. 抽象聚合（Aggregate）角色：定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
2. 具体聚合（ConcreteAggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。
3. 抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含 hasNext()、first()、next() 等方法。
4. 具体迭代器（Concrete lterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

14.3 实现

import java.util.*;
public class IteratorPattern {
    
    
    public static void main(String[] args) {
    
    
        Aggregate ag = new ConcreteAggregate();
        ag.add("中山大学");
        ag.add("华南理工");
        ag.add("韶关学院");
        System.out.print("聚合的内容有：");
        Iterator it = ag.getIterator();
        while (it.hasNext()) {
    
    
            Object ob = it.next();
            System.out.print(ob.toString() + "\t");
        }
        Object ob = it.first();
        System.out.println("\nFirst：" + ob.toString());
    }
}
//抽象聚合
interface Aggregate {
    
    
    public void add(Object obj);
    public void remove(Object obj);
    public Iterator getIterator();
}
//具体聚合
class ConcreteAggregate implements Aggregate {
    
    
    private List<Object> list = new ArrayList<Object>();
    public void add(Object obj) {
    
    
        list.add(obj);
    }
    public void remove(Object obj) {
    
    
        list.remove(obj);
    }
    public Iterator getIterator() {
    
    
        return (new ConcreteIterator(list));
    }
}
//抽象迭代器
interface Iterator {
    
    
    Object first();
    Object next();
    boolean hasNext();
}
//具体迭代器
class ConcreteIterator implements Iterator {
    
    
    private List<Object> list = null;
    private int index = -1;
    public ConcreteIterator(List<Object> list) {
    
    
        this.list = list;
    }
    public boolean hasNext() {
    
    
        if (index < list.size() - 1) {
    
    
            return true;
        } else {
    
    
            return false;
        }
    }
    public Object first() {
    
    
        index = 0;
        Object obj = list.get(index);
        ;
        return obj;
    }
    public Object next() {
    
    
        Object obj = null;
        if (this.hasNext()) {
    
    
            obj = list.get(++index);
        }
        return obj;
    }
}

14.4 总结

主要优点：

1. 访问一个聚合对象的内容而无须暴露它的内部表示。
2. 遍历任务交由迭代器完成，这简化了聚合类。
3. 它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历。
4. 增加新的聚合类和迭代器类都很方便，无须修改原有代码。
5. 封装性良好，为遍历不同的聚合结构提供一个统一的接口。

主要缺点：增加了类的个数，这在一定程度上增加了系统的复杂性。

应用场景：

1. 当需要为聚合对象提供多种遍历方式时。
2. 当需要为遍历不同的聚合结构提供一个统一的接口时。
3. 当访问一个聚合对象的内容而无须暴露其内部细节的表示时

参考：

1. http://c.biancheng.net/view/1361.html
2. https://www.cnblogs.com/gonjan-blog/p/6685611.html
3. https://www.cnblogs.com/betterboyz/category/1260384.html
4. https://blog.csdn.net/ShuSheng0007/article/details/115980889
5. https://www.runoob.com/design-pattern/adapter-pattern.html
6. https://www.cnblogs.com/gonjan-blog/p/6685611.html
7. https://blog.csdn.net/jcsyl_mshot/article/details/79845732
8. https://blog.csdn.net/wwwdc1012/article/details/82504040
9. https://blog.csdn.net/A1342772/article/details/91349142
10. https://blog.csdn.net/mengchuan6666/article/details/119924760