一个实例用全创建型模式-优化（冗余消除）
1.关联链接
上一篇：一个实例用全创建型模式-CSDN博客
目录：《一个实例讲完23种设计模式》
2.内容
当前：单件+抽象工厂+创建者+工厂方法+优化
需求：坦克大战
创建两种坦克
坦克类型 射程 速度
b70 70米 时/70公里
b50 50米 时/50公里
设计说明
1.抽象工厂承担了创建部件的任务
2.创建者承担了讲部件组装的任务
3.工厂方法类相当于创建者模式的导演，但是他是并未给用户提供选择创建者的接口。
而是通过自己的多态来实现加载不同的创建者。
类图（红色为优化的部分）
代码
//-----基本功能部分-------------------------
//功能类
class Function{
public String mOperation;
public void exe(int type) {
System.out.println(mOperation+type);
}
};
//功能类-射击
class ShotFun extends Function{
static ShotFun mFunction = new ShotFun();
static ShotFun get() {
return mFunction;
}
public ShotFun() {
mOperation = "射击：";
}
}
//功能类-跑
class RunFun extends Function{
static RunFun mFunction = new RunFun();
static RunFun get() {
return mFunction;
}
public RunFun() {
mOperation = "跑：";
}
}
//-- interface 接口设计部分 ----------------
//坦克
interface ITank{
void shot();
void run();
void setmShot(IOperation mShot);
void setmRun(IOperation mRun);
}
//功能
interface IOperation{
void exe();
}
//抽象工厂
interface IAbstractFactory{
IOperation createShot();
IOperation createRun();
}
//创建者模式
interface IBuilder{
void createShout(ITank t);
void createRun(ITank t);
}
//工厂方法
interface IFactory{
ITank createTank();
}
//发射
abstract class Shot implements IOperation{
int type;
public void exe() {
ShotFun.get().exe(type);
}
}
//跑
abstract class Run implements IOperation{
int type;
public void exe() {
RunFun.get().exe(type);
}
}
//-----实现类-----------------------------------------------
//跑-70
class Shot70 extends Shot{
public Shot70() {
type = 70;
}
}
//跑-50
class Run70 extends Run{
public Run70() {
type = 70;
}
}
//发射-70
class Shot50 extends Shot{
public Shot50() {
type = 50;
}
}
//发射-50
class Run50 extends Run{
public Run50() {
type = 50;
}
}
//坦克-基类
class Tank implements ITank{
IOperation mShot;
IOperation mRun;
public void setmShot(IOperation mShot) {
this.mShot = mShot;
}
public void setmRun(IOperation mRun) {
this.mRun = mRun;
}
public void shot() {
mShot.exe();
}
public void run() {
mRun.exe();
}
}
//--------抽象工厂----------------------------------------------
//抽象工程-实现-70
class AbstractFactory70 implements IAbstractFactory{
public IOperation createShot() {
return new Shot70();
}
public IOperation createRun() {
return new Run70();
}
}
//抽象工程-实现-50
class AbstractFactory50 implements IAbstractFactory{
public IOperation createShot() {
return new Shot50();
}
public IOperation createRun() {
return new Run50();
}
}
//-------创建者----------------
//创建者-基类
abstract class Builder implements IBuilder{
IAbstractFactory mIAbstractFactory;
public void createShout(ITank t) {
t.setmShot(mIAbstractFactory.createShot());
}
public void createRun(ITank t) {
t.setmRun(mIAbstractFactory.createRun());
}
}
//创建者-70
class Builder70 extends Builder{
public Builder70() {
mIAbstractFactory = new AbstractFactory70();
}
}
//创建者-50
class Builder50 extends Builder{
public Builder50() {
mIAbstractFactory = new AbstractFactory50();
}
}
//-----工厂方法-----------------------------------
//工厂方法-基类
abstract class Factory implements IFactory{
IBuilder mBuilder;
public ITank createTank() {
ITank t = new Tank();
mBuilder.createRun(t);
mBuilder.createShout(t);
return t;
}
}
//工厂方法-70
class Factory70 extends Factory{
public Factory70() {
mBuilder = new Builder70();
}
}
//工厂方法-50
class Factory50 extends Factory{
public Factory50() {
mBuilder = new Builder50();
}
}
//--------主函数-----------------
//主函数
public class Client {
public static void main(String[] args) {
System.out.println("hello worldff !");
Factory70 f7 = new Factory70();
ITank t = f7.createTank();
t.shot();
t.run();
}
}
运行结果
2.关联知识
1.创建型模式
设计模式中的创建型模式（Creational Pattern）是一类用于处理对象创建过程的设计模式。它们旨在以灵活和高效的方式创建对象，将对象的创建过程与使用过程分离，从而降低系统的耦合度，提高代码的可维护性和可扩展性。以下是创建型模式的详细介绍：
一、创建型模式概述
创建型模式主要关注如何创建对象，它们通过封装对象的创建过程，使得客户端代码无需关心对象的创建细节，从而降低了系统的复杂度。根据《设计模式：可复用面向对象软件的基础》一书，创建型模式主要包括以下五种：
- 单例模式（Singleton Pattern）
- 工厂方法模式（Factory Method Pattern）
- 抽象工厂模式（Abstract Factory Pattern）
- 建造者模式（Builder Pattern）
- 原型模式（Prototype Pattern）
二、创建型模式详解
1. 单例模式（Singleton Pattern）
定义：
确保一个类只有一个实例，并提供一个全局访问点。
特点：
- 节省内存资源，避免创建多个相同的实例。
- 便于全局访问和控制。
应用场景：
- 配置管理器、资源管理器等需要全局唯一实例的场景。
实现方式：
- 饿汉式（静态初始化）：在类加载时就创建实例。
- 懒汉式（延迟初始化）：在第一次使用时创建实例。
- 双重检查锁定（Double-Checked Locking）：线程安全的懒汉式实现。
- 静态内部类：利用类加载机制实现线程安全的延迟初始化。
- 枚举（Enum）：利用枚举的特性和语法糖实现单例。
示例代码（以饿汉式为例）：
public class Singleton {
// 类加载时就创建实例
private static final Singleton instance = new Singleton();
// 私有构造函数，防止外部实例化
private Singleton() {}
// 提供全局访问点
public static Singleton getInstance() {
return instance;
}
}2. 工厂方法模式（Factory Method Pattern）
定义：
定义一个用于创建对象的接口，但由子类决定实例化哪一个类。
特点：
- 延迟到子类决定实例化哪一个类。
- 遵循开闭原则，易于扩展。
应用场景：
- 当具体类的实例化需要延迟到子类时，如日志记录器、连接池等。
实现方式：
- 定义一个抽象工厂类，包含创建产品对象的抽象方法。
- 子类实现抽象工厂类，提供具体的产品对象。
示例代码：
// 抽象工厂类
public abstract class Factory {
public abstract Product createProduct();
}
// 具体工厂类
public class ConcreteFactory extends Factory {
@Override
public Product createProduct() {
return new ConcreteProduct();
}
}
// 抽象产品类
public abstract class Product {
public abstract void use();
}
// 具体产品类
public class ConcreteProduct extends Product {
@Override
public void use() {
System.out.println("Using ConcreteProduct");
}
}3. 抽象工厂模式（Abstract Factory Pattern）
定义：
提供一个接口，用于创建一族相关或依赖对象，而无需指定具体类。
特点：
- 创建一族相关或依赖的对象。
- 遵循开闭原则，易于扩展。
应用场景：
- 系统需要一组相关或依赖的产品对象时，如UI组件的跨平台开发。
实现方式：
- 定义一个抽象工厂类，包含创建一组相关或依赖对象的抽象方法。
- 具体工厂类实现抽象工厂类，提供具体的产品对象。
示例代码：
// 抽象工厂类
public abstract class AbstractFactory {
public abstract Button createButton();
public abstract TextArea createTextArea();
}
// 具体工厂类1（Windows风格）
public class WindowsFactory extends AbstractFactory {
@Override
public Button createButton() {
return new WindowsButton();
}
@Override
public TextArea createTextArea() {
return new WindowsTextArea();
}
}
// 具体工厂类2（Mac风格）
public class MacFactory extends AbstractFactory {
@Override
public Button createButton() {
return new MacButton();
}
@Override
public TextArea createTextArea() {
return new MacTextArea();
}
}
// 抽象产品类
public abstract class Button {
public abstract void render();
}
// 具体产品类（Windows风格按钮）
public class WindowsButton extends Button {
@Override
public void render() {
System.out.println("Rendering Windows Button");
}
}
// 具体产品类（Mac风格按钮）
public class MacButton extends Button {
@Override
public void render() {
System.out.println("Rendering Mac Button");
}
}
// 抽象产品类
public abstract class TextArea {
public abstract void render();
}
// 具体产品类（Windows风格文本区域）
public class WindowsTextArea extends TextArea {
@Override
public void render() {
System.out.println("Rendering Windows TextArea");
}
}
// 具体产品类（Mac风格文本区域）
public class MacTextArea extends TextArea {
@Override
public void render() {
System.out.println("Rendering Mac TextArea");
}
}4. 建造者模式（Builder Pattern）
定义：
将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。
特点：
- 逐步构建复杂对象。
- 便于控制构建过程，易于扩展。
应用场景：
- 需要创建复杂对象，且对象的创建过程独立于其组成部分时，如创建复杂的文档对象。
实现方式：
- 定义一个抽象建造者类，包含创建复杂对象各个部分的抽象方法。
- 具体建造者类实现抽象建造者类，提供具体的产品对象。
- 定义一个指挥者类，负责调用建造者类的方法构建复杂对象。
示例代码：
// 抽象建造者类
public abstract class Builder {
public abstract void buildPartA();
public abstract void buildPartB();
public abstract Product getResult();
}
// 具体建造者类
public class ConcreteBuilder extends Builder {
private Product product = new Product();
@Override
public void buildPartA() {
product.add("PartA");
}
@Override
public void buildPartB() {
product.add("PartB");
}
@Override
public Product getResult() {
return product;
}
}
// 产品类
public class Product {
private List parts = new ArrayList<>();
public void add(String part) {
parts.add(part);
}
public void show() {
for (String part : parts) {
System.out.println(part);
}
}
}
// 指挥者类
public class Director {
public void construct(Builder builder) {
builder.buildPartA();
builder.buildPartB();
}
} 5. 原型模式（Prototype Pattern）
定义：
通过复制现有实例来创建新对象。
特点：
- 避免了重复初始化过程。
- 便于创建大量相似对象。
应用场景：
- 需要大量相似对象的场景，如编辑器中的图形工具。
实现方式：
- 实现一个克隆方法（
clone()），用于复制现有对象。
示例代码：
public class Prototype implements Cloneable {
private String id;
public Prototype(String id) {
this.id = id;
}
public String getId() {
return id;
}
// 实现克隆方法
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
public static void main(String[] args) {
try {
Prototype original = new Prototype("1");
Prototype copy = (Prototype) original.clone();
System.out.println("Original ID: " + original.getId());
System.out.println("Copied ID: " + copy.getId());
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}三、创建型模式总结
创建型模式通过将对象的创建过程与使用过程分离，提高了代码的灵活性和可维护性。它们适用于不同的场景，可以根据具体需求选择合适的设计模式。例如，单例模式适用于需要全局唯一实例的场景；工厂方法模式和抽象工厂模式适用于
2.创建型模式的特点
创建型模式的特点和适用场景对比说明
创建型模式是一组处理对象创建的设计模式，它们旨在以灵活和高效的方式创建对象，将对象的创建与使用分离，提高系统的灵活性和可扩展性。以下是五种主要的创建型模式的特点和适用场景对比说明：
| 模式名称 | 特点 | 适用场景 |
|---|---|---|
| 单例模式（Singleton） | 1. 确保一个类只有一个实例，并提供一个全局访问点。 | 1. 需要确保一个类只有一个实例的场景，如配置管理器、资源管理器等。 |
| 2. 节省系统资源，避免重复创建对象。 | 2. 需要全局访问点的场景，如全局状态管理器、全局配置对象等。 | |
| 3. 实现简单，但需注意多线程环境下的安全性。 | 3. 对象创建开销较大的场景，避免重复初始化。 | |
| 工厂方法模式（Factory Method） | 1. 定义一个创建对象的接口，由子类决定实例化哪一个类。 | 1. 需要根据条件动态选择不同产品类的场景，如日志记录器、连接池等。 |
| 2. 延迟对象的创建到子类，符合开闭原则。 | 2. 需要创建不同类型的对象，而客户端不需要知道具体实现类的场景。 | |
| 3. 提高了系统的灵活性和可扩展性。 | 3. 需要在不修改客户端代码的情况下，通过扩展子类支持新产品的场景。 | |
| 抽象工厂模式（Abstract Factory） | 1. 提供一个接口，用于创建一族相关或依赖对象，而无需指定具体类。 | 1. 需要创建一组相互关联或相互依赖的对象，如UI组件的跨平台开发。 |
| 2. 隔离了具体类的生成，使得客户并不需要知道什么被创建。 | 2. 需要支持多种产品族，并且希望这些产品族的创建能够被封装起来的场景。 | |
| 3. 增加或替换产品族比较方便，支持开闭原则。 | 3. 系统需要独立于具体产品的创建、组合和表示时。 | |
| 建造者模式（Builder） | 1. 将一个复杂对象的构建过程与其表示分离，逐步构造对象。 | 1. 需要创建复杂对象，且对象的创建过程独立于其组成部分时，如创建复杂的文档对象。 |
| 2. 可以创建不同表示的对象，实现产品的灵活创建。 | 2. 需要构建过程允许对象有不同的表示时。 | |
| 3. 客户端不必知道产品内部组成的细节。 | 3. 构建过程需要精细控制，允许分步构建和组装对象。 | |
| 原型模式（Prototype） | 1. 通过复制现有实例来创建新对象，避免重复初始化。 | 1. 需要大量相似对象的场景，如编辑器中的图形工具。 |
| 2. 提高了对象的创建效率，简化了创建过程。 | 2. 创建对象的成本较高，或对象初始化过程较复杂的场景。 | |
| 3. 支持对象的深拷贝和浅拷贝。 | 3. 需要通过复制现有对象来创建新对象时。 |
详细对比说明：
-
单例模式：
- 特点：单例模式确保一个类只有一个实例，并提供一个全局访问点。它常用于需要全局控制资源的场景，如配置管理、日志记录、数据库连接等。
- 适用场景：
- 当需要确保在整个应用程序中某个类只能存在一个实例时。
- 当对象需要被共享的场合，共享对象可以节省内存，并加快对象访问速度。
- 当某类需要频繁实例化，而创建的对象又频繁被销毁时。
-
工厂方法模式：
- 特点：工厂方法模式定义一个创建对象的接口，由子类决定实例化哪一个类。它将对象的创建过程延迟到子类，符合开闭原则，提高了系统的灵活性和可扩展性。
- 适用场景：
- 当需要创建不同类型的对象，而客户端不需要知道具体实现类的场景。
- 当需要根据条件动态选择不同产品类的场景。
- 当需要在不修改客户端代码的情况下，通过扩展子类支持新产品的场景。
-
抽象工厂模式：
- 特点：抽象工厂模式提供一个接口，用于创建一族相关或依赖对象，而无需指定具体类。它隔离了具体类的生成，使得客户并不需要知道什么被创建，支持开闭原则。
- 适用场景：
- 当需要创建一组相互关联或相互依赖的对象时。
- 当需要支持多种产品族，并且希望这些产品族的创建能够被封装起来的场景。
- 当系统需要独立于具体产品的创建、组合和表示时。
-
建造者模式：
- 特点：建造者模式将一个复杂对象的构建过程与其表示分离，逐步构造对象。它允许通过指定复杂对象的类型和内容逐步构造一个复杂对象，客户端不必知道产品内部组成的细节。
- 适用场景：
- 当需要创建复杂对象，且对象的创建过程独立于其组成部分时。
- 当构建过程需要精细控制，允许分步构建和组装对象时。
- 当需要创建不同表示的对象，实现产品的灵活创建时。
-
原型模式：
- 特点：原型模式通过复制现有实例来创建新对象，避免重复初始化。它提高了对象的创建效率，简化了创建过程，支持对象的深拷贝和浅拷贝。
- 适用场景：
- 当需要大量相似对象的场景。
- 当创建对象的成本较高，或对象初始化过程较复杂的场景。
- 当需要通过复制现有对象来创建新对象时。
总结：
创建型模式通过封装对象的创建方式，使得系统不依赖于具体的类，实现了对象创建的抽象化和多样化。在选择使用哪种创建型模式时，需要根据具体的需求和上下文，考虑对象的创建过程、系统的灵活性和可扩展性等因素。