常用设计模式一(创建型模式)
来源:互联网 发布:邮件大师 mac 编辑:程序博客网 时间:2024/06/08 08:30
前言
很久前就一直想总结下常用的设计模式,但是各种原因一直拖到现在,下面我尝试用自己的理解去解释常用的设计模式,旨在让自己对常用设计模式有一个直观认识,过后回来能看懂并理解这些常用设计模式,当然如果这篇文章能帮到想了解设计的同学那就更好不过了。
概念介绍
设计模式分为三大类:
创建型模式(Creational Pattern):创建型模式对类的实例化过程进行了抽象,将软件模块中对象的创建和对象的使用分离。使软件的结构更加清晰,外界对于这些对象只需要知道它们共同的接口,而不需要清楚其具体的实现细节,使整个系统的设计更加符合单一职责原则。
创建型模式在创建什么(What),由谁创建(Who),何时创建(When)等方面都为软件设计者提供了尽可能大的灵活性。创建型模式隐藏了类的实例的创建细节,通过隐藏对象如何被创建和组合在一起达到使整个系统独立的目的。
设计模式中属于创建型模式的有:
单例模式、建造者模式、工厂方法模式、抽象工厂模式、原型模式。
其中常用的有:- 单例模式:保证一个类只有一个实例,并且提供对这个实例的全局访问方式。
- 建造者模式:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。
- 工厂方法模式:允许一个类的实例化推迟到子类中进行。
- 抽象工厂模式:提供一个创建相关或依赖对象的接口,而不指定对象的具体类。
这几个模式在这篇文章中都会有介绍。
结构型模式(Structural Pattern):结构型模式描述如何将类或者对象结合在一起形成更大的结构,就像搭积木,可以通过简单积木的组合形成复杂的、功能更为强大的结构。
结构型模式可以分为类结构型模式和对象结构型模式:
类结构型模式关心类的组合,由多个类可以组合成一个更大的系统,在类结构型模式中一般只存在继承关系和实现关系。
对象结构型模式关心类与对象的组合,通过关联关系使得在一个类中定义另一个类的实例对象,然后通过该对象调用其方法。 根据“合成复用原则”,在系统中尽量使用关联关系来替代继承关系,因此大部分结构型模式都是对象结构型模式。
设计模式中属于结构型模式的有:适配器模式、代理模式、享元模式、外观模式、桥接模式、组合模式、装饰器模式。
其中常用的有:- 适配器模式:将一个接口转换成客户希望的另一个接口,适配器模式使接口不兼容的那些类可以一起工作,其别名为包装器(Wrapper)。适配器模式既可以作为类结构型模式,也可以作为对象结构型模式。
- 代理模式:给某一个对象提供一个代理,并由代理对象控制对原对象的引用,它是一种对象结构型模式。
- 享元模式:运用共享技术有效地支持大量细粒度对象的复用。系统只使用少量的对象,而这些对象都很相似,状态变化很小,可以实现对象的多次复用。由于享元模式要求能够共享的对象必须是细粒度对象,因此它又称为轻量级模式,它是一种对象结构型模式。
这几个模式会在下篇文章中介绍。
行为型模式(Behavioral Pattern):行为型模式是对在不同的对象之间划分责任和算法的抽象化。行为型模式不仅仅关注类和对象的结构,而且重点关注它们之间的相互作用。通过行为型模式,可以更加清晰地划分类与对象的职责,并研究系统在运行时实例对象 之间的交互。在系统运行时,对象并不是孤立的,它们可以通过相互通信与协作完成某些复杂功能,一个对象在运行时也将影响到其他对象的运行。
设计模式中属于行为型模式的有:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
其中常用的有:- 策略模式:定义一系列算法,将每一个算法封装起来,并让它们可以相互替换。策略模式让算法独立于使用它的客户而变化,也称为政策模式。
- 观察者模式:定义对象间的一种一对多依赖关系,使得每当一个对象状态发生改变时,其相关依赖对象皆得到通知并被自动更新。
单例模式
单例模式是最常用的设计模式之一,是为了保证单例对象的类只有一个实例存在,并保证整个系统只需要拥有一个全局对象。
使用场景
确保某个类在全局中只需要存在一个对象的场景。如:访问IO和数据库时,使用单例模式可以避免浪费资源。
懒汉模式
懒汉模式是声明一个静态变量,在调用对象类提供的get方法时就进行初始化,如下:
public class LazySingleton { private static LazySingleton mSingleton; public static synchronized LazySingleton getLazySingleton() { if (mSingleton == null) { mSingleton = new LazySingleton(); } return mSingleton; }}
懒汉模式只会在使用时才会被实例化,可以节约一定的资源,但是每次调用getLazySingleton都会进行同步,造成不必要的同步开销,这种模式一般不建议使用。
饿汉模式
饿汉模式在类加载的时候就进行了初始化,所以类加载会稍慢,但是调用类实例时由于类已经初始化所以获取速度很快。如下:
public class HungrySingleton { private static HungrySingleton mSingleton = new HungrySingleton(); public static HungrySingleton getHungrySingleton() { return mSingleton; }}
双重检查模式 (Double CheckLock)
DCL方式的优点是能保证在需要是单例才会初始化的同时保证线程安全。如下:
public class DCLSingleton { private static DCLSingleton mSingleton; public static DCLSingleton getDCLSingleton() { if (mSingleton == null) { synchronized (DCLSingleton.class) { if (mSingleton == null) { mSingleton = new DCLSingleton(); } } } return mSingleton; }}
静态内部类单例模式
这种方式不仅能确保线程安全也能保证Singleton类的唯一性,这是推荐使用的静态内部类单例模式。
public class StaticSingleton { public static StaticSingleton getStaticSingleton() { return StaticSingletonHolder.singleton; } private static class StaticSingletonHolder { private static final StaticSingleton singleton = new StaticSingleton(); }}
小结
以上四种是比较常用的单例写法,单例模式在日常开发中使用很多,在Android源码中也有使用。
建造者模式
建造者模式是一步步创建复杂对象的创建型模式,这个模式可以让用户在不知道内部构建细节的情况下,控制对象的构造流程。如汽车有车轮、方向盘、座椅还有各种小零件等,将这些部件组装成一辆汽车就是一个复杂的过程。在这个事例里汽车就是一个复杂的对象,而将汽车部件组装成汽车的过程就是复杂对象的构建流程。建造者模式将复杂对象的构建过程和部件进行了良好的解耦,将耦合度降到最低。
使用场景
- 相同方法不同执行顺序会产生不同的事件结果时。
- 多个部件或者零件都可以装配到一个对象中,但是产生的 运行结果又不相同时。
- 产品类是个复杂的对象,或产品类调用顺序不同就会产生不同的作用时。
- 当初始化一个对象异常复杂时。
例子
使用建造者模式组装一台汽车,假定一辆汽车只需要有车轮、方向盘、座椅这三个部件。那么一个汽车类就有如下几个变量和组装方法:
产品类
public class Car { private String mWheel;//车轮 private String mSteering;//方向盘 private String mSeat;//座椅 /** * 组装车轮 * * @param mWheel */ public void setmWheel(String mWheel) { this.mWheel = mWheel; } /** * 组装方向盘 * * @param mSteering */ public void setmSteering(String mSteering) { this.mSteering = mSteering; } /** * 组装座椅 * * @param mSeat */ public void setmSeat(String mSeat) { this.mSeat = mSeat; } @Override public String toString() { return "Car{" + "mWheel='" + mWheel + '\'' + ", mSteering='" + mSteering + '\'' + ", mSeat='" + mSeat + '\'' + '}'; }}
Builder类组装模板
一个良好的汽车组装流程应该有一套组装模板,模板包含各种控件的组装方法,这里的组装模板类如下
public abstract class Builder { public abstract void buildWheel(String wheel); public abstract void buildSteering(String settring); public abstract void buildSeat(String seat); public abstract Car createCar();}
而要想组装一辆具体的车必须传承这套组装模板:
public class SixSixSixCarBuilder extends Builder { private Car mCar = new Car(); @Override public void buildWheel(String wheel) { mCar.setmWheel(wheel); } @Override public void buildSteering(String steering) { mCar.setmSteering(steering); } @Override public void buildSeat(String seat) { mCar.setmSeat(seat); } @Override public Car createCar() { return mCar; }}
然后还需要一个指挥者(Director )去规范指挥组装流程:
public class Director { Builder mBuild = null; public Director(Builder build) { this.mBuild = build; } public Car createCar(String wheel, String steering, String seat) { this.mBuild.buildWheel(wheel); this.mBuild.buildSteering(steering); this.mBuild.buildSeat(seat); return mBuild.createCar(); }}
这时候谁要造汽车只需要找到这个指挥者即可,测试如下
public class Test{ public static void main(string[] args){ Builder builder=new SixSixSixCarBuilder(); Director director=new Director(builder); director.createCar("米其林三星轮胎","真皮方向盘","真皮座椅"); System.out.println("汽车信息:"+builder.createCar().toString()); }}
小结
从上面例子得出建造者模式主要有以下几个结构构成:
- Product: 产品类。
- Builder:抽象Builder类,规范产品的组建,子类会继承这个类实现具体的建造流程。
- ConcreteBulider: 上面Builder的实现类,实现抽象Builder类定义的所有方法,并且返回一个组建好的对象。
- Director: 指挥者类,用于统一组装流程。
实际开发中Director类经常是忽略的,直接用Builder来对对象进行组装,如下:
public class Test{ public static void main(string[] args){ Builder builder=new SixSixSixCarBuilder(); builder.buildWheel("米其林三星轮胎"); builder.buildSteering("真皮方向盘"); builder.buildSeat("真皮座椅"); System.out.println("汽车信息:"+builder.createCar().toString()); }}
这个Builder一般写成链式调用,这时Builder类的setter方法需要返回自身,如下:
public abstract class Builder { public abstract Builder buildWheel(String wheel); public abstract Builder buildSteering(String steering); public abstract Builder buildSeat(String seat); public abstract Car createCar();}
public class SixSixSixCarBuilder extends Builder { private Car mCar = new Car(); @Override public SixSixSixCarBuilder buildWheel(String wheel) { mCar.setmWheel(wheel); return this; } @Override public SixSixSixCarBuilder buildSteering(String steering) { mCar.setmSteering(steering); return this; } @Override public SixSixSixCarBuilder buildSeat(String seat) { mCar.setmSeat(seat); return this; } @Override public Car createCar() { return mCar; }}
调用时:
public class Test{ public static void main(string[] args){ Builder builder=new SixSixSixCarBuilder(); builder.buildWheel("米其林三星轮胎") .buildSteering("真皮方向盘") .buildSeat("真皮座椅") .createCar(); System.out.println("汽车信息:" + builder.createCar().toString()); }}
工厂方法模式
工厂方法模式是应用最广泛的模式,它定义一个用于创建对象的接口,让子类决定实例化哪个类。
使用场景
任何需要生成复杂对象的地方都可以使用工厂方法模式。
例子
还是组装汽车,具体组装k3、k5属于同一车型的两款车。由于是同一车型所以一条生产线足够。
先明确汽车需要的功能,即汽车抽象基类:
public abstract class QiYaCar { public abstract void drive();//汽车可以开 public abstract void speedUp();//汽车可以加速}
创建抽象生产线定义类:
public abstract class QiYaFactory { /** * * @param clzz 具体汽车型号 * @return 具体的汽车 */ public abstract <T extends QiYaCar> T createQiYaCar(Class clzz);}
创建具体的生产线:
public class QiYaCreateFactory extends QiYaFactory{ @Override public <T extends QiYaCar> T createQiYaCar(Class clzz) { QiYaCar car= null; try { car = (QiYaCar) Class.forName(clzz.getName()).newInstance(); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } return (T) car; }}
生产具体车型:
public class QiYaK3Car extends QiYaCar{ @Override public void drive() { System.out.println("k3启动"); } @Override public void speedUp() { System.out.println("k3加速"); }}
public class QiYaK5Car extends QiYaCar{ @Override public void drive() { System.out.println("k5启动"); } @Override public void speedUp() { System.out.println("k5加速"); }}
把上面各个类组装起来就可以形成一条完整的流水线:
public class Client{ public static void main(string[] args){ QiYaFactory factory = new QiYaCreateFactory(); QiYaK3Car k3Car = factory.createQiYaCar(QiYaK3Car.class); k3Car.drive(); k3Car.speedUp(); QiYaK5Car k5Car = factory.createQiYaCar(QiYaK5Car.class); k5Car.drive(); k5Car.speedUp(); }}
小结
工厂方法模式是一个很好的设计模式,但是从上面例子也可以看出,工厂方法模式也有一定的缺点,比如当添加新的产品时就要编写一个新的产品类,同时还要引用抽象层,导致类的结构复杂化。是否使用工厂方法模式需要根据实际需求决定。
抽象工厂模式
抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类。抽象工厂模式又称为Kit模式,属于对象创建型模式。
使用场景
一个对象族有相同约束时可以使用抽象工厂模式,如Android、ios都有拨号软件,这个软件属于软件的范畴,但是所在的操作系统不一样,这时候开业考虑使用抽象工厂模式来设计拨号软件。
例子
起亚和现代有两条生成线,一个中型车,一个SUV。抽象工厂模式来进行实现这两条生产线。
首先是抽象产品类:
public abstract class BetweenCar{ public abstract void drive();//汽车可以开 public abstract void speedUp();//汽车加速}
public abstract class SUVCar{ public abstract void drive();//汽车可以开 public abstract void speedUp();//汽车加速}
生产具体产品
public class QiYaBetweenCar extends BetweenCar{ @Override public void drive() { System.out.println("起亚中型车启动"); } @Override public void speedUp() { System.out.println("起亚中型车加速"); }}
public class XianDaiBetweenCar extends BetweenCar{ @Override public void drive() { System.out.println("现代中型车启动"); } @Override public void speedUp() { System.out.println("现代中型车加速"); }}
public class QiYaSUVCar extends SUVCar { @Override public void drive() { System.out.println("起亚SUV启动"); } @Override public void speedUp() { System.out.println("起亚SUV加速"); }}
public class XianDaiSUVCar extends SUVCar { @Override public void drive() { System.out.println("现代SUV启动"); } @Override public void speedUp() { System.out.println("现代SUV加速"); }}
创建生产汽车的抽象工厂里面有两条生产线,即生产中型车和SUV
public abstract class CarFactory { public abstract BetweenCar createBetweenCar(); public abstract SUVCar createSUVCar();}
定义具体的工厂
public class QiYaCarFactory extends CarFactory{ @Override public BetweenCar createBetweenCar() { return new QiYaBetweenCar(); } @Override public SUVCar createSUVCar() { return new QiYaSUVCar(); }}
public class XianDaiCarFactory extends CarFactory { @Override public BetweenCar createBetweenCar() { return new XianDaiBetweenCar(); } @Override public SUVCar createSUVCar() { return new XianDaiSUVCar(); }}
最后客户端调用
public class Client{ public static void main(string[] args){ CarFactory qiYaCarFactory = new QiYaCarFactory(); qiYaCarFactory.createBetweenCar().drive(); qiYaCarFactory.createBetweenCar().speedUp(); qiYaCarFactory.createSUVCar().drive(); qiYaCarFactory.createSUVCar().speedUp(); CarFactory xianDaiCarFactory = new XianDaiCarFactory(); xianDaiCarFactory.createBetweenCar().drive(); xianDaiCarFactory.createBetweenCar().speedUp(); xianDaiCarFactory.createSUVCar().drive(); xianDaiCarFactory.createSUVCar().speedUp(); }}
小结
抽象工厂模式一个显著的优点是分离接口与实现,客户端使用抽象工厂来创建需要的对象,而客户端不需要知道具体实现是谁,客户端只是面向产品的接口编程,使其从具体的产品视线中解耦,在切换产品类时更加灵活。当然抽象工厂模式不容易扩展新的产品类,因为增加一个产品类就需要修改抽象工厂,则所有具体工厂类都要修改。
- 常用设计模式一(创建型模式)
- 设计模式(一):创建型模式
- 设计模式(一)--创建型模式
- 创建型设计模式(一)
- [设计模式笔记]一. 创建型模式
- JAVA设计模式一 创建型模式
- 走进设计模式(一)-创建型模式
- 设计模式-创建型软件设计模式(一)
- 设计模式:创建型模式(一)
- 设计模式(一)工厂模式Factory(创建型)
- 设计模式(一)工厂模式Factory(创建型)
- 设计模式(一)工厂模式Factory(创建型)
- 设计模式(一)工厂模式Factory(创建型)
- 设计模式(一)工厂模式Factory(创建型)
- 设计模式(一)工厂模式Factory(创建型)
- 设计模式(一)工厂模式Factory(创建型)
- 设计模式(一)工厂模式Factory(创建型)
- 设计模式(一)工厂模式Factory(创建型)
- UIGestureRecognizer 手势识别
- Linux 文件系统扩展属性(对文件进行锁定)
- Java设计模式10——外观模式
- C_栈的应用----行编辑程序
- 15. 3Sum
- 常用设计模式一(创建型模式)
- Android TranslateAnimation实现View的显示与隐藏动画
- ionic3 使用--prod时间过长问题解决(完美解决)
- 练习赛 无尽的矩阵 最小循环矩阵(kmp hash)
- HTML、CSS、JavaScript基础知识
- 项目小坑勤记
- Java程序-2
- thinkPHP中使用join进行两个表关联查询
- Python3中bytes与string的互相转换