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

文章目录

  • 1.单例模式
    • 1.1 懒汉式-线程不安全
    • 1.2 懒汉式-线程安全
    • 1.3 饿汉式
    • 1.4 懒汉式-同步代码块
    • 1.5 懒汉式--同步类(最终)
  • 2. 简单工厂
    • 2.1 简单实现
    • 2.2 优缺点
    • 2.3适用环境
    • 2.4 扩充
  • 3. 工厂模式
    • 3.1 简单工厂模式:
    • 3.2 工厂模式:
  • 4.抽象工厂方法
  • 5. 原型模型
  • 6. 生成器模型

创建型模式

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 简单实现

  • 简单工厂模式属于类创建型模式
    • 可以根据参数的不同返回不同的实例
    • 专门创建一个类来创建其他类的实例
    • 被创建的实例通常具有共同的父类

简单工厂中的角色:

  1. 抽象产品类
  2. 产品子类
  3. 工厂类
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();
	}
}
*/

2.2 优缺点

  • 优点:创建由专门的工厂类负责,客户端成员不用关心其是怎么创建的,直接使用就行。

    • (1)工厂类包含必要的逻辑判断,可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责
    • (2)客户端无需知道所创建具体产品的类名,只需知道参数即可
  • 缺点:工厂类不够灵活,如何新增一个产品,则需要修改逻辑,如果产品越多,则越复杂。

    • (1)工厂类集中了所有产品的创建逻辑,职责过重,一旦异常,整个系统将受影响
    • (2)使用简单工厂模式会增加系统中类的个数(引入新的工厂类),增加系统的复杂度和理解难度
    • (3)系统扩展困难,一旦增加新产品不得不修改工厂逻辑,在产品类型较多时,可能造成逻辑过于复杂,违反开发封闭原则。

2.3适用环境

  • (1)工厂类负责创建对的对象比较少,因为不会造成工厂方法中的业务逻辑过于复杂
  • (2)客户端只知道传入工厂类的参数,对如何创建对象不关心

2.4 扩充

工厂类:
根据参数,创建A/B产品,普通
直接多个方法,创建A/B产品,多方法
静态方法,创建A/B产品,静态方法

3. 工厂模式

3.1 简单工厂模式:

设计模式总结(一):创建型模型_第1张图片

3.2 工厂模式:

设计模式总结(一):创建型模型_第2张图片
注:从图上看,感觉更复杂了,但是,计算机中有一个“开闭原则”(扩展优于修改),这里举个例子,一个工厂,生产拖拉机,然后又生产口罩,那么为了更好的区别,最好是工厂下有个拖拉机工厂,有一个口罩工厂。

在这里插入图片描述
设计模式总结(一):创建型模型_第3张图片
Jdk同样也用了这种思想:
设计模式总结(一):创建型模型_第4张图片

4.抽象工厂方法

对类进行区分,如果都生产手机,你要生产口罩,则工厂方法就显得不合适了,因为接口功能不一样了,所以增加一个产品接口,表示一个大类,然后在工厂接口中,可以同时创建手机和口罩的对象,但是这样明显也违反了“开发封闭”原则。

设计模式总结(一):创建型模型_第5张图片

5. 原型模型

设计模式总结(一):创建型模型_第6张图片
设计模式总结(一):创建型模型_第7张图片
设计模式总结(一):创建型模型_第8张图片

设计模式总结(一):创建型模型_第9张图片

6. 生成器模型

在产品结构比较复杂,构造过程比较繁琐,一次性构造比较难的时候,我们可以采取分而治之的原则,将产品组件化,每个组件由专门的厂商来生产,最后的产品指派给制定的车间进行最后装配.这种方式其实是现代制造业的一种典型的模式.比如汽车,飞机的制造等.这样做的好处是:

  • 1.产品的部件由专门的生产厂商来生产,这样分工更加明确,更加精细,生产专业化,可以降低成本;
  • 2.整个产品的生产更加简单,也可增加零件的复用.
  • 3.转换生产比较容易,比如产品的材质发生变化,只需要找相应提供该材质的厂商即可.

设计模式总结(一):创建型模型_第10张图片
设计模式总结(一):创建型模型_第11张图片

你可能感兴趣的:(设计模式,单例模式)