首页 / 设计模式 / 面向对象-设计模式-创建型

面向对象-设计模式-创建型

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了面向对象-设计模式-创建型，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含10996字，纯文字阅读大概需要16分钟。

内容图文

面向对象-设计模式-创建型

晴川历历汉阳树，芳草萋萋鹦鹉洲。

简介：面向对象-设计模式-创建型。

一、概述

何谓设计模式：

设计模式(Design Pattern)是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。

设计模式的好处&学习目的：

1、为了代码可重用行、让代码更易被他人理解、保证代码的可靠性、使代码编写真正实现工程化；

2、设计模式便于我们维护项目，增强系统的健壮性和可扩展性；

3、设计模式还可以锻炼码农的设计思维、升华代码质量等。

二、创建型

单例模式、简单工厂模式、工厂方法模式、抽象工厂模式、生成器模式、原型模式。

1、单例（Singleton）

单例模式参考链接：https://www.cnblogs.com/taojietaoge/p/10336439.html

Intent

确保一个类只有一个实例，并提供该实例的全局访问点。

Class Diagram

使用一个私有构造函数、一个私有静态变量以及一个公有静态函数来实现。

私有构造函数保证了不能通过构造函数来创建对象实例，只能通过公有静态函数返回唯一的私有静态变量。

技术分享图片

Implementation

Ⅰ 懒汉式-线程不安全

以下实现中，私有静态变量 uniqueInstance 被延迟实例化，这样做的好处是，如果没有用到该类，那么就不会实例化 uniqueInstance，从而节约资源。

这个实现在多线程环境下是不安全的，如果多个线程能够同时进入 if (uniqueInstance == null) ，并且此时 uniqueInstance 为 null，那么会有多个线程执行 uniqueInstance = new Singleton(); 语句，这将导致实例化多次 uniqueInstance。

                
                     1
                    //
                     懒汉模式-线程不安全
                     2
                    public
                    class
                     Singleton {

                     3
                     4
                    private
                    static
                     Singleton uniqueInstance;

                     5
                     6
                    private
                     Singleton() {

                     7
                        }

                     8
                     9
                    public
                    static
                     Singleton getUniqueInstance() {

                    10
                    if (uniqueInstance == null) {
11             uniqueInstance = new Singleton();
12        }
13return uniqueInstance;
14    }
15 }

View Code

Ⅱ 饿汉式-线程安全

线程不安全问题主要是由于 uniqueInstance 被实例化多次，采取直接实例化 uniqueInstance 的方式就不会产生线程不安全问题。

但是直接实例化的方式也丢失了延迟实例化带来的节约资源的好处。

                
                     1
                    //
                     饿汉模式
                     2
                    public
                    class
                     Singleton {

                     3
                     4
                    private
                    static Singleton uniqueInstance = new Singleton();
 5 6private Singleton() {
 7    }
 8 9publicstatic Singleton getUniqueInstance() {
10return uniqueInstance;
11    }
12 }

View Code

Ⅲ 懒汉式-线程安全

只需要对 getUniqueInstance() 方法加锁，那么在一个时间点只能有一个线程能够进入该方法，从而避免了实例化多次 uniqueInstance。

但是当一个线程进入该方法之后，其它试图进入该方法的线程都必须等待，即使 uniqueInstance 已经被实例化了。这会让线程阻塞时间过长，因此该方法有性能问题，不推荐使用。

                
                     1
                    //
                     懒汉模式-线程安全方法
                     2
                    public
                    class
                     Singleton {

                     3
                     4
                    private
                    static
                     Singleton uniqueInstance;

                     5
                     6
                    private
                     Singleton() {

                     7
                        }

                     8
                     9
                    public
                    static
                    synchronized Singleton getUniqueInstance() {  // synchronized 加锁10if (uniqueInstance == null) {
11             uniqueInstance = new Singleton();
12        }
13return uniqueInstance;
14    }
15 }

View Code

Ⅳ 双重校验锁-线程安全

uniqueInstance 只需要被实例化一次，之后就可以直接使用了。加锁操作只需要对实例化那部分的代码进行，只有当 uniqueInstance 没有被实例化时，才需要进行加锁。

双重校验锁先判断 uniqueInstance 是否已经被实例化，如果没有被实例化，那么才对实例化语句进行加锁。

                
                     1
                    //
                     双重校验锁
                     2
                    public
                    class
                     Singleton {

                     3
                     4
                    private
                    volatile
                    static Singleton uniqueInstance;  // 使用 volatile 关键字修饰，禁止JVM 指令重排序 5 6private Singleton() {
 7    }
 8 9publicstatic Singleton getUniqueInstance() {
10if (uniqueInstance == null) {
11synchronized (Singleton.class) {  // synchronized 对实例化语句加锁12if (uniqueInstance == null) {
13                     uniqueInstance = new Singleton();
14                }
15            }
16        }
17return uniqueInstance;
18    }
19 }

View Code

考虑下面的实现，也就是只使用了一个 if 语句。在 uniqueInstance == null 的情况下，如果两个线程都执行了 if 语句，那么两个线程都会进入 if 语句块内。虽然在 if 语句块内有加锁操作，但是两个线程都会执行 uniqueInstance = new Singleton(); 这条语句，只是先后的问题，那么就会进行两次实例化。因此必须使用双重校验锁，也就是需要使用两个 if 语句：第一个 if 语句用来避免 uniqueInstance 已经被实例化之后的加锁操作，而第二个 if 语句进行了加锁，所以只能有一个线程进入，就不会出现 uniqueInstance == null 时两个线程同时进行实例化操作。

            
                1
                if (uniqueInstance == null) {
2synchronized (Singleton.class) {  // 如果两个线程都执行了 if 语句3         uniqueInstance = new Singleton();
4    }
5 }

uniqueInstance 采用 volatile 关键字修饰也是很有必要的， uniqueInstance = new Singleton(); 这段代码其实是分为三步执行：

为 uniqueInstance 分配内存空间
初始化 uniqueInstance
将 uniqueInstance 指向分配的内存地址

但是由于 JVM 具有指令重排的特性，执行顺序有可能变成 1>3>2。指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例。例如，线程 T₁ 执行了 1 和 3，此时 T₂ 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。

使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。

volatile 如何保证禁止指令重排序参考链接：https://www.cnblogs.com/taojietaoge/p/10260888.html

Ⅴ 静态内部类实现

当 Singleton 类被加载时，静态内部类 SingletonHolder 没有被加载进内存。只有当调用 getUniqueInstance() 方法从而触发 SingletonHolder.INSTANCE 时 SingletonHolder 才会被加载，此时初始化 INSTANCE 实例，并且 JVM 能确保 INSTANCE 只被实例化一次。

这种方式不仅具有延迟初始化的好处，而且由 JVM 提供了对线程安全的支持。

Ⅵ 枚举实现

1 使用枚举类实现单例的好处：写法简单、默认线程安全、反序列化（反射、克隆）时也不会创建新的对象。

                
                     1
                    //
                     枚举类实现单例
                     2
                    public
                    enum
                     Singleton {

                     3
                     4
                        INSTANCE;

                     5
                     6
                    private
                     String objName;

                     7
                     8
                     9
                    public
                     String getObjName() {

                    10
                    return
                     objName;

                    11
                        }

                    12
                    13
                    14
                    public
                    void
                     setObjName(String objName) {

                    15
                    this.objName = objName;
16    }
171819publicstaticvoid main(String[] args) {
2021// 单例测试22         Singleton firstSingleton = Singleton.INSTANCE;
23         firstSingleton.setObjName("firstName");
24        System.out.println(firstSingleton.getObjName());
25         Singleton secondSingleton = Singleton.INSTANCE;
26         secondSingleton.setObjName("secondName");
27        System.out.println(firstSingleton.getObjName());
28        System.out.println(secondSingleton.getObjName());
2930// 反射获取实例测试31try {
32             Singleton[] enumConstants = Singleton.class.getEnumConstants();
33for (Singleton enumConstant : enumConstants) {
34                System.out.println(enumConstant.getObjName());
35            }
36         } catch (Exception e) {
37            e.printStackTrace();
38        }
39    }
40 }

View Code

            
                1
                输出：

                2
                firstName

                3
                secondName

                4
                secondName

                5 secondName

该实现可以防止反射攻击。在其它实现中，通过 setAccessible() 方法可以将私有构造函数的访问级别设置为 public，然后调用构造函数从而实例化对象，如果要防止这种攻击，需要在构造函数中添加防止多次实例化的代码。该实现是由 JVM 保证只会实例化一次，因此不会出现上述的反射攻击。

该实现在多次序列化和序列化之后，不会得到多个实例。而其它实现需要使用 transient 修饰所有字段，并且实现序列化和反序列化的方法。

单例小结

最佳的单例实现模式就是枚举模式。利用枚举的特性，让JVM 来帮我们保证线程安全和单一实例。

2、简单工厂（Simple Factory）

Intent

在创建一个对象时不向客户暴露内部细节，并提供一个创建对象的通用接口。

Class Diagram

简单工厂把实例化的操作单独放到一个类中，这个类就成为简单工厂类，让简单工厂类来决定应该用哪个具体子类来实例化。

这样做能把客户类和具体子类的实现解耦，客户类不再需要知道有哪些子类以及应当实例化哪个子类。客户类往往有多个，如果不使用简单工厂，那么所有的客户类都要知道所有子类的细节。而且一旦子类发生改变，例如增加子类，那么所有的客户类都要进行修改。

技术分享图片

Implementation

            
                1
                public
                class ConcreteProduct implements Product {
2 }

            
                1
                public
                class ConcreteProduct1 implements Product {
2 }

            
                public
                class ConcreteProduct2 implements Product {
}

以下的 Client 类包含了实例化的代码，这是一种错误的实现。如果在客户类中存在这种实例化代码，就需要考虑将代码放到简单工厂中。

                
                     1
                    //
                     错误实现
                     2
                    public
                    class
                     Client {

                     3
                     4
                    public
                    static
                    void
                     main(String[] args) {

                     5
                    int type = 1;
 6        Product product;
 7if (type == 1) {
 8             product = new ConcreteProduct1();
 9         } elseif (type == 2) {
10             product = new ConcreteProduct2();
11         } else {
12             product = new ConcreteProduct();
13        }
14// do what u want to do15    }
16 }

View Code

以下的 SimpleFactory 是简单工厂实现，它被所有需要进行实例化的客户类调用。

            
                 1
                public
                class
                 SimpleFactory {

                 2
                 3
                public Product createProduct(int type) {
 4if (type == 1) {  // 也可以用switch 当对象类型太多 5returnnew ConcreteProduct1();
 6         } elseif (type == 2) {
 7returnnew ConcreteProduct2();
 8        }
 9returnnew ConcreteProduct();
10    }
11 }

            
                1
                public
                class
                 Client {

                2
                public
                static
                void
                 main(String[] args) {

                3         SimpleFactory simpleFactory = new SimpleFactory();
4// 只需要传一个类型参数，实例化具体对象  5         Product product1 = simpleFactory.createProduct(1);
6         Product product2 = simpleFactory.createProduct(2);
7    }
8 }

3、工厂方法（Factory Method）

Intent

定义了一个创建对象的接口，但由子类决定要实例化哪个类。工厂方法把实例化操作推迟到子类。

Class Diagram

在简单工厂中，创建对象的是另一个类，而在工厂方法中，是由子类来创建对象。

下图中，Factory 有一个 doSomething() 方法，这个方法需要用到一个产品对象，这个产品对象由 factoryMethod() 方法创建。该方法是抽象的，需要由子类去实现。

技术分享图片

Implementation

            
                1
                public
                abstract
                class
                 Factory {

                2
                abstract
                public Product factoryMethod();  // 抽象方法，由子类去实现3publicvoid doSomething() {
4         Product product = factoryMethod();
5// do something with the product6    }
7 }

            
                1
                public
                class ConcreteFactory extends Factory {
2public Product factoryMethod() {
3returnnew ConcreteProduct();
4    }
5 }

            
                1
                public
                class ConcreteFactory1 extends Factory {
2public Product factoryMethod() {
3returnnew ConcreteProduct1();
4    }
5 }

            
                1
                public
                class ConcreteFactory2 extends Factory {
2public Product factoryMethod() {
3returnnew ConcreteProduct2();  // 由子类来创建对象4    }
5 }

4、抽象工厂（Abstract Factory）

Intent

提供一个接口，用于创建相关的对象家族。

Class Diagram

抽象工厂模式创建的是对象家族，也就是很多对象而不是一个对象，并且这些对象是相关的，也就是说必须一起创建出来。而工厂方法模式只是用于创建一个对象，这和抽象工厂模式有很大不同。

抽象工厂模式用到了工厂方法模式来创建单一对象，AbstractFactory 中的 createProductA() 和 createProductB() 方法都是让子类来实现，这两个方法单独来看就是在创建一个对象，这符合工厂方法模式的定义。

至于创建对象的家族这一概念是在 Client 体现，Client 要通过 AbstractFactory 同时调用两个方法来创建出两个对象，在这里这两个对象就有很大的相关性，Client 需要同时创建出这两个对象。

从高层次来看，抽象工厂使用了组合，即 Cilent 组合了 AbstractFactory，而工厂方法模式使用了继承。

技术分享图片

Implementation

            
                1
                public
                class
                 AbstractProductA {

                2 }

            
                1
                public
                class
                 AbstractProductB {

                2 }

            
                1
                public
                class ProductA1 extends AbstractProductA {
2 }

            
                1
                public
                class ProductA2 extends AbstractProductA {
2 }

            
                1
                public
                class ProductB1 extends AbstractProductB {
2 }

            
                1
                public
                class ProductB2 extends AbstractProductB {
2 }

            
                1
                public
                abstract
                class
                 AbstractFactory {

                2
                abstract
                 AbstractProductA createProductA();

                3
                abstract
                 AbstractProductB createProductB();

                4 }

            
                1
                public
                class ConcreteFactory1 extends AbstractFactory {
2    AbstractProductA createProductA() {
3returnnew ProductA1();
4    }
56    AbstractProductB createProductB() {
7returnnew ProductB1();
8    }
9 }

            
                1
                public
                class ConcreteFactory2 extends AbstractFactory {
2    AbstractProductA createProductA() {
3returnnew ProductA2();
4    }
56    AbstractProductB createProductB() {
7returnnew ProductB2();
8    }
9 }

            
                1
                public
                class
                 Client {

                2
                public
                static
                void
                 main(String[] args) {

                3         AbstractFactory abstractFactory = new ConcreteFactory1();
4         AbstractProductA productA = abstractFactory.createProductA();
5         AbstractProductB productB = abstractFactory.createProductB();
6// do something with productA and productB7    }
8 }

6、生成器（Builder）

Intent

封装一个对象的构造过程，并允许按步骤构造。

Class Diagram

技术分享图片

Implementation

以下是一个简易的 StringBuilder 实现，参考了 JDK 1.8 源码。

                
                     1
                    public
                    class
                     AbstractStringBuilder {

                     2
                    protected
                    char
                    [] value;

                     3
                     4
                    protected
                    int
                     count;

                     5
                     6
                    public AbstractStringBuilder(int capacity) {
 7         count = 0;
 8         value = newchar[capacity];
 9    }
1011public AbstractStringBuilder append(char c) {
12         ensureCapacityInternal(count + 1);
13         value[count++] = c;
14returnthis;
15    }
1617privatevoid ensureCapacityInternal(int minimumCapacity) {
18// overflow-conscious code19if (minimumCapacity - value.length > 0)
20            expandCapacity(minimumCapacity);
21    }
2223void expandCapacity(int minimumCapacity) {
24int newCapacity = value.length * 2 + 2;
25if (newCapacity - minimumCapacity < 0)
26             newCapacity = minimumCapacity;
27if (newCapacity < 0) {
28if (minimumCapacity < 0) // overflow29thrownew OutOfMemoryError();
30             newCapacity = Integer.MAX_VALUE;
31        }
32         value = Arrays.copyOf(value, newCapacity);
33    }
34 }

View Code

                
                     1
                    public
                    class StringBuilder extends AbstractStringBuilder {
 2public StringBuilder() {
 3super(16);
 4    }
 5 6    @Override
 7public String toString() {
 8// Create a copy, don‘t share the array 9returnnew String(value, 0, count);
10    }
11 }

View Code

                
                     1
                    public
                    class
                     Client {

                     2
                    public
                    static
                    void
                     main(String[] args) {

                     3         StringBuilder sb = new StringBuilder();
 4finalint count = 26;
 5for (int i = 0; i < count; i++) {
 6             sb.append((char) (‘a‘ + i));
 7        }
 8        System.out.println(sb.toString());
 9    }
10 }

View Code

            abcdefghijklmnopqrstuvwxyz

6、原型模式（Prototype）

Intent

使用原型实例指定要创建对象的类型，通过复制这个原型来创建新对象。

Class Diagram

技术分享图片

Implementation

            
                1
                public
                abstract
                class
                 Prototype {

                2
                abstract
                 Prototype myClone();

                3 }

                
                     1
                    public
                    class ConcretePrototype extends Prototype {
 2 3private String filed;
 4 5public ConcretePrototype(String filed) {
 6this.filed = filed;
 7    }
 8 9    @Override
10    Prototype myClone() {
11returnnew ConcretePrototype(filed);
12    }
1314    @Override
15public String toString() {
16return filed;
17    }
18 }

View Code

            
                1
                public
                class
                 Client {

                2
                public
                static
                void
                 main(String[] args) {

                3         Prototype prototype = new ConcretePrototype("abc");
4         Prototype clone = prototype.myClone();
5         System.out.println(clone.toString());  // abc6    }
7 }

晴川历历汉阳树

　　　　　　芳草萋萋鹦鹉洲

原文：https://www.cnblogs.com/taojietaoge/p/15047483.html

内容总结

以上是互联网集市为您收集整理的面向对象-设计模式-创建型全部内容，希望文章能够帮你解决面向对象-设计模式-创建型所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1283368.html

来源：【匿名】

首页 / 设计模式 / 面向对象-设计模式-创建型

面向对象-设计模式-创建型

内容导读

内容图文

一、概述

二、创建型

1、单例（Singleton）

Intent

Class Diagram

Implementation

Ⅰ 懒汉式-线程不安全

Ⅱ 饿汉式-线程安全

Ⅲ 懒汉式-线程安全

Ⅳ 双重校验锁-线程安全

Ⅴ 静态内部类实现

Ⅵ 枚举实现

单例小结

2、简单工厂（Simple Factory）

Intent

Class Diagram

Implementation

3、工厂方法（Factory Method）

Intent

Class Diagram

Implementation

4、抽象工厂（Abstract Factory）

Intent

Class Diagram

Implementation

6、生成器（Builder）

Intent

Class Diagram

Implementation

6、原型模式（Prototype）

Intent

Class Diagram

Implementation

内容总结

内容备注

内容手机端

设计模式 - 相关标签

面向对象 - 相关标签

创建 - 相关标签

设计模式 - 最新教程

设计模式 - 最热教程