java设计模式总结

java设计模式

创建型模型

包括：单例模式、建造者模式、原型模式、工厂模式

单例模式

保证对象在一个jvm中，只有一个实例存在

适用场景:

• 创建对象比较繁琐，且消耗较大的
• 控制全局的类

分类：

• 饿汉式

  • 类初始化时创建单例，线程安全，适用于单例占内存小的场景，否则推荐使用懒汉式延迟加载
  • 

• 懒汉式

  • 需要创建单例的时候再创建，需要考虑线程安全（性能不太好）
  • 

• 双重检验锁

  • 解决的问题：当两个线程同时执行到了

    if(null == instance){   // AB线程均执行到此处，判断instance为空。
    ...
    }
    

    两个线程会继续往下执行，那么内存中就存在了两个实例

    

• 静态内部类方式：可以同时保证延迟加载和线程安全

建造者模式

原型模式

对一个原型类进行复制克隆产生新的对象

要求：被复制的对象需要实现Cloneable接口，和重写Object类中的clone方法；

好处：通过原型模式创建对象比直接new会有更好的性能，Object类的clone方法时一个本地方法，直接操作内存中的二进制流。

工厂模式

工厂方法模式

1、普通工厂模式

建立一个工厂类，对实现了同一个接口的一些类进行实例的创建

通过入参判断所需的是哪一个实体类，然后直接返回

2、多个工厂方法模式

提供多个工厂方法，分别创建对象

对不同的返回实例，编写不同的方法，根据方法调用返回实现了同一个接口的不同实例。

3、静态工厂方法模式（常用的模式）

将上面的多个工厂方法设置为静态的，无需创建实例就可得到所需类。

抽象工厂模式

创建多个工厂类，进一步提高了工厂的扩展性

对不同工厂的抽象和分类，使用的时候，根据自己所需选择对应的工厂类，进而获取到所需的实例

结构型模型

包括：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、亨元模式

适配器模式

1、类的适配器模式

需求:在一个接口类A中，存在方法methodA()，目前需要在methodA()中调用另一个类B的methodB().

实现：创建适配器类C继承B,实现A接口，重写methodA(),方法中调用super.methodB;

public class C extends B implements C{
    @Override
    public void methodA() {
        //...一些操作...
        super.methodB();
        //...一些操作...
    }
}

2、对象的适配器模式

与类适配器不同是，类适配器通过继承来完成适配，对象适配则是通过关联来完成。

public class C implements A{
    // 适配者是对象适配器的一个属性
    private B b = new B();

    @Override
    public void methodA() {
        //...
        b.B();
        //...
    }
}

3、接口的适配器模式

问题：有时候我们实现一个接口，但是不想实现里边无关的其他方法，就需要一个中间适配器，由中间适配器实现接口的所有方法，然后我们定义一个类继承这个适配器，只重写我们关心的方法即可。

package com.demo.adapter.interfaceadapter;

/**
 * 接口类.
 */

public interface DCOutput {
    int output5V();
    int output9V();
    int output12V();
    int output24V();
}

package com.demo.adapter.interfaceadapter;

import com.demo.adapter.classadapter.AC220;

/**
 * 适配器类.
 */
public abstract class PowerAdapter implements DCOutput{
    protected AC220 mAC220;

    public PowerAdapter(AC220 ac220){
        this.mAC220 = ac220;
    }

    @Override
    public int output5V() {
        return mAC220.output220V();
    }

    @Override
    public int output9V() {
        return mAC220.output220V();
    }

    @Override
    public int output12V() {
        return mAC220.output220V();
    }

    @Override
    public int output24V() {
        return mAC220.output220V();
    }
}

package com.demo.adapter.interfaceadapter;

import com.demo.adapter.classadapter.AC220;

/**
 * 适配器的使用.
 */

public class Power5VAdapter extends PowerAdapter {

    public Power5VAdapter(AC220 ac220) {
        super(ac220);
    }

    @Override
    public int output5V() {
        int output = 0;
        if (mAC220 != null) {
            output = mAC220.output220V() / 44;
        }
        return output;
    }
}

装饰者模式

增强被装饰者的功能，要求装饰者和被装饰者实现同一个接口，装饰者持有被装饰者对象的实例

代理模式

外观模式

将一类相关的组件放到一个类里，并实现相关的方法；

public class Facade {

    //被委托的对象
    SubSystemA a;
    SubSystemB b;
    SubSystemC c;
    SubSystemD d;
    
    public Facade() {
        a = new SubSystemA();
        b = new SubSystemB();
        c = new SubSystemC();
        d = new SubSystemD();
    }
    
    //提供给外部访问的方法
    public void methodA() {
        this.a.dosomethingA();
    }
    
    public void methodB() {
        this.b.dosomethingB();
    }
    
    public void methodC() {
        this.c.dosomethingC();
    }
    
    public void methodD() {
        this.d.dosomethingD();
    }
    
}

public class Client {

    public static void main(String[] args) {
        Facade facade = new Facade();
        
        facade.methodA();
        facade.methodB();
    }
    
}

桥接模式

比如JDBC桥接DriverManager一样；JDBC进行连接数据库的时候，在各个数据库之间进行切换，基本不需要改动太多的代码，原因就是JDBC提供统一的接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了。

组合模式(部分整体模式)

亨元模式(共享池、数据库连接池)

主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，通常与工厂模式一起使用。当一个客户端请求时，工厂需要检查当前对象池中是否有符合条件的对象，如果有，就返回已经存在的对象，如果没有，则创建一个新对象，如数据库连接池。

行为型模型

包括：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式

策略模式(多种算法封装)

模板方法模式

观察者模式(发布-订阅模式)

当一个对象变化时，其他依赖该对象的都对象都会收到通知，并且随着变化，对象之间是一种一对多的关系。类似邮件订阅和RSS订阅，当你订阅了该文章，如果后续有更新，会及时通知你。

迭代器模式

责任链模式(多任务在形成一条链，请求在链上传递)

有多个对象，每个对象都持有对下一个对象的引用，这样就会形成一条链，请求在这条链上传递，知道某一个对象决定处理该请求。但是发出者并不清楚到底最终哪个对象会处理该请求，所以责任链可以实现在隐瞒客户端的情况下，对系统进行动态的调整。

命令模式

备忘录模式

状态模式

当对象的状态改变时，同时改变其行为

访问者模式

中介者模式

中介者模式也是用来降低类之间耦合的，如果使用中介者模式，只需关心和中介类的关系，具体类和类之间的关系及调度交给中介类就行。

解释器模式

建造者模式(创建复合对象)

工厂类模式是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建符合对现象，所谓复合对象就是指某个类有不同的属性。

六大设计原则

• 开闭原则
  • 对扩展开放，对修改关闭，在程序需要扩展的时候，不能去修改原有的代码，要实现一个热插拔的效果。尽可能的使用接口和抽象类，从而使程序更好的扩展，更容易的维护和升级。
• 里氏代换原则（LSP）
  • 在继承类的时候金，除了扩展一些新的功能外，尽量不要修改或者删除对父类方法的引用，也尽量不要在父类中重载方法。
• 依赖倒转原则
  • 高层次模块不依赖低层次模块的细节，高层次就是不依赖细节而是依赖抽象（不依赖具体的类，而是依赖于接口）
• 接口隔离原则
  • 在定义接口方法时，应该尽量合理化，尽量追求简单最小，避免接口臃肿。
• 迪米特法则（最少知道原则）
  • 一个对象对其它对象有最少的了解，对自己需要耦合或者调用的类知道的最少，类的内部如何实现，如何复杂都与调用者或依赖者没关系，调用者或者依赖者只需要知道他需要的方法即可，其他的一概不关心。
• 单一职责原则
  • 对功能进行分类，代码进行解耦，不能够将不同的功能放在一起实现，一次只做一件事。