Java学习之路（六）设计模式（不全，后续会逐渐更新）

设计模式是在大量实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式免去我们自己再思考和摸索。式就像是经典的棋谱，不同的棋局，我们用不同的棋谱，也就是我们平时所说的“套路”

一、创建型模式（5种）

1.工厂方法模式

• 概述：实现了创建者与调用者的分离，即将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。
• 工厂方法模式：用来生产同一等级结构中的固定产品。（支持增加任意产品）

2. 抽象工厂模式

• 抽象工厂模式：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）

3. 单例模式

所谓类的单例模式，就是采取一定的方法保证在整个软件系统中，对某个类只能存在一个实例对象，并且该类提供一个取得其对象实例的方法。如果我们要让类在虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为private，这样，就不能使用new操作符在类的外部产生类的对象了，但是在类的内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，而静态方法只能访问类中的静态成员变量，所以，指向类内部产生该类对象的变量也必须定义为静态的

①单例的饿汉式实现（一开始就创建对象）

public class SingletonTest1 {
    public static void main(String[] args) {
        Bank bank1 = Bank.getInstance();
        Bank bank2 = Bank.getInstance();
        System.out.println(bank1 == bank2);//true
    }
}

class Bank{
    
    //1. 私有化构造器
    private Bank(){
    }
    
    //2. 在类内部创建对象，且赋值给指向该对象的静态变量
    private static Bank instance = new Bank();
    
    //3. 提供公共的静态的方法，返回类的对象
    public static Bank getInstance(){
        return instance;
    }
}

② 单例的懒汉式实现（要用的时候才创建对象）

public class SingletonTest2 {
    public static void main(String[] args) {
        Bank2 bank1 = Bank2.getInstance();
        Bank2 bank2 = Bank2.getInstance();
        System.out.println(bank1 == bank2);//true
    }
}

class Bank2{
    //1. 私有化构造器
    private Bank2(){

    }
    //2. 声明一个静态变量
    private static Bank2 instance = null;

    //3. 提供公有的静态的方法，返回类的对象
    public static Bank2 getInstance(){
        if (instance == null){
            instance = new Bank2();
        }
        return instance;
    }
}

方式	好处	坏处
饿汉式	线程安全	对象加载时间过长
懒汉式	延迟对象的加载	目前的写法线程不安全

③单例模式的引用场景

1. 网站的计数器，一般也是单例模式实现，否则难以同步
2. 应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加
3. 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源
4. 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，都生成一个对象去读取
5. Application也是单列的典型应用
6. windows的Task Manager（任务管理器）也是很典型的单例模式
7. Windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例

4. 建造者模式

5. 原型模式

二、结构型模式（7种）

1. 适配器模式

2. 装饰器模式

3. 代理模式

• 概述：代理模式是Java开发中使用比较多的一种设计模式。代理模式就是为其他对象提供一种代理以控制对这个对象的访问

public class NetWorkTest{
	public static void main(String[] args){
		Server server = new Server();
		ProxyServer proxyServer = new ProxyServer(server);
		proxyServer.browse();
		/**
		连接网络前的各种检验。。。
		真实的服务器访问网络
		*/
	}
}


interface Network{

	public void browse();
	
}

//被代理类
class Server implements Network{

	@Override
	public void browse(){
		Sysout.out.println("真实的服务器访问网络");
	}

}

//代理类
class ProxyServer implements Network{

	private Network work;
	
	public ProxyServer(Network work){
		this.work = work;
	}
	
	@Override
	public void browse(){
		check();
		work.browse();
	}
	
	public void check(){
		System.out.println("连接网络前的各种检验。。。")
	}
}

• 应用场景：

1. 安全代理：屏蔽对真实角色的直接访问
2. 远程代理：通过代理类处理远程方法调用（RMI）
3. 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100MB，在打开文件时，不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图片的打开。

• 分类

1. 静态代理（静态定义代理类）
2. 动态代理（动态生成代理类）——JDK自带的动态代理，需要反射等知识

4. 外观模式

5. 桥接模式

6. 组合模式

7. 享元模式

三、行为型模式（11种）

1. 策略模式

2.模板方法模式

1. 解释：抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式
2. 解决的问题
   ① 当功能内部一部分实现是确定，一部分实现是不确定的。这是可以把不确定的部分暴露出去，让子类去实现
   ② 也就是说，在软件开发中实现一个算法时，整体步骤是固定的、通用的，这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种模板模式
3. 模板方法的应用场景：
   ① 数据库访问的封装
   ② Junit单元的测试
   ③ JavaWeb的Servlet中关于doGet()/doPost()方法的调用
   ④ Hibernate中的模板程序
   ⑤ Spring中JDBCTemlate、HibernateTemplate等

3. 观察者模式

4. 迭代子模式

5. 责任链模式

6. 命令模式

7. 备忘录模式

8. 状态模式

9. 访问者模式

10. 中介者模式

11. 解释器模式