23种设计模式个人简要总结（更新中）

常用设计模式可以分为三大类：

1 创建型模式（5种）
●工厂模式（Factory Pattern）
●抽象工厂模式（Abstract Factory Pattern）
●单例模式（Singleton Pattern）
●建造者模式（Builder Pattern）
●原型模式（Prototype Pattern）

2 结构型模式（7种）
●适配器模式（Adapter Pattern）
●装饰器模式（Decorator Pattern）
●代理模式（Proxy Pattern）
●外观模式（Facade Pattern）
●桥接模式（Bridge Pattern）
●组合模式（Composite Pattern）
●享元模式（Flyweight Pattern）

3 行为型模式（11种）
●策略模式（Strategy Pattern）
●模板模式（Template Pattern）
●观察者模式（Observer Pattern）
●迭代器模式（Iterator Pattern）
●责任链模式（Chain of Responsibility Pattern）
●命令模式（Command Pattern）
●备忘录模式（Memento Pattern）
●状态模式（State Pattern）
●访问者模式（Visitor Pattern）
●中介者模式（Mediator Pattern）
●解释器模式（Interpreter Pattern）

以下是23种常用设计模式Java代码+简要说明（个人总结）

一、工厂模式

1.代码

public class Main {

    static class ColorFactory{
        public static Color getColor(Class c){
            if(c == Blue.class){
                return new Blue();
            }else if(c == Red.class){
                return new Red();
            }else{
                System.out.println("error");
                return null;
            }
        }
    }

    interface Color{
        void create();
    }

    static class Red implements Color{
        public void create(){
            System.out.println("class Red created.");
        }
        public Red(){
            create();
        }
    }

    static class Blue implements Color{
        public void create(){
            System.out.println("class Blue created.");
        }
        public Blue(){
            create();
        }
    }

    public static void main(String[] args) {
        //使用工厂方法获得Color(Blue)对象
        Color blue = ColorFactory.getColor(Blue.class);
        //使用工厂方法获得Color(Red)对象
        Color red = ColorFactory.getColor(Red.class);
    }
}

2.说明
工厂模式，主要就是用到一个工厂类，根据传给工厂类的参数不同，工厂类返回不同的实例对象。

上方代码中，工厂类是ColorFactory，根据入参不同，工厂类可以生产出Blue或Red的JavaBean对象。

二、抽象工厂模式

1.代码

import java.util.*;

public class Main {

    static class SuperFactory{
        public static AbstractFactory getFactory(String str){
            if("MapFactory".equals(str)){
                System.out.println("return MapFactory");
                return new MapFactory();
            }else if("ListFactory".equals(str)){
                System.out.println("return ListFactory");
                return new ListFactory();
            }else{
                System.out.println("error");
                return null;
            }
        }
    }

    public static abstract class AbstractFactory {
        public abstract List getList(String str);
        public abstract Map getMap(String str);
    }

    static class ListFactory extends AbstractFactory{
        @Override
        public List getList(String str) {
            if("ArrayList".equals(str)){
                System.out.println("return ArrayList");
                return new ArrayList();
            }else if("LinkedList".equals(str)){
                System.out.println("return LinkedList");
                return new LinkedList();
            }else{
                System.out.println("error");
                return null;
            }
        }
        @Override
        public Map getMap(String str) {
            return null;
        }
    }
    static class MapFactory extends AbstractFactory{
        @Override
        public List getList(String str) {
            return null;
        }
        @Override
        public Map getMap(String str) {
            if("HashMap".equals(str)){
                System.out.println("return HashMap");
                return new HashMap();
            }else if("LinkedHashMap".equals(str)){
                System.out.println("return LinkedHashMap");
                return new LinkedHashMap();
            }else{
                System.out.println("error");
                return null;
            }
        }
    }

    public static void main(String[] args) {
        //从超级工厂获得具体工厂
        MapFactory mapFactory = (MapFactory)SuperFactory.getFactory("MapFactory");
        //从具体工厂获得具体JavaBean对象
        Map map = mapFactory.getMap("HashMap");

        //从超级工厂获得具体工厂
        ListFactory listFactory = (ListFactory)SuperFactory.getFactory("ListFactory");
        //从具体工厂获得具体JavaBean对象
        List list = listFactory.getList("ArrayList");
    }
}

2.说明
抽象工厂模式，就是有一个工厂的工厂（把多个具体工厂抽象成一个超级工厂），给工厂的工厂传参，获得具体的工厂，然后再给具体的工厂传参，获取需要的JavaBean对象。

上方代码中，工厂的工厂是SuperFactory，具体的工厂是ListFactory和MapFactory；根据入参不同，可以生产出具体的JavaBean对象。

三、单例模式

单例模式，Java中，就是某个java类，只允许创建一个该类的实例对象。

有几种常用的创建方法：

1.懒汉式（线程不安全）
(1)代码

public class Main {

    static class A{
        private static A a;
        private A(){}
        public static A getInstance(){
            if(a == null){
                a = new A();
                return a;
            }else{
                return a;
            }
        }
    }

    public static void main(String[] args) {
        //获取对象
        A instance = A.getInstance();
    }
}

(2)说明
懒汉式的意思是，用到这个JavaBean时，会调用getInstance()方法，此时再看是否有JavaBean，没有就创建并返回，有的话直接返回。

上方代码中，类A即是单例，只允许存在一个；不过多线程时不能保证只创建了一个，所以是线程不安全的。

2.懒汉式（线程安全）
(1)代码

public class Main {

    static class A{
        private static A a;
        private A(){}
        public static synchronized A getInstance(){
            if(a == null){
                a = new A();
                return a;
            }else{
                return a;
            }
        }
    }

    public static void main(String[] args) {
        //获取对象
        A instance = A.getInstance();
    }
}

(2)说明
这是一个简单的线程安全的懒汉式代码，只增加了synchronized关键字，保证了线程安全。

不过，当多个线程调用getInstance()方法时，虽然线程安全了，但是不能并发处理，对效率有一定影响。

3.饿汉式
(1)代码

public class Main {

    static class A{
        private static A a = new A();
        private A(){}
        public static A getInstance(){
            return a;
        }
    }

    public static void main(String[] args) {
        //获取对象
        A instance = A.getInstance();
    }
}

(2)说明
饿汉式的意思是，当类加载时，就把JavaBean提前准备好；当需要使用getInstance()方法时，直接返回即可。

上方代码中，由于类加载时已准备好这一个对象，后续直接使用即可，不需要加synchronized关键字，也是线程安全的。

四、建造者模式

1.概念
建造者模式，目的是将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

四个角色：
Product（产品角色）： 一个具体的产品对象。
Builder（抽象建造者）： 创建一个Product对象的各个部件指定的抽象接口。
ConcreteBuilder（具体建造者）： 实现抽象接口，构建和装配各个部件。
Director（指挥者）： 构建一个使用Builder接口的对象。它主要是用于创建一个复杂的对象。它主要有两个作用，一是：隔离了客户与对象的生产过程，二是：负责控制产品对象的生产过程。

2.代码

public class Main {

    //产品角色（Product）
    static class MsgBean{
        private String code;
        private String msg;
        private String desc;

        public MsgBean(Builder builder){
            this.code = builder.code;
            this.msg = builder.msg;
            this.desc = builder.desc;
        }

        @Override
        public String toString() {
            return "MsgBean{" +
                    "code='" + code + '\'' +
                    ", msg='" + msg + '\'' +
                    ", desc='" + desc + '\'' +
                    '}';
        }
    }

    //抽象建造者（Builder）可以省略，这个直接是具体建造者（ConcreteBuilder）
    static class Builder{
        private String code;
        private String msg;
        private String desc;

        public Builder setCode(String code){
            this.code = code;
            return this;
        }
        public Builder setMsg(String msg){
            this.msg = msg;
            return this;
        }
        public Builder setDesc(String desc){
            this.desc = desc;
            return this;
        }

        public MsgBean getMsgBean(){
            return new MsgBean(this);
        }
    }

    //指挥者（Director）也可以省略，这里直接是测试方法
    public static void main(String[] args) {
        MsgBean msgBean = new Builder().setCode("200").setMsg("ok").setDesc("msg received.").getMsgBean();
        System.out.println(msgBean);
    }
}

3.说明
上方代码是一个简化的建造者模式，省略了抽象建造者和指挥者，只保留了产品角色和具体建造者。

五、原型模式

1.概念
原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。

2.代码

public class Main {

    //实现Cloneable
    static class User implements Cloneable{
        public String name;

        @Override
        protected Object clone() throws CloneNotSupportedException {
            System.out.println("执行clone方法");
            return super.clone();
        }
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        //创建一个u1
        User u1 = new User();
        u1.name = "u1";

        //克隆一个u2
        User u2 = null;
        u2 = (User)u1.clone();
        System.out.println(u2.name);
    }
}

3.说明
上方代码，实现了Cloneable接口，然后用clone()方法，以u1为模板，重复创建了对象u2。

六、适配器模式

1.概念
适配器模式（Adapter Pattern）,将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

2.代码

public class Main {
    //接口
    public interface MediaPlayer {
        public void play(String type, String fileName);
    }

    //假设这个类只能播放MP3
    public static class MP3Player implements MediaPlayer {
        @Override
        public void play(String type, String fileName) {
            if("MP3".equals(type)) {
                System.out.println("begin play MP3,fileName is "+fileName);
            }
        }
    }

    //假设这个类只能播放MP4
    public static class MP4Player implements MediaPlayer {
        @Override
        public void play(String type, String fileName) {
            if("MP4".equals(type)) {
                System.out.println("begin play MP4,fileName is "+fileName);
            }
        }
    }

    //这个类是适配器类，MP3和MP4都能播放
    public static class AdapterPlayer implements MediaPlayer {
        @Override
        public void play(String type, String fileName) {
            if("MP4".equals(type)) {
                MP4Player mp4Player = new MP4Player();
                mp4Player.play(type, fileName);
            }else if("MP3".equals(type)){
                MP3Player mp3Player = new MP3Player();
                mp3Player.play(type, fileName);
            }
        }
    }

    public static void main(String[] args) {
        AdapterPlayer adapterPlayer = new AdapterPlayer();
        adapterPlayer.play("MP3","a.mp3");
        adapterPlayer.play("MP4","b.mp4");
    }
}

3.说明
适配器模式可以让任何两个没有关联的类一起运行。
上方使用了AdapterPlayer类，它是个适配器类，整合了播放MP3与MP4的功能，可以让播放功能更方便使用。

七、装饰器模式

1.概念
2.代码
3.说明