设计模式总结(一)：创建型模型
文章目录
- 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 简单实现
- 简单工厂模式属于类创建型模式
- 可以根据参数的不同返回不同的实例
- 专门创建一个类来创建其他类的实例
- 被创建的实例通常具有共同的父类
简单工厂中的角色:
- 抽象产品类
- 产品子类
- 工厂类
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 简单工厂模式：
3.2 工厂模式：
注：从图上看，感觉更复杂了，但是，计算机中有一个“开闭原则”（扩展优于修改），这里举个例子，一个工厂，生产拖拉机，然后又生产口罩，那么为了更好的区别，最好是工厂下有个拖拉机工厂，有一个口罩工厂。
Jdk同样也用了这种思想：
4.抽象工厂方法
对类进行区分，如果都生产手机，你要生产口罩，则工厂方法就显得不合适了，因为接口功能不一样了，所以增加一个产品接口，表示一个大类，然后在工厂接口中，可以同时创建手机和口罩的对象，但是这样明显也违反了“开发封闭”原则。
5. 原型模型
6. 生成器模型
在产品结构比较复杂,构造过程比较繁琐,一次性构造比较难的时候,我们可以采取分而治之的原则,将产品组件化,每个组件由专门的厂商来生产,最后的产品指派给制定的车间进行最后装配.这种方式其实是现代制造业的一种典型的模式.比如汽车,飞机的制造等.这样做的好处是：
- 1.产品的部件由专门的生产厂商来生产,这样分工更加明确,更加精细,生产专业化,可以降低成本;
- 2.整个产品的生产更加简单,也可增加零件的复用.
- 3.转换生产比较容易,比如产品的材质发生变化,只需要找相应提供该材质的厂商即可.
