23种设计模式——创建型模式（Creational Patterns）
这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。
1.单例模式（Singleton Pattern）
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供了一个全局访问点来访问该实例。
注意：
- 1、单例类只能有一个实例。
- 2、单例类必须自己创建自己的唯一实例。
- 3、单例类必须给所有其他对象提供这一实例。
介绍
**意图：**保证一个类仅有一个实例，并提供一个访问它的全局访问点。
**主要解决：**一个全局使用的类频繁地创建与销毁。
**何时使用：**当您想控制实例数目，节省系统资源的时候。
**如何解决：**判断系统是否已经有这个单例，如果有则返回，如果没有则创建。
**关键代码：**构造函数是私有的。
应用实例：
- 1、一个班级只有一个班主任。
- 2、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。
- 3、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。
优点：
- 1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
- 2、避免对资源的多重占用（比如写文件操作）。
**缺点：**没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。
使用场景：
- 1、要求生产唯一序列号。
- 2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
- 3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。
**注意事项：**getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。
实现
我们将创建一个 SingleObject 类。SingleObject 类有它的私有构造函数和本身的一个静态实例。
SingleObject 类提供了一个静态方法，供外界获取它的静态实例。SingletonPatternDemo 类使用 SingleObject 类来获取 SingleObject 对象。
public class SingleObject extends SinglePattern {
//创建对象
private static SingleObject instance = new SingleObject();
private SingleObject(){}//构造器私有化
public static SingleObject getInstance(){//向外提供调用方法
return instance;
}
public void show(){
System.out.println("hello,world");
}
}
//SinglePattern中使用SingleObject对象
public class SinglePattern {
public static void main(String[] args) {
//编译错误
//SingleObject singleObject = new SingleObject();
SingleObject singleObject = SingleObject.getInstance();
singleObject.show();
}
}
单例模式的几种实现方式
1、懒汉式（线程不安全）
- **是否 Lazy 初始化：**是
- **是否多线程安全：**否
- **实现难度：**易
**描述：**这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。
这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
2、懒汉式(线程安全)
- **是否 Lazy 初始化：**是
- **是否多线程安全：**是
- **实现难度：**易
**描述：**这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。
优点：第一次调用才初始化，避免内存浪费。
缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。
getInstance() 的性能对应用程序不是很关键（该方法使用不太频繁）。
public class Singleton{
private static Singleton singleton;
private Singleton(){}
private static syschonized Singleton getInstance(){
if(singleton==null){
singleton = new Singleton();
}
return singleton;
}
}
3、饿汉式
- **是否 Lazy 初始化：**否
- **是否多线程安全：**是
- **实现难度：**易
**描述：**这种方式比较常用，但容易产生垃圾对象。
优点：没有加锁，执行效率会提高。
缺点：类加载时就初始化，浪费内存。
它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
}
4、双检锁/双重校验锁（DCL，即 double-checked locking）
- **JDK 版本：**JDK1.5 起
- **是否 Lazy 初始化：**是
- **是否多线程安全：**是
- **实现难度：**较复杂
**描述：**这种方式采用双锁机制，安全且在多线程情
public class Singleton{
private static Singleton singleton;
private Singleton(){}
private static getInstance(){
if(singleton==null){
synchonized(Singleton.class){
if(singleton==null){
singleton = new Singleton();
}
}
}
return singleton;
}
}
5、登记式/静态内部类
- **是否 Lazy 初始化：**是
- **是否多线程安全：**是
- **实现难度：**一般
**描述：**这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。
public class Singleton {
private static class SingletonHolder {
private static final Singleton SINGLETON = new Singleton();
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.SINGLETON;
}
}
6、枚举
- **JDK 版本：**JDK1.5 起
- **是否 Lazy 初始化：**否
- **是否多线程安全：**是
- **实现难度：**易
**描述：**这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。
public enum Singleton{
INSTANCE;
public Singleton(){}
}
2.工厂模式（Factory Pattern）
工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
工厂模式提供了一种将对象的实例化过程封装在工厂类中的方式。通过使用工厂模式，可以将对象的创建与使用代码分离，提供一种统一的接口来创建不同类型的对象。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对
介绍
**意图：**定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
**主要解决：**主要解决接口选择的问题。
**何时使用：**我们明确地计划不同条件下创建不同实例时。
**如何解决：**让其子类实现工厂接口，返回的也是一个抽象的产品。
**关键代码：**创建过程在其子类执行。
应用实例： 1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。 2、Hibernate 换数据库只需换方言和驱动就可以。
优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。
**缺点：**每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。
使用场景： 1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。 2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。 3、设计一个连接服务器的框架，需要三个协议，“POP3”、“IMAP”、“HTTP”，可以把这三个作为产品类，共同实现一个接口。
**注意事项：**作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。
工厂模式包含以下几个核心角色：
- 抽象产品（Abstract Product）：定义了产品的共同接口或抽象类。它可以是具体产品类的父类或接口，规定了产品对象的共同方法。
- 具体产品（Concrete Product）：实现了抽象产品接口，定义了具体产品的特定行为和属性。
- 抽象工厂（Abstract Factory）：声明了创建产品的抽象方法，可以是接口或抽象类。它可以有多个方法用于创建不同类型的产品。
- 具体工厂（Concrete Factory）：实现了抽象工厂接口，负责实际创建具体产品的对象。
实现
- 我们将创建一个 Shape 接口和实现 Shape 接口的实体类。下一步是定义工厂类 ShapeFactory。
- FactoryPatternDemo 类使用 ShapeFactory 来获取 Shape 对象。它将向 ShapeFactory 传递信息（CIRCLE / RECTANGLE / SQUARE），以便获取它所需对象的类型。
抽象产品（Abstract Product）
public interface Shape {
void show();
}
具体产品（Concrete Product）
public class Circle implements Shape{
@Override
public void show() {
System.out.println("绘制了一个圆");
}
}
public class Rectangle implements Shape{
@Override
public void show() {
System.out.println("绘制一个三角形");
}
}
抽象工厂（Abstract Factory）
public interface ShapeFactory {
Shape getShape(String type);
}
具体工厂（Concrete Factory）
public class ConcreteShapeFactory implements ShapeFactory{
@Override
public Shape getShape(String type) {
if(type==null){
return null;
} else if (type.equals("CIRCLE")) {
return new Circle();
}
else if (type.equals("RECTANGLE")) {
return new Rectangle();
}
return null;
}
客户端使用
public class Client {
public static void main(String[] args) {
ConcreteShapeFactory concreteShapeFactory = new ConcreteShapeFactory();
Shape rectangle = concreteShapeFactory.getShape("RECTANGLE");
}
}
总结
工厂设计模式的优点
- 面向接口编程，体现了面向对象的思想；
- 将创建对象的工作转移到了工厂类
JDK 中的工厂设计模式实例
1.java.util.Calendar, ResourceBundle and NumberFormat getInstance() 使用了工厂方法模式；
Calendar中getInstance()
Calendar中createCalendar()方法源码
private static Calendar createCalendar(TimeZone zone,
Locale aLocale)
{
CalendarProvider provider =
LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
.getCalendarProvider();
if (provider != null) {
try {
return provider.getInstance(zone, aLocale);
} catch (IllegalArgumentException iae) {
// fall back to the default instantiation
}
}
Calendar cal = null;
if (aLocale.hasExtensions()) {
String caltype = aLocale.getUnicodeLocaleType("ca");
if (caltype != null) {
cal = switch (caltype) {
case "buddhist" -> new BuddhistCalendar(zone, aLocale);
case "japanese" -> new JapaneseImperialCalendar(zone, aLocale);
case "gregory" -> new GregorianCalendar(zone, aLocale);
default -> null;
};
}
}
if (cal == null) {
if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
cal = new BuddhistCalendar(zone, aLocale);
} else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
&& aLocale.getCountry() == "JP") {
cal = new JapaneseImperialCalendar(zone, aLocale);
} else {
cal = new GregorianCalendar(zone, aLocale);
}
}
return cal;
}
2.valueOf() 在包装类中，如Boolean, Integer 也使用了工厂方法模式；
Integer
Integer中具体valueOf源码
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
3.抽象工厂模式（Abstract Factory Pattern）
抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
抽象工厂模式提供了一种创建一系列相关或相互依赖对象的接口，而无需指定具体实现类。通过使用抽象工厂模式，可以将客户端与具体产品的创建过程解耦，使得客户端可以通过工厂接口来创建一族产品。
介绍
**意图：**提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
**主要解决：**主要解决接口选择的问题。
**何时使用：**系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。
**如何解决：**在一个产品族里面，定义多个产品。
**关键代码：**在一个工厂里聚合多个同类产品。
**优点：**当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
**缺点：**产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。
使用场景： 1、QQ 换皮肤，一整套一起换。 2、生成不同操作系统的程序。
**注意事项：**产品族难扩展，产品等级易扩展。
抽象工厂模式包含以下几个核心角色：
- 抽象工厂（Abstract Factory）：声明了一组用于创建产品对象的方法，每个方法对应一种产品类型。抽象工厂可以是接口或抽象类。
- 具体工厂（Concrete Factory）：实现了抽象工厂接口，负责创建具体产品对象的实例。
- 抽象产品（Abstract Product）：定义了一组产品对象的共同接口或抽象类，描述了产品对象的公共方法。
- 具体产品（Concrete Product）：实现了抽象产品接口，定义了具体产品的特定行为和属性。
抽象工厂模式通常涉及一族相关的产品，每个具体工厂类负责创建该族中的具体产品。客户端通过使用抽象工厂接口来创建产品对象，而不需要直接使用具体产品的实现类。
实现
我们将创建 Shape 和 Color 接口和实现这些接口的实体类。下一步是创建抽象工厂类 AbstractFactory。接着定义工厂类 ShapeFactory 和 ColorFactory，这两个工厂类都是扩展了 AbstractFactory。然后创建一个工厂创造器/生FactoryProducer。
Client类使用 FactoryProducer 来获取 AbstractFactory 对象。它将向 AbstractFactory 传递形状信息 Shape（*CIRCLE / RECTANGLE *），以便获取它所需对象的类型。同时它还向 AbstractFactory 传递颜色信息 Color（RED / GREEN），以便获取它所需对象的类型。
抽象产品Shape和具体产品Circle Rectangle
//抽象产品
public interface Shape {
void draw();
}
//具体产品
class Circle implements Shape{
@Override
public void draw() {
System.out.println("绘制了一个圆");
}
}
class Rectangle implements Shape{
@Override
public void draw() {
System.out.println("绘制了一个矩形");
}
}
抽象产品Color和具体产品Red Green
//抽象产品
public interface Color {
void fill();
}
//具体产品
class Red implements Color{
@Override
public void fill() {
System.out.println("填充成红色");
}
}
class Green implements Color{
@Override
public void fill() {
System.out.println("填充成绿色");
}
}
抽象工厂AbstractFactory和具体工厂ShapeFactory ColorFactory
//抽象工厂AbstractFactory
public abstract class AbstractFactory {
public abstract Shape getShape(String shape);
public abstract Color getColor(String color);
}
//以下是具体工厂 ShapeFactory 和 ColorFactory
class ShapeFactory extends AbstractFactory{
@Override
public Shape getShape(String shape) {
if(shape.equalsIgnoreCase("CIRCLE")){
return new Circle();
} else if (shape.equalsIgnoreCase("RECTANGLE")) {
return new Rectangle();
}
return null;
}
@Override
public Color getColor(String color) {
return null;
}
}
class ColorFactory extends AbstractFactory{
@Override
public Shape getShape(String shape) {
return null;
}
@Override
public Color getColor(String color) {
if(color.equalsIgnoreCase("RED")){
return new Red();
} else if (color.equalsIgnoreCase("GREEN")) {
return new Green();
}else{
return null;
}
}
}
工厂创建者FactoryProducer和客户端Client
public class FactoryProducer {
public static AbstractFactory getFactory(String factory){
if(factory.equalsIgnoreCase("COLOR")){
return new ColorFactory();
} else if (factory.equalsIgnoreCase("SHAPE")) {
return new ShapeFactory();
}
return null;
}
}
class Client{
public static void main(String[] args) {
//获取colorFactory 得到 red
AbstractFactory colorFactory = FactoryProducer.getFactory("color");
Color red = colorFactory.getColor("red");
red.fill();
//获取colorFactory 得到 red
AbstractFactory shapeFactory = FactoryProducer.getFactory("shape");
Shape circle = shapeFactory.getShape("circle");
circle.draw();
}
}
总结
优点：一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象（将一个系列的产品统一一起创建）；
缺点：
- 产品族扩展非常困难，要增加一个系列的某一产品，既要修改工厂抽象类里加代码，又修改具体的实现类里面加代码；
- 增加了系统的抽象性和理解难度
4.建造者模式（Builder Pattern）
建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。
介绍
**意图：**将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
**主要解决：**主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。
**何时使用：**一些基本部件不会变，而其组合经常变化的时候。
**如何解决：**将变与不变分离开。
关键代码：建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。
优点：
- 分离构建过程和表示，使得构建过程更加灵活，可以构建不同的表示。
- 可以更好地控制构建过程，隐藏具体构建细节。
- 代码复用性高，可以在不同的构建过程中重复使用相同的建造者。
缺点：
- 如果产品的属性较少，建造者模式可能会导致代码冗余。
- 建造者模式增加了系统的类和对象数量。
使用场景： 1、需要生成的对象具有复杂的内部结构。 2、需要生成的对象内部属性本身相互依赖。
建造者模式在创建复杂对象时非常有用，特别是当对象的构建过程涉及多个步骤或参数时。它可以提供更好的灵活性和可维护性，同时使得代码更加清晰可读。
**注意事项：**与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。
主要包含的角色
- Builder：抽象建造者
- ConcreteBuilder：具体建造者
- Director：指挥者
- Product：产品角色
实现
- 我们假设一个快餐店的商业案例，其中，一个典型的套餐可以是一个汉堡（Burger）和一杯冷饮（Cold drink）。
- ==汉堡（Burger）==可以是素食汉堡（Veg Burger）或鸡肉汉堡（Chicken Burger），它们是包在纸盒中。==冷饮（Cold drink）==可以是可口可乐（coke）或百事可（pepsi），它们是装在瓶子中。
- 我们将创建一个表示食物条目（比如汉堡和冷饮）的 Item 接口和实现 Item 接口的实体类，以及一个表示食物包装的 Packing 接口和实现 Packing 接口的实体类，汉堡是包在纸盒中，冷饮是装在瓶子中。
- 然后我们创建一个 Meal 类，带有 Item 的 ArrayList 和一个通过结合 Item 来创建不同类型的 Meal 对象的 MealBuilder。Client 类使用 MealBuilder 来创建一个 Meal。
创建一个表示食物条目Item
public interface Item {
public String name();
public Packing packing();
public float price();
}
创建扩展了 抽象Burger 和 其**具体实现子类ChickenBurger VegBurger **
public abstract class Burger implements Item{
@Override
public Packing packing() {
return new Wrapper();
}
}
class ChickenBurger extends Burger{
@Override
public String name() {
return "ChickenBurger";
}
@Override
public float price() {
return 30f;
}
}
class VegBurger extends Burger{
@Override
public String name() {
return "VegBurger";
}
@Override
public float price() {
return 20f;
}
}
抽象ColdDrink 的实体类和其具体实现子类Coke Pepsi
public abstract class ColdDrink implements Item{
@Override
public Packing packing() {
return new Bottle();
}
}
class Coke extends ColdDrink{
@Override
public String name() {
return "coke";
}
@Override
public float price() {
return 30f;
}
}
class Pepsi extends ColdDrink{
@Override
public String name() {
return "pepsi";
}
@Override
public float price() {
return 20f;
}
}
Packing和具体实现子类Wrapper Bottle
public interface Packing {
public String pack();
}
class Wrapper implements Packing{
@Override
public String pack() {
return "wrapper";
}
}
class Bottle implements Packing{
@Override
public String pack() {
return "bottle";
}
}
produc类Meal
public class Meal {
private List<Item> menu = new ArrayList<>();
public void addItem(Item item){
menu.add(item);
}
public float getPrice(){
float cost = 0.0f;
for (Item item:menu) {
cost += item.price();
}
return cost;
}
public void showDetail(){
for (Item item:menu) {
System.out.println("item"+item.name());
System.out.println("item"+item.packing());
System.out.println("item"+item.price());
}
}
}
builderl类MealBuilder
public class MealBuilder {
public Meal prepareVegMeal(){
Meal meal = new Meal();
meal.addItem(new VegBurger());
meal.addItem(new Coke());
return meal;
}
public Meal prepareNonVegMeal(){
Meal meal = new Meal();
meal.addItem(new ChickenBurger());
meal.addItem(new Pepsi());
return meal;
}
}
Client类调用
public class Client {
public static void main(String[] args) {
MealBuilder mealBuilder = new MealBuilder();
Meal nonVegMealmeal = mealBuilder.prepareNonVegMeal();
nonVegMealmeal.showDetail();
System.out.println("=======================");
Meal vegMeal = mealBuilder.prepareVegMeal();
vegMeal.showDetail();
}
}
JAVA 中的 StringBuilder。
角色分析
- StringBuilder是一个指挥者同时是一个具体建造者
- AbstractStringBuilder是Appendable的一个是实现类，为具体建造者
- Appendable接口定义了append()方法，是抽象建造者
源码分析
1. 创建StringBuilder对象时传入字符串，传入的字符串就相当于指定产品类型，需要构建什么样的产品对象
2. 进入到super.append()中，AbstractStringBuilder实现了Appendable，他是具体的建造者，在这里完成了一个具体的操作
abstract class AbstractStringBuilder implements Appendable, CharSequence {
public AbstractStringBuilder append(String str) {
if (str == null)
return appendNull();
int len = str.length();
ensureCapacityInternal(count + len);
str.getChars(0, len, value, count);
count += len;
return this;
}
}
3. Appendable定义了多个append接口，由他的实现类去实现，方便后续的可扩展性
public interface Appendable {
Appendable append(CharSequence csq) throws IOException;
Appendable append(CharSequence csq, int start, int end) throws IOException;
Appendable append(char c) throws IOException;
}
4.小结
- 建造者模式可以更加精细的控制产品的创建过程，将复杂产品的创建步骤分解在不同的方法中，也方便控制
- 增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合开闭原则
- 原则上每个具体建造者是相对独立的，除了在足够简单的结构下，具体建造者和指挥者可以有直接关联（如上StringBuilder），因为相对独立所以可以很方便的增加或者替换具体建造者，系统耦合度较低
- 建造者模式所建造的产品要有较多的共同点，组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式
- 产品内部变化复杂的话，会导致定义很多具体建造者来适应变化的需求，这样系统会很庞大
5.原型模式（Prototype Pattern）
原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式之一。
这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。
介绍
**意图：**用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
**主要解决：**在运行期建立和删除原型。
何时使用：
- 当一个系统应该独立于它的产品创建，构成和表示时。
- 当要实例化的类是在运行时刻指定时，例如，通过动态装载。
- 为了避免创建一个与产品类层次平行的工厂类层次时。
- 当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。
**如何解决：**利用已有的一个原型对象，快速地生成和原型对象一样的实例。
关键代码：
- 实现克隆操作，在 JAVA 实现 Cloneable 接口，重写 clone()，在 .NET 中可以使用 Object 类的 MemberwiseClone() 方法来实现对象的浅拷贝或通过序列化的方式来实现深拷贝。
- 原型模式同样用于隔离类对象的使用者和具体类型（易变类）之间的耦合关系，它同样要求这些"易变类"拥有稳定的接口。
优点： 1、性能提高。 2、逃避构造函数的约束。
缺点： 1、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。 2、必须实现 Cloneable 接口。
使用场景：
- 资源优化场景。
- 类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。 3、性能和安全要求的场景。
- 通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。 一个对象多个修改者的场景。
- 一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。
- 在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。
**注意事项：**与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。浅拷贝实现 Cloneable，重写，深拷贝是通过实现 Serializable 读取二进制流。
实现
我们将创建一个抽象类 *Shape* 和扩展了 Shape 类的实体类。下一步是定义类 ShapeCache，该类把 shape 对象存储在一个 HashMap 中，并在请求的时候返回它们的克隆。
Client 类使用 ShapeCache 类来获取 Shape 对象。
实现Cloneable 接口的抽象类Shape,和其子类Circle Rectangle
public abstract class Shape implements Cloneable{
private String id;
protected String type;
abstract void draw();
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public Object clone(){
Object clone = null;
try {
clone = super.clone();
} catch (CloneNotSupportedException e) {
throw new RuntimeException(e);
}
return clone;
}
}
class Rectangle extends Shape{
public Rectangle(){
type = "Rectangle";
}
@Override
void draw() {
System.out.println("绘制了一个矩形");
}
}
class Circle extends Shape{
public Circle(){
type = "Circle";
}
@Override
void draw() {
System.out.println("绘制了一个圆形");
}
}
从数据库获取实体类ShapeCache，并把它们存储在一个 HashMap 中。
public class ShapeCache {
private static Map<String,Shape> cache = new HashMap<>();
public static Shape getShape(String id){
Shape shape = cache.get(id);
return (Shape) shape.clone();
}
public static void load(){
Circle circle = new Circle();
circle.setId("1");
cache.put(circle.getId(),circle);
Rectangle rectangle = new Rectangle();
rectangle.setId("2");
cache.put(rectangle.getId(),rectangle);
}
}
Client使用 ShapeCache 类来获取存储在 Hashtable 中的形状的克隆
public class Client {
public static void main(String[] args) {
ShapeCache.load();
Shape circle1 = ShapeCache.getShape("1");
Shape circle2 = ShapeCache.getShape("1");
System.out.println("circle1:"+circle1.hashCode() +" circle2:"+circle2.hashCode());
Shape rectangle1 = ShapeCache.getShape("2");
Shape rectangle2 = ShapeCache.getShape("2");
System.out.println("rectangle1:"+rectangle1.hashCode() +" rectangle2:"+rectangle2.hashCode());
}
}
581
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
