设计模式专题之 —— 创建类模式

最新推荐文章于 2023-08-27 16:31:11 发布

原创最新推荐文章于 2023-08-27 16:31:11 发布 · 280 阅读

0 ·

CC 4.0 BY-SA版权

设计模式专栏收录该内容

4 篇文章

订阅专栏

本文详细解析了创建型设计模式中的工厂方法模式、建造者模式、抽象工厂模式、单例模式和原型模式，提供了每种模式的定义、通用代码示例及应用场景，帮助读者深入理解并灵活运用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

创建类模式包括工厂方法模式、建造者模式、抽象工厂模式、单例模式和原型模式，他们都能够提供对象的创建和管理职责。单例模式是要保持在内存中只有一个对象，原型模式是要求通过复制的方式产生一个新的对象。

一、单例模式（Singleton Pattern）

1.1 定义

Ensure a class has only one instance, and provide a global point of access to it.
确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

1.2 通用代码

饿汉式单例

线程安全

package designpattern.Singleton;

public class Singleton {
	// 饿汉式单例
	private static final Singleton singleton = new Singleton();

	private Singleton() {

	}

	public static Singleton getSingleton() {
		return singleton;
	}
	
	public static void doSomething() {
		
	}
}

懒汉式单例

package designpattern.Singleton;

public class Singleton {
	// 线程安全的懒汉式单例
	private static Singleton instance = null;

	private Singleton() {

	}

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

	public static void doSomething() {

	}
}

双检锁、双重校验锁

package designpattern.Singleton;

public class Singleton {
	// 双检锁、双重校验锁
	private static Singleton instance = null;

	private Singleton() {

	}

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

	public static void doSomething() {

	}
}

静态（类级）内部类

能达到和双检锁、双重校验锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式，这种方式只适用于静态域的情况，双检锁可以再实例域需要延迟初始化时使用。

package designpattern.Singleton;

public class Singleton {
	// 双检锁、双重校验锁

	private Singleton() {

	}

	private static class SingletonHolder {
		private static Singleton instance = new Singleton();
	}

	public static Singleton getInstance() {
		return SingletonHolder.instance;
	}
	
	public static void doSomething() {

	}
}

二、工厂方法模式（Factory Pattern）

2.1 定义

Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.
定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

2.2 通用代码

抽象产品类

package designpattern.Factory;

public abstract class Product {
	// 产品类的公共方法
	public void method1() {
		//业务逻辑处理
	}
	// 抽象方法
	public abstract void method2();
}

具体产品类

package designpattern.Factory;

public class ConcreteProduct1 extends Product {
	@Override
	public void method2() {
		//业务逻辑处理
	}
}

package designpattern.Factory;

public class ConcreteProduct2 extends Product {
	@Override
	public void method2() {
		//业务逻辑处理
	}
}

抽象工厂类

package designpattern.Factory;

public abstract class Creator {
	/*
	 * 创建一个产品对象，其输入参数类型可以自行设置
	 * 通常为String、Enum、Class等，当然也可以为空
	 */
	public abstract <T extends Product> T createProduct(Class<T> c);
}

具体工厂类

package designpattern.Factory;

public class ConcreteCreator extends Creator {
	@Override
	public <T extends Product> T createProduct(Class<T> c) {
		Product product = null;
		try{
			product = (Product)Class.forName(c.getName()).newInstance();
		} catch (Exception e) {
			//异常处理
		}
		return (T)product;
	}
}

场景类

package designpattern.Factory;

public class Client {
	public static void main(String[] args) {
		Creator creator = new ConcreteCreator();
		Product product = creator.createProduct(ConcreteProduct1.class);
		/*
		 * 继续业务处理
		 */
	}
}

三、抽象工厂模式（Abstract Factory Pattern）

3.1 定义

Provide an interface for creating families of related or dependent objects without specifying their concrete classes
为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。

3.2 通用代码

抽象产品类A

package designpattern.abstractfactory;

public abstract class AbstractProductA {
	//每个产品共有的方法
	public void sharedMethod(){

	}
	//每个产品相同方法，不通实现
	public abstract void doSomething();
}

产品A1的实现类

package designpattern.abstractfactory;

public class ProductA1 extends AbstractProductA {
	@Override
	public void doSomething() {
		System.out.println("产品A1的实现方法");
	}
}

产品A2的实现类

package designpattern.abstractfactory;

public class ProductA2 extends AbstractProductA {
	@Override
	public void doSomething() {
		System.out.println("产品A2的实现方法");
	}
}

抽象产品类B

package designpattern.abstractfactory;

public abstract class AbstractProductB {
	//每个产品共有的方法
	public void sharedMethod(){

	}
	//每个产品相同方法，不通实现
	public abstract void doSomething();
}

产品B1的实现类

package designpattern.abstractfactory;

public class ProductB1 extends AbstractProductB {
	@Override
	public void doSomething() {
		System.out.println("产品B1的实现方法");
	}
}

产品B2的实现类

package designpattern.abstractfactory;

public class ProductB2 extends AbstractProductB {
	@Override
	public void doSomething() {
		System.out.println("产品B2的实现方法");
	}
}

抽象工厂类

package designpattern.abstractfactory;

public abstract class AbstractCreator {
	// 创建A产品家族
	public abstract AbstractProductA createProductA();
	// 创建B产品家族
	public abstract AbstractProductB createProductB();
}

产品等级1的实现类

package designpattern.abstractfactory;

public class Creator1 extends AbstractCreator {
	//只生成产品等级为1的A产品
	@Override
	public AbstractProductA createProductA() {
		return new ProductA1();
	}

	//只生成产品等级为1的B产品
	@Override
	public AbstractProductB createProductB() {
		return new ProductB1();
	}
}

产品等级2的实现类

package designpattern.abstractfactory;

public class Creator2 extends AbstractCreator {
	//只生成产品等级为2的A产品
	@Override
	public AbstractProductA createProductA() {
		return new ProductA2();
	}

	//只生成产品等级为2的B产品
	@Override
	public AbstractProductB createProductB() {
		return new ProductB2();
	}
}

场景类

package designpattern.abstractfactory;

public class Client {
	public static void main(String[] args) {
		//定义出两个工厂
		AbstractCreator creator1 = new Creator1();
		AbstractCreator creator2 = new Creator2();
		//产生A1对象
		AbstractProductA a1 = creator1.createProductA();
		//产生A2对象
		AbstractProductA a2 = creator2.createProductA();
		//产生B1对象
		AbstractProductB b1 = creator1.createProductB();
		//产生B2对象
		AbstractProductB b2 = creator2.createProductB();
		/*
		 * 然后在这里就可以为所欲为了
		 */

	}
}

四、建造者模式（Builder Pattern）

4.1 定义

Separate the construction of a complex object from its representation so that the same construction process can create different representations.
将一个复杂对象的构建与他的表示分离，使得同样的构建过程可以创建不同的表示。

4.2 通用代码

产品类

package designpattern.builder;

public class Product {
	public void doSomething() {
		//独立业务处理
	}
}

抽象建造者

package designpattern.builder;

public abstract class Builder {
	//设置产品的不同部分，以获得不同的产品
	public abstract void setPart();
	//建造产品
	public abstract Product buildProduct();
}

具体建造者

package designpattern.builder;

public class ConcreteProduct extends Builder {
	private Product product = new Product();
	//设置产品零件
	@Override
	public void setPart() {
		/*
		 * 产品类内的逻辑处理
		 */
	}

	//组建一个产品
	@Override
	public Product buildProduct() {
		return product;
	}
}

导演类

package designpattern.builder;

public class Director {
	private Builder builder = new ConcreteProduct();
	//构建不同的产品
	public Product getAProduct() {
		builder.setPart();
		/*
		 * 设置不同的零件，产生不同的产品
		 */
		return builder.buildProduct();
	}
}

五、原型模式（Prototype Pattern）

5.1 定义

Specify the kinds of objects to create using a prototypical instance, and create new objects by copying this prototype.
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

5.2通用代码

package designpattern.prototype;

public class PrototypeClass implements Cloneable {
	//覆写父类Object方法

	@Override
	public PrototypeClass clone() {
		PrototypeClass prototypeClass = null;
		try {
			prototypeClass = (PrototypeClass)super.clone();
		} catch (CloneNotSupportedException e) {
			//异常处理
		}
		return prototypeClass;
	}
}