设计模式-创建者模式 | 字数总计: 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 建造者模式 抽象工厂模式实现对产品家族的创建,一个产品家族是这样的一系列产品:具有不同分类维度的产品组合,采用抽象工厂模式则是不需要关心构建过程,只关心什么产品由什么工厂生产即可。
建造者模式则是要求按照指定的蓝图建造产品,它的主要目的是通过组装零配件而产生一个新产品。
如果将抽象工厂模式看成汽车配件生产工厂,生产一个产品族的产品,那么建造者模式就是一个汽车组装工厂,通过对部件的组装可以返回一辆完整的汽车。