设计模式-创建者模式
|字数总计:6.3k|阅读时长:23分钟|阅读量:
设计模式
一,创建型模式
用于描述“怎么创建对象”。它的主要特点是“将对象的创建与使用分离”。如,单例、原型、工厂方法、抽象工厂、建造者等5种创建型模式。
- 单例(Singleton)模式:某个类只能生成一个实例,该实例提供一个全局访问店供外部获取该对象,其扩展时有限多例模式。
- 原型(Prototype)模式:将一个对象作为原型,通过对其进行复制而克隆出多个和原型类型的新实例。
- 工厂方法(Factory Method)模式:定义一个用于创建产品的接口,有子类决定生产什么产品。
- 抽象工厂(Abstract Factory)模式:提供一个创建产品族的接口,其每个子类可以生产一些列相关的产品。
- 建造者(Builder)模式:将一个复杂对象分解成多个相对简单的部分,然后根据不同需要分别创建它们,最后构建从复杂对象。
1. 单例模式(Singleton)
参考资料:单例模式 | 菜鸟教程 (runoob.com)
确保任何情况下都绝对只有一个实例
想在程序中表现出“只存在一个实例”
1.1八种方式
加粗为推荐方式
- 饿汉式(静态常量)
- 饿汉式(静态代码块)
- 懒汉式(线程不安全)
- 懒汉式(线程安全,同步方法)
- 懒汉式(线程安全,同步代码块)
- 双重检查
- 静态内部类
- 枚举
1.1.1 饿汉式(静态常量)
1 2 3 4 5 6 7 8 9 10 11 12 13 14
|
class Singleton01 { private Singleton01() {}
private static Singleton01 instance = new Singleton01();
public static Singleton01 getInstance() { return instance; } }
|
优缺点说明:
优点:这种写法比较简单,就是在类装载的时候就完成实例化。避免了线程同步问题。
缺点:
1.在类装载的时候就完成实例化,没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例,则
会造成内存的浪费
2.这种方式基于classloder机制避免了多线程的同步问题,不过,instance在类装载时就实例化,在单例模 式中大
3.多数都是调用getInstance方法,但是导致类装载的原因有很多种,因此不能确定有其他的方式(或者其 他的静态方法)导致类装载,这时候初始化instance就没有达到lazy loading的效果
结论:这种单例模式可用,可能造成内存浪费
1.1.2 饿汉式(静态代码块)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
|
class Singleton01 { private static Singleton01 instance; static { instance = new Singleton01(); }
private Singleton01() { }
public static Singleton01 getInstance() { return instance; } }
|
1.1.3 懒汉式(双重检查)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
|
class Singleton01 {
private static volatile Singleton01 instance;
private Singleton01() { }
public static Singleton01 getInstance() { if (instance == null) { synchronized (Singleton01.class) { if (instance == null) { instance = new Singleton01(); } } } return instance; } }
|
优缺点说明:
- Double-Check概念是多线程开发中常使用到的,如代码中所示,我们进行了两次f(singleton=null)检查,这样就可以保证线程安全了。
- 这样,实例化代码只用执行一次,后面再次访问时,判断if(singleton=nul),直接return实例化对象,也避免的反复进行方法同步线程安全;延迟加载;效率较高
- 结论:在实际开发中,推荐使用这种单例设计模式
1.1.4 静态内部类
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
|
class Singleton01 { private static Singleton01 instance;
private Singleton01() { }
private static class SingletonInstance{ private static final Singleton01 INSTANCE = new Singleton01(); }
public static Singleton01 getInstance() { return SingletonInstance.INSTANCE; } }
|
优缺点说明:
1.这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
2.静态内部类方式在Singleton类被装载时并不会立即实例化,而是在需要实例化时,调用getInstance 方法,才会装载SingletonInstance类,从而完成Singleton的实例化。
3.类的静态属性只会在第一次加载类的时候初始化,所以在这里,JVM帮助我们保证了线程的安全性, 在类进行初始化时,别的线程是无法进入的。
4.优点:避免了线程不安全,利用静态内部类特点实现延迟加载,效率高
5.结论:推荐使用
1.1.5 枚举
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
|
public class SingletonTest01 { public static void main(String[] args) { Singleton instance1 = Singleton.INSTANCE; Singleton instance2 = Singleton.INSTANCE; System.out.println(instance1 == instance2); instance1.sayHi(); } }
enum Singleton { INSTANCE;
public void sayHi() { System.out.println("Hi!"); } }
|
优缺点说明:
1.这借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题,而且还能防止反序列化重新创建
新的对象。
2.这种方式是Effective Java作者Josh Bloch提倡的方式
3.结论:推荐使用
1.2.单例模式注意事项和细节说明
- 单例模式保证了系统内存中该类只存在一个对象,节省了系统资源,对于一些需要频繁创建销毁的对象,使
用单例模式可以提高系统性能
- 当想实例化一个单例类的时候,必须要记住使用相应的获取对象的方法,而不是使用new
- 单例模式使用的场景:需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即:重量级
对象),但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、session工厂等)
2. 工厂模式(Factory Pattern)
参考资料:工厂模式 | 菜鸟教程 (runoob.com)
定义一个创建对象的接口,让其子类自己决定实例化哪一个工厂类,工厂模式使其创建过程延迟到子类进行。
2.1 结构
工厂方法模式的主要角色:
- 抽象工厂(Abstract Factory):提供了创建产品的接口,调用者通过它访问具体工厂的工厂方法来创建产品。
- 具体工厂(ConcreteFactory):主要是实现抽象工厂中的抽象方法,完成具体产品的创建。
- 抽象产品(Product):定义了产品的规范,描述了产品的主要特性和功能。
- 具体产品(ConcreteProduct):实现了抽象产品角色所定义的接口,由具体工厂来创建,它同具体工厂之间一一对应。
2.2 实现
我们将创建一个 Shape 接口和实现 Shape 接口的实体类。下一步是定义工厂类 ShapeFactory。
FactoryPatternDemo 类使用 ShapeFactory 来获取 Shape 对象。它将向 ShapeFactory 传递信息(CIRCLE / RECTANGLE / SQUARE),以便获取它所需对象的类型。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
| public interface Shape { void draw(); }
public class Rectangle implements Shape { @Override public void draw() { System.out.println("Inside Rectangle::draw() method."); } }
public class Square implements Shape { @Override public void draw() { System.out.println("Inside Square::draw() method."); } }
public class Circle implements Shape { @Override public void draw() { System.out.println("Inside Circle::draw() method."); } }
public class ShapeFactory { public Shape getShape(String shapeType){ if(shapeType == null){ return null; } if(shapeType.equalsIgnoreCase("CIRCLE")){ return new Circle(); } else if(shapeType.equalsIgnoreCase("RECTANGLE")){ return new Rectangle(); } else if(shapeType.equalsIgnoreCase("SQUARE")){ return new Square(); } return null; } }
public class FactoryPatternDemo { public static void main(String[] args) { ShapeFactory shapeFactory = new ShapeFactory(); Shape shape1 = shapeFactory.getShape("CIRCLE"); shape1.draw(); Shape shape2 = shapeFactory.getShape("RECTANGLE"); shape2.draw(); Shape shape3 = shapeFactory.getShape("SQUARE"); shape3.draw(); } }
|
2.3 优缺点
优点:
- 用户只需要知道具体工厂的名称就可得到所要的产品,无须知道产品的具体创建过程;
- 在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类,无须对原工厂进行任何修改,满足开闭原则;
缺点:
- 每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类,这增加了系统的复杂度。
3. 抽象工厂模式(Abstract Factory)
参考资料:抽象工厂模式 | 菜鸟教程 (runoob.com)
抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
使用场景: 1、QQ 换皮肤,一整套一起换。 2、生成不同操作系统的程序。
3.1结构
抽象工厂模式的主要角色如下:
抽象工厂(Abstract Factory):提供了创建产品的接口,它包含多个创建产品的方法,可以创建多个不同等级的产品。
具体工厂(Concrete Factory):主要是实现抽象工厂中的多个抽象方法,完成具体产品的创建。
抽象产品(Product):定义了产品的规范,描述了产品的主要特性和功能,抽象工厂模式有多个抽象产品。
具体产品(ConcreteProduct):实现了抽象产品角色所定义的接口,由具体工厂来创建,它同具体工厂之间是多对一的关系。

4. 原型模式(Prototype Pattern)
参考资料:原型模式 | 菜鸟教程 (runoob.com)
原型模式(Prototype Pattern)是用于创建重复的对象,同时又能保证性能。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
这种模式是实现了一个原型接口,该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时,则采用这种模式。例如,一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象,在下一个请求时返回它的克隆,在需要的时候更新数据库,以此来减少数据库调用。
原型模式的克隆分为浅克隆和深克隆:
浅克隆:创建一个新对象,新对象的属性和原来对象完全相同,对于非基本类型属性,仍指向原有属性所指向的对象的内存地址。
深克隆:创建一个新对象,属性中引用的其他对象也会被克隆,不再指向原有对象地址。
4.1 结构:
原型模式包含如下角色:
- 抽象原型类:规定了具体原型对象必须实现的的 clone() 方法。
- 具体原型类:实现抽象原型类的 clone() 方法,它是可被复制的对象。
- 访问类:使用具体原型类中的 clone() 方法来复制新的对象。
接口类图如下:

4.2 浅克隆
4.2.1 案例:
用原型模式生成“三好学生”奖状
同一学校的“三好学生”奖状除了获奖人姓名不同,其他都相同,可以使用原型模式复制多个“三好学生”奖状出来,然后在修改奖状上的名字即可。
类图如下:
代码如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
| public class Citation implements Cloneable { private String name;
public void setName(String name) { this.name = name; }
public String getName() { return (this.name); }
public void show() { System.out.println(name + "同学:在2020学年第一学期中表现优秀,被评为三好学生。特发此状!"); }
@Override public Citation clone() throws CloneNotSupportedException { return (Citation) super.clone(); } }
public class CitationTest { public static void main(String[] args) throws CloneNotSupportedException { Citation c1 = new Citation(); c1.setName("张三");
Citation c2 = c1.clone(); c2.setName("李四");
c1.show(); c2.show(); } }
|
4.2.2 使用场景
- 对象的创建非常复杂,可以使用原型模式快捷的创建对象。
- 性能和安全要求比较高。
4.3 深克隆
将上面的“三好学生”奖状的案例中Citation类的name属性修改为Student类型的属性。代码如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
| public class Citation implements Cloneable { private Student stu;
public Student getStu() { return stu; }
public void setStu(Student stu) { this.stu = stu; }
void show() { System.out.println(stu.getName() + "同学:在2020学年第一学期中表现优秀,被评为三好学生。特发此状!"); }
@Override public Citation clone() throws CloneNotSupportedException { return (Citation) super.clone(); } }
public class Student { private String name; private String address;
public Student(String name, String address) { this.name = name; this.address = address; }
public Student() { }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public String getAddress() { return address; }
public void setAddress(String address) { this.address = address; } }
public class CitationTest { public static void main(String[] args) throws CloneNotSupportedException {
Citation c1 = new Citation(); Student stu = new Student("张三", "西安"); c1.setStu(stu);
Citation c2 = c1.clone(); Student stu1 = c2.getStu(); stu1.setName("李四");
System.out.println("stu和stu1是同一个对象?" + (stu == stu1));
c1.show(); c2.show(); } }
|
运行结果为:
说明:
stu对象和stu1对象是同一个对象,就会产生将stu1对象中name属性值改为“李四”,两个Citation(奖状)对象中显示的都是李四。这就是浅克隆的效果,对具体原型类(Citation)中的引用类型的属性进行引用的复制。这种情况需要使用深克隆,而进行深克隆需要使用对象流。代码如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
| public class CitationTest1 { public static void main(String[] args) throws Exception { Citation c1 = new Citation(); Student stu = new Student("张三", "西安"); c1.setStu(stu);
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Think\\Desktop\\b.txt")); oos.writeObject(c1); oos.close();
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\Think\\Desktop\\b.txt")); Citation c2 = (Citation) ois.readObject(); Student stu1 = c2.getStu(); stu1.setName("李四");
System.out.println("stu和stu1是同一个对象?" + (stu == stu1));
c1.show(); c2.show(); } }
|
运行结果为:
注意:Citation类和Student类必须实现Serializable接口,否则会抛NotSerializableException异常。
5. 建造者模式(Builder Pattern)
参考资料:建造者模式 | 菜鸟教程 (runoob.com)
建造者模式(Builder Pattern)使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。
5.1 结构
建造者(Builder)模式包含如下角色:
- 抽象建造者类(Builder):这个接口规定要实现复杂对象的那些部分的创建,并不涉及具体的部件对象的创建。
- 具体建造者类(ConcreteBuilder):实现 Builder 接口,完成复杂产品的各个部件的具体创建方法。在构造过程完成后,提供产品的实例。
- 产品类(Product):要创建的复杂对象。
- 指挥者类(Director):调用具体建造者来创建复杂对象的各个部分,在指导者中不涉及具体产品的信息,只负责保证对象各部分完整创建或按某种顺序创建。
类图如下:
5.2 实例
创建共享单车
生产自行车是一个复杂的过程,它包含了车架,车座等组件的生产。而车架又有碳纤维,铝合金等材质的,车座有橡胶,真皮等材质。对于自行车的生产就可以使用建造者模式。
这里Bike是产品,包含车架,车座等组件;Builder是抽象建造者,MobikeBuilder和OfoBuilder是具体的建造者;Director是指挥者。类图如下:
具体的代码如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
| public class Bike { private String frame; private String seat;
public String getFrame() { return frame; }
public void setFrame(String frame) { this.frame = frame; }
public String getSeat() { return seat; }
public void setSeat(String seat) { this.seat = seat; } }
public abstract class Builder {
protected Bike mBike = new Bike();
public abstract void buildFrame(); public abstract void buildSeat(); public abstract Bike createBike(); }
public class MobikeBuilder extends Builder {
@Override public void buildFrame() { mBike.setFrame("铝合金车架"); }
@Override public void buildSeat() { mBike.setSeat("真皮车座"); }
@Override public Bike createBike() { return mBike; } }
public class OfoBuilder extends Builder {
@Override public void buildFrame() { mBike.setFrame("碳纤维车架"); }
@Override public void buildSeat() { mBike.setSeat("橡胶车座"); }
@Override public Bike createBike() { return mBike; } }
public class Director { private Builder mBuilder;
public Director(Builder builder) { mBuilder = builder; }
public Bike construct() { mBuilder.buildFrame(); mBuilder.buildSeat(); return mBuilder.createBike(); } }
public class Client { public static void main(String[] args) { showBike(new OfoBuilder()); showBike(new MobikeBuilder()); } private static void showBike(Builder builder) { Director director = new Director(builder); Bike bike = director.construct(); System.out.println(bike.getFrame()); System.out.println(bike.getSeat()); } }
|
- 过程可以创建不同的产品对象。
- 可以更加精细地控制产品的创建过程 。将复杂产品的创建步骤分解在不同的方法中,使得创建过程更加清晰,也更方便使用程序来控制创建过程。
- 建造者模式很容易进行扩展。如果有新的需求,通过实现一个新的建造者类就可以完成,基本上不用修改之前已经测试通过的代码,因此也就不会对原有功能引入风险。符合开闭原则。
缺点:
造者模式所创建的产品一般具有较多的共同点,其组成部分相似,如果产品之间的差异性很大,则不适合使用建造者模式,因此其使用范围受到一定的限制。
5.3 使用场景
建造者(Builder)模式创建的是复杂对象,其产品的各个部分经常面临着剧烈的变化,但将它们组合在一起的算法却相对稳定,所以它通常在以下场合使用。
- 创建的对象较复杂,由多个部件构成,各部件面临着复杂的变化,但构件间的建造顺序是稳定的。
- 创建复杂对象的算法独立于该对象的组成部分以及它们的装配方式,即产品的构建过程和最终的表示是独立的。
5.4 模式扩展
建造者模式除了上面的用途外,在开发中还有一个常用的使用方式,就是当一个类构造器需要传入很多参数时,如果创建这个类的实例,代码可读性会非常差,而且很容易引入错误,此时就可以利用建造者模式进行重构。
重构前代码如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
| public class Phone { private String cpu; private String screen; private String memory; private String mainboard;
public Phone(String cpu, String screen, String memory, String mainboard) { this.cpu = cpu; this.screen = screen; this.memory = memory; this.mainboard = mainboard; }
public String getCpu() { return cpu; }
public void setCpu(String cpu) { this.cpu = cpu; }
public String getScreen() { return screen; }
public void setScreen(String screen) { this.screen = screen; }
public String getMemory() { return memory; }
public void setMemory(String memory) { this.memory = memory; }
public String getMainboard() { return mainboard; }
public void setMainboard(String mainboard) { this.mainboard = mainboard; }
@Override public String toString() { return "Phone{" + "cpu='" + cpu + '\'' + ", screen='" + screen + '\'' + ", memory='" + memory + '\'' + ", mainboard='" + mainboard + '\'' + '}'; } }
public class Client { public static void main(String[] args) { Phone phone = new Phone("intel","三星屏幕","金士顿","华硕"); System.out.println(phone); } }
|
上面在客户端代码中构建Phone对象,传递了四个参数,如果参数更多呢?代码的可读性及使用的成本就是比较高。
重构后代码:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
| public class Phone {
private String cpu; private String screen; private String memory; private String mainboard;
private Phone(Builder builder) { cpu = builder.cpu; screen = builder.screen; memory = builder.memory; mainboard = builder.mainboard; }
public static final class Builder { private String cpu; private String screen; private String memory; private String mainboard;
public Builder() {}
public Builder cpu(String val) { cpu = val; return this; } public Builder screen(String val) { screen = val; return this; } public Builder memory(String val) { memory = val; return this; } public Builder mainboard(String val) { mainboard = val; return this; } public Phone build() { return new Phone(this);} } @Override public String toString() { return "Phone{" + "cpu='" + cpu + '\'' + ", screen='" + screen + '\'' + ", memory='" + memory + '\'' + ", mainboard='" + mainboard + '\'' + '}'; } }
public class Client { public static void main(String[] args) { Phone phone = new Phone.Builder() .cpu("intel") .mainboard("华硕") .memory("金士顿") .screen("三星") .build(); System.out.println(phone); } }
|
重构后的代码在使用起来更方便,某种程度上也可以提高开发效率。从软件设计上,对程序员的要求比较高。
6 创建者模式对比
工厂模式 – >去饭店
建造者模式 – >自己做菜
6.1 工厂方法模式VS建造者模式
工厂方法模式注重的是整体对象的创建方式;而建造者模式注重的是部件构建的过程,意在通过一步一步地精确构造创建出一个复杂的对象。
我们举个简单例子来说明两者的差异,如要制造一个超人,如果使用工厂方法模式,直接产生出来的就是一个力大无穷、能够飞翔、内裤外穿的超人;而如果使用建造者模式,则需要组装手、头、脚、躯干等部分,然后再把内裤外穿,于是一个超人就诞生了。
6.2 抽象工厂模式VS建造者模式
抽象工厂模式实现对产品家族的创建,一个产品家族是这样的一系列产品:具有不同分类维度的产品组合,采用抽象工厂模式则是不需要关心构建过程,只关心什么产品由什么工厂生产即可。
建造者模式则是要求按照指定的蓝图建造产品,它的主要目的是通过组装零配件而产生一个新产品。
如果将抽象工厂模式看成汽车配件生产工厂,生产一个产品族的产品,那么建造者模式就是一个汽车组装工厂,通过对部件的组装可以返回一辆完整的汽车。