java常见的设计模式

1.什么是设计模式？

设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理地运用设计模式可以完美地解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式都描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是设计模式能被广泛应用的原因。

2.设计模式的类型

总共有 23 种设计模式 ， 可以分为三大类 ： 创建型模式 ， 结构型模式 ， 行为型模式 。

创建型模式

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

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

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

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

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

结构型模式

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

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

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

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

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

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

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

行为型模式

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

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

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

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

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

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

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

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

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

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

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

 

3.单例模式

单例模式，它的定义就是确保某一个类只有一个实例，并且提供一个全局访问点 。

单例模式具备典型的 3 个特点： 1 、只有一个实例。 2 、自我实例化。 3 、提供全局访问点。

 代码示例

/**
* 用户消息类
* @author Administrator
*
*/
public class UserMassage {
    //创建静态对象
    public static UserMassage umsg = new UserMassage();
    //对外部提供一个公共的访问方法
    public static UserMassage getUserMassage(){
        return umsg;
    }
    //一个普通方法
    public void show(){
        System.out.println("我是单例模式");
    }
}
//测试
public static void main(String[] args) {
    UserMassage msg1 = UserMassage.getUserMassage();
    msg1.show();
    UserMassage msg2 = UserMassage.getUserMassage();
    msg2.show();
    System.out.println(msg1.equals(msg2)); //输出结果为true 表示只创建了一次对象
}

优点

在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例。

避免对资源的多重占用（比如写文件操作）。

缺点

没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来

实例化

使用场景：

1 、要求生产唯一序列号。

2 、 WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。

3 、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等

注意事项： getUserMassage() 方法中需要使用同步锁 synchronized (UserMassage.class) 防止多线程同时进入造成 UserMassage 被多次实例化

4.工厂模式

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

代码示例

/**
* 面条类
*/
public interface MianTiao {
    //面条描述
    public abstract void desc();
}
/**
* 兰州拉面
*/
public class LzNoodles implements MianTiao {
    public void desc() {
        System.out.println("这是兰州拉面");
    }
}
/**
* 泡面
*/
public class PaoNoodles implements MianTiao {
    public void desc() {
        System.out.println("这是泡面");
    }
}
/**
* 河南烩面
*/
public class HuiNoodles implements MianTiao {
    public void desc() {
        System.out.println("这是河南烩面");
    }
}
/**
* 面馆工厂
*/
public class SimpleNoodlesFactory {
    public static final int TYPE_LZ = 1;//兰州拉面
    public static final int TYPE_PM = 2;//泡面
    public static final int TYPE_HM = 3;//河南烩面
    //根据用户的选择 创建不同的面
public static MianTiao createNoodles(int type) {
    switch (type) {
        case TYPE_LZ:
        return new LzNoodles();
        case TYPE_PM:
        return new PaoNoodles();
        case TYPE_HM:
        default:
        return new HuiNoodles();
    }
}
}
public static void main(String[] args) {
    //调用面馆 传入我需要生产面
    MianTiao mian =SimpleNoodlesFactory.createNoodles(SimpleNoodlesFactory.TYPE_HM);
    mian.desc();
}

优点

1 、一个调用者想创建一个对象，只要知道其名称就可以了。

2 、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。

3 、屏蔽产品的具体实现，调用者只关心产品的接口。

缺点

每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事 。

5.装饰模式

装饰模式是用来替代继承的一种设计模式。它通过一种无须定义子类的方式来给对象动态增加职责，使用对象之间的关联关系取代类之间的继承关系。降低了系统的耦合，可以动态的增加或者删除对象的职责

代码示例

/**
* 展示自己的接口
*/
public interface Showable {
    public abstract void show();//定义展示行为
}
/**
* 女友类
* @author Administrator
*
*/
public class Girl implements Showable{
    @Override
    public void show() {
        /**
        * 展示自己的接口
        */
        public interface Showable {
            public abstract void show();//定义展示行为
        }
        /**
        * 女友类
        * @author Administrator
        *
        */
    public class Girl implements Showable{
        @Override
        public void show() {
            public static void main(String[] args) {
                //创建女友
                Girl girl = new Girl();
                //将女友放入描眉类
            MiaoMei hzp = new MiaoMei(girl);
            //将描眉后的女友放入涂口红类
            TuKouHong tkh = new TuKouHong(hzp);
        tkh.show();
    }
    输出结果：涂口红(描眉(女友的素颜))

优点

1. 对于扩张一个对象的功能，装饰模式比继承模式更加灵活，不会导致类的数量急剧增加。

2. 可以通过一种动态的方式扩张一个类的功能，同过配置文件可以在运行时进行选择，不同的装饰

类。

3. 可以对一个对象进行多次装饰，通过使用不同的具体装饰类以及这些装饰类的排列组合可以创造不同的行为的组合。

缺点

1. 在使用装饰模式的时候进行系统设计时会产生很多小对象，这些对象的区别在于他们之间相互连接的方式有所不同，而不是他们的类或者属性值有所不同，大量小对象势必产生一大部分的系统资源开销。影响系统性能

2. 装饰模式是一种比继承更加灵活的解决方案。但同时，也意味着比继承更加容易出错，更加难排

长。对于多层装饰的对象，需要逐级排查，较为繁琐。

6.代理模式

代理模式 指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关 业务的处理。比如生活中的通过代理访问网络，客户通过网络代理连接网络（具体业务），由代理服务 器完成用户权限和访问限制等与上网相关的其他操作（相关业务）

/*
* 定义Network接口
*/
public interface Network {
    public void browse(); // 定义浏览的抽象方法
}
/*
* 真实的上网操作
*/
public class Real implements Network {
    //重写抽象方法
    public void browse() {
        System.out.println("上网浏览信息！");
    }
}
/*
* 代理上网
*/
public class Proxy implements Network {
    private Network network;
    // 设置代理的真实操作
    public Proxy(Network network) {
        this.network = network; // 设置代理的子类
    }
    // 身份验证操作 其他操作
    public void check() {
        System.out.println("检查用户是否合法！");
    }
    //代码实现上网
    public void browse() {
        this.check(); // 调用具体的代理业务操作
        this.network.browse(); // 调用真实的上网操作
    }
}
public static void main(String args[]) {
    Network net = null; // 定义接口对象
    net = new Proxy(new Real()); // 实例化代理，同时传入代理的真实操作
    net.browse(); // 调用代理的上网操作
}

优点

1. 代理模式能将代理对象与真实被调用的目标对象隔离

2. 一定程度上降低了系统的耦合度，扩展性好

3. 可以起到保护目标对象的作用

4. 可以对目标对象的功能增强

缺点

1. 代理模式会造成系统设计中类的数量增加

2. 在客户端与目标对象之间增加一个代理对象，会造成请求处理速度变慢

3. 增加了系统的复杂度

7.观察者模式

观察者模式定义了对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对 象都将得到通知，并自动更新。观察者模式属于行为型模式，行为型模式关注的是对象之间的通讯，观察者模式就是观察者和被观察者之间的通讯观察者模式有一个别名叫“ 发布 - 订阅模式 ” ，或者说是 “ 订阅 - 发布模式 ” ，订阅者和订阅目标是联系在一起的，当订阅目标发生改变时，逐个通知订阅者。我们可以用报纸期刊的订阅来形象的说明，当你订阅了一份报纸，每天都会有一份最新的报纸送到你手上，有多少人订阅报纸，报社就会发多少份报纸，报社和订报纸的客户就是上面文章开头所说的“ 一对多 ”的依赖关系

我们按照定牛奶的方式来理解， Subject 实际上可以理解成奶厂， Observer 可以理解成为我们每个用 户，而观察者模式就是在 Subject 发生变化的时候，去通知每一个 Observer 对象，以达到消息通知目的

/**
* 观察者主题对象
*/
public interface Subject {
    /**
    * 订阅操作
    */
    void attach(Observer observer);
    /**
    * 取消订阅操作
    */
    void detach(Observer observer);
    /**
    * 通知变动
    */
    void notifyChanged();
}
/**
* 观察者订阅人对象
*/
public interface Observer {
    /**
    * 接收变动通知
    */
    void update();
}
/**
* 具体订阅人
*/
public static class RealObject implements Observer {
    @Override
    public void update() {
        System.out.println("接收到了通知");
    }
}
/*
* 具体的某家奶厂
*/
public static class RealSubject implements Subject{
    //本奶厂下订奶的人集合
    private List<Observer> observerList = new ArrayList<Observer>();
    //添加订阅者
    @Override
    public void attach(Observer observer) {
        observerList.add(observer);
    }
    //删除订阅者
    @Override
    public void detach(Observer observer) {
        observerList.remove(observer);
    }
    //消息通知订阅者
    @Override
    public void notifyChanged() {
        for (Observer observer : observerList) {
            observer.update();
        }
    }
}
public static void main(String[] args) {
    Subject subject = new RealSubject(); //创建奶厂
    Observer observer = new RealObject();//创建订阅人
    subject.attach(observer);//订阅subject奶厂
    subject.notifyChanged();//奶厂发布消息 订阅者接收
}

优点

观察者和被观察者是抽象耦合的

建立了一套触发机制

缺点

如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时

间如果观察者和观察目标间有循环依赖，可能导致系统崩溃

没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的