常见的设计模式

各模式关键点：

单例模式：某个类只能有一个实例，提供一个全局的访问点。

简单工厂：一个工厂类根据传入的参量决定创建出那一种产品类的实例。

工厂方法：定义一个创建对象的接口，让子类决定实例化那个类。

抽象工厂：创建相关或依赖对象的家族，而无需明确指定具体类。

建造者模式：封装一个复杂对象的构建过程，并可以按步骤构造。

原型模式：通过复制现有的实例来创建新的实例。

适配器模式：将一个类的方法接口转换成客户希望的另外一个接口。

组合模式：将对象组合成树形结构以表示“”部分-整体“”的层次结构。

装饰模式：动态的给对象添加新的功能。

代理模式：为其他对象提供一个代理以便控制这个对象的访问。

亨元（蝇量）模式：通过共享技术来有效的支持大量细粒度的对象。

外观模式：对外提供一个统一的方法，来访问子系统中的一群接口。

桥接模式：将抽象部分和它的实现部分分离，使它们都可以独立的变化。

模板模式：定义一个算法结构，而将一些步骤延迟到子类实现。

解释器模式：给定一个语言，定义它的文法的一种表示，并定义一个解释器。

策略模式：定义一系列算法，把他们封装起来，并且使它们可以相互替换。

状态模式：允许一个对象在其对象内部状态改变时改变它的行为。

观察者模式：对象间的一对多的依赖关系。

备忘录模式：在不破坏封装的前提下，保持对象的内部状态。

中介者模式：用一个中介对象来封装一系列的对象交互。

命令模式：将命令请求封装为一个对象，使得可以用不同的请求来进行参数化。

访问者模式：在不改变数据结构的前提下，增加作用于一组对象元素的新功能。

责任链模式：将请求的发送者和接收者解耦，使的多个对象都有处理这个请求的机会。

迭代器模式：一种遍历访问聚合对象中各个元素的方法，不暴露该对象的内部结构。

一、单例设计模式

饿汉式：

//这个类用来测试单例设计模式   ---  饿汉式

public class Test6_Singleton {

    public static void main(String[] args) {

       MySingle m = MySingle.getSingle();

       MySingle m2 = MySingle.getSingle();

       //==如果比较的是两个引用类型的变量？比较的是地址值

       System.out.println(m==m2);

    }

}

//创建自己的单例程序

class MySingle {

    //1，私有化构造方法，不让外界随意new

    private MySingle() {}

   

    //2，在类的内部，提供一个已经创建好的对象

    //static是因为  静态资源getSingle()只能调用静态

    static private MySingle single = new MySingle();

   

    //3，对外提供一个全局访问点

    //static 是因为，想要访问get()可以创建对象访问，但是目前已经不允许创建对象了。只能通过类名调用，就得修饰。

    static public MySingle getSingle(){

       //把内部创建好的对象返回调用位置

       return single;

    }

}

懒汉式：

 

//这个类用来测试单例设计模式   ---  懒汉式

//面试重点：

//1、延迟加载思想：是指不会第一时间就把对象创建好来占用内存，而是什么时候用什么时候创建

//2、线程安全问题：是指共享资源有线程并发的数据隐患，加同步锁，锁方法，也可以锁代码块

public class Test7_Single2 {

    public static void main(String[] args) {

       MySingleton my = MySingleton.getMy();

       MySingleton my2 = MySingleton.getMy();

       System.out.println(my==my2);

    }

}

// 创建类

class MySingleton {

    // 1,私有化构造方法 -- 控制外界new的权利

    private MySingleton() {

    }

    // 2，在类的内部创建好对象 -- 延迟加载！！

    static private MySingleton my;

 

//  static Object obj = new Object();

   

    // 3，提供全局访问点

    // 问题：程序中有共享资源my，并且有多条语句(3条)操作了共享资源，此时，my共享资源一定会存在多线程编程的数据安全隐患

    // 解决方案就是加 同步锁 。

    //如果用同步代码块需要确定锁的位置？ 锁的对象？由于方法中的所有代码都被同步了，可以直接变成同步方法。

    synchronized static public MySingleton getMy() {

//     synchronized (obj) {//同步代码块：静态区域内，不能是用this关键字？因为加载的先后顺序问题

           if (my == null) {// 说明没new过，保存的是默认值null

              my = new MySingleton();// 需要时才会创建对象，不需要也不会提前就开始占用内存。

           }

           return my;

//     }

    }

 

}

 

二、亨元模式

在一个系统中对象会使得内存占用过多，特别是那些大量重复的对象，这就是对系统资源的极大浪费。享元模式对对象的重用提供了一种解决方案，它使用共享技术对相同或者相似对象实现重用。享元模式就是运行共享技术有效地支持大量细粒度对象的复用。系统使用少量对象,而且这些都比较相似，状态变化小，可以实现对象的多次复用。这里有一点要注意：享元模式要求能够共享的对象必须是细粒度对象。享元模式通过共享技术使得系统中的对象个数大大减少了，同时享元模式使用了内部状态和外部状态，同时外部状态相对独立，不会影响到内部状态，所以享元模式能够使得享元对象在不同的环境下被共享。同时正是分为了内部状态和外部状态，享元模式会使得系统变得更加复杂，同时也会导致读取外部状态所消耗的时间过长。

享元模式包含如下角色：
Flyweight: 抽象享元类
ConcreteFlyweight: 具体享元类
UnsharedConcreteFlyweight: 非共享具体享元类
FlyweightFactory: 享元工厂类

三、代理模式

代理模式就是给一个对象提供一个代理，并由代理对象控制对原对象的引用。它使得客户不能直接与真正的目标对象通信。代理对象是目标对象的代表，其他需要与这个目标对象打交道的操作都是和这个代理对象在交涉。

代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了的作用和保护了目标对象的，同时也在一定程度上面减少了系统的耦合度。

代理模式包含如下角色：
 Subject: 抽象主题角色
 Proxy: 代理主题角色
 RealSubject: 真实主题角色

四、工厂模式

作为抽象工厂模式的孪生兄弟，工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个，也就是说工厂方法模式让实例化推迟到子类。

工厂方法模式非常符合“开闭原则”，当需要增加一个新的产品时，我们只需要增加一个具体的产品类和与之对应的具体工厂即可，无须修改原有系统。同时在工厂方法模式中用户只需要知道生产产品的具体工厂即可，无须关系产品的创建过程，甚至连具体的产品类名称都不需要知道。虽然他很好的符合了“开闭原则”，但是由于每新增一个新产品时就需要增加两个类，这样势必会导致系统的复杂度增加。其UML结构图：