设计模式总结(一)：创建型模型-阿里云开发者社区

设计模式总结(一)：创建型模型

2023-10-11 73

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： 设计模式总结(一)：创建型模型

1.单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

import java.util.HashSet;
import java.util.Set;
public class SingleInstance {
    /**
     * 我用一个private的Static的变量来存放我们的SIngleInstance的实例
     */
    private static SingleInstance singleInstance = null;
    /**
     * 让构造方法编程私有的，这样我们可以防止在外面被其他类直接new出来，构造方   *  法同其它方法一样，也可以用private修饰，私有的构造方法无法在本类外部使   *  用，也就导致本类无法用new实例化，这样可以控制对象的生成。
     */
    private SingleInstance() {
    }
    /**
     * 我们提供一个静态的方法来创建我们的单例
     * @return
     */
    public static SingleInstance instance() throws InterruptedException {
        Thread.sleep(1000);
        if (singleInstance == null) {
            synchronized (SingleInstance.class) {
                if (singleInstance == null) {
                    System.out.println("我被new出来了");
                    singleInstance = new SingleInstance();
                }
            }
        }
        return singleInstance;
    }
    public static void main(String[] args) {
        Runnable runnable = () -> {
            try {
                instance();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };
        Set<Thread> threads = new HashSet<>();
        for (int i = 0; i < 10; i++) {
            threads.add(new Thread(runnable));
        }
        threads.forEach(t -> t.start());
    }
}

参考链接：

https://www.cnblogs.com/qq895139140/p/7774152.html

1.1 懒汉式-线程不安全

单例类的实例在第一次被引用时候才被初始化。
public class Singleton {  
    private static Singleton instance=null;  
    private Singleton() {  
    }  
    public static Singleton getInstance(){  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

1.2 懒汉式-线程安全

这种方式效率比较低，性能不是太好，不过也可以用，因为是对整个方法加上了线程同步，其实只要在new的时候考虑线程同步就行了，这种方法不推荐使用。

public class Singleton {  
    private static Singleton instance=null;  
    private Singleton() {  
    }  
    public synchronized static Singleton getInstance(){  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

1.3 饿汉式

单例类的实例在加载的时候就被初始化。

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton() {  
    }  
    public static Singleton getInstance(){  
        return instance;  
    }  
}

1.4 懒汉式-同步代码块

synchronized同步块括号中的锁定对象是采用的一个无关的Object类实例，而不是采用this，因为getInstance是一个静态方法，在它内部不能使用未静态的或者未实例的类对象

public class Singleton {  
    private static Singleton instance;  
    private final static Object syncLock = new Object();  
    private Singleton() {  
    }  
    public static Singleton getInstance(){  
        if (instance == null) {  
            synchronized (syncLock) {  
                if (instance == null) {  
                    instance = new Singleton();  
                }  
            }  
        }  
        return instance;  
    }  
}

1.5 懒汉式–同步类（最终）

public class Singleton {  
    private static Singleton instance;  
    private Singleton() {  
    }  
    public static Singleton getInstance(){  
        if (instance == null) {  
            synchronized (Singleton.class) {  
                if (instance == null) {  
                    instance = new Singleton();  
                }  
            }  
        }  
        return instance;  
    }  
}

2. 简单工厂

简单来说：简单工厂模式主要是工厂类根据参数的不同来创建不同类的实例，通常这些不同类拥有同一个父类。因为静态方法，也叫做静态工厂模式。

其实JDK中也广泛使用了这种模式，如DataFormat类，根据参数不同，会创建data、time、datatime类等等。

2.1 简单实现

简单工厂模式属于类创建型模式

可以根据参数的不同返回不同的实例
专门创建一个类来创建其他类的实例
被创建的实例通常具有共同的父类

简单工厂中的角色:

抽象产品类
产品子类
工厂类

abstract class Product{
  public void use() {
  }
}
class ProductA extends Product {
  public void use(){
    System.out.println(使用了产品A);
  }
}
class ProductB extends Product {
    public void use(){
    System.out.println(使用了产品B);
  }
}
class Factory{
  public static Product createProduct(String type){
    if (type.equals(A)){
      return new ProductA();
    }else if (type.equals(B)) {
      return new ProductB();
    }
    return new ProductA();
  }
}
*/