Java 常见的设计模式

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() {System.out.println("女友的素颜");
}
}
/**
* 抽象装饰器
* @author Administrator
*
*/
public abstract class Decorator implements Showable{
Showable showable ;//持有一个善于展示自己某个家伙
//构造时注入这个家伙
public Decorator(Showable showable){
this.showable = showable;
}
public abstract void show(); //无须实现 因为装饰器现在还不知道要怎么化妆
}
/**
* 描眉类继承装饰器类
*/
public class MiaoMei extends Decorator{
public MiaoMei(Showable showable) {
super(showable);//调用化妆品父类
}
//重写接口化妆后展示 描眉 化妆
public void show(){
System.out.println("描眉(");
showable.show();
System.out.println(")");
}
}
/**
* 涂口红继承装饰器类
*/
public class TuKouHong extends Decorator{
public TuKouHong(Showable showable) {
super(showable);//调用化妆品父类
}
//重写接口化妆后展示 涂口红 化妆
public void show(){
System.out.println("涂口红(");
showable.show();
System.out.println(")");
}
}
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();//奶厂发布消息 订阅者接收
}

优点
观察者和被观察者是抽象耦合的
建立了一套触发机制
缺点
如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时
间
如果观察者和观察目标间有循环依赖，可能导致系统崩溃
没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的