1.概要
2.内容
当前：原型
需求：坦克大战
创建两种坦克
| 坦克类型 | 射程 | 速度 |
| b70 | 70米 | 时/70公里 |
| b50 | 50米 | 时/50公里 |
类图
代码说明
Function：机能描述
IPrototype<ITank> 一个需要实现自拷贝功能的接口
ITank：一个坦克的接口，需要实现设计的功能，因该模式需要，并未实现上面要啊的全部需求。
B70Tank/B50Tank：俩个具有自拷贝机能的类。
模式说明：
要点：一个具有通过拷贝自己而创建对象的模型，就是原型模式。（有这个就可以叫模式了，只有真的的模式价值需要结合需求去体悟，不用太纠结，如果真的有合适的需求你就立马明白了）
意图：用原型实例创建对象种类，并且通过拷贝这些原型创建对象。
代码
class Function{
public String mStr;
Function(String str){
mStr = str;
}
public void exe() {
System.out.println(mStr);
}
};
interface IPrototype<ITank>{
ITank clone();
}
interface ITank{
void shot();
}
abstract class Tank implements ITank,IPrototype<ITank>{
Function mFunction;
public Tank(Function m) {
mFunction = m;
}
public ITank clone() {
return create();
}
public void shot() {
mFunction.exe();
}
abstract public ITank create();
}
class B70Tank extends Tank{
public B70Tank() {
super(new Function("射击距离70米"));
}
private B70Tank(Function m) {
super(m);
}
public ITank create() {
return new B70Tank(mFunction);
}
}
class B50Tank extends Tank{
public B50Tank() {
super(new Function("射击距离50米"));
}
private B50Tank(Function m) {
super(m);
}
public ITank create() {
return new B50Tank(mFunction);
}
}
public class Client {
public static void main(String[] args) {
//“该模式的代码只能说是实现了原型模式，并未体现出原型解决问题的优势”
//“如果输能够解决问题，就不用添加新的类型了”
System.out.println("hello worldff !");
Tank b7 = new B70Tank();
b7.shot();
ITank b72 = b7.clone();
b72.shot();
}
}
运行结果
3.关联链接
4.关联知识
1.设计模式的原型模式深入分析
设计模式之原型模式（Prototype Pattern）深入分析
原型模式（Prototype Pattern）是一种创建型设计模式，其核心思想是通过复制现有对象（而非通过类直接实例化）来生成新对象。这一模式在需要动态配置对象类型、避免复杂初始化逻辑，或优化性能的场景中尤为适用。
1. 核心思想与目标
-
克隆代替新建：通过实现
clone()方法，允许对象自我复制，避免重复初始化开销。 -
解耦对象创建：客户端无需知道具体类，只需通过统一接口操作对象。
-
动态对象类型：运行时根据需求选择克隆的原型类型（如通过配置或工厂）。
2. 结构组成
原型模式通常包含以下角色：
- Prototype（抽象原型）
- 定义克隆方法的接口（如
clone()）。 - 代码示例（Java风格）：
public interface Prototype { Prototype clone(); }
- 定义克隆方法的接口（如
- ConcretePrototype（具体原型）
- 实现
clone()方法，返回自身的一个拷贝。 - 代码示例：
public class ConcretePrototype implements Prototype { private String state; @Override public Prototype clone() { return new ConcretePrototype(this.state); // 浅拷贝或深拷贝 } }
- 实现
- Client（客户端）
-
通过调用
clone()方法创建新对象，无需依赖具体类。 -
代码示例：
public class Client { public static void main(String[] args) { Prototype original = new ConcretePrototype(); Prototype copy = original.clone(); } }
-
3. 关键实现方式
- 浅拷贝（Shallow Copy）
- 仅复制对象的字段值，引用类型字段指向同一内存地址。
- 实现简单，但修改引用字段可能导致多个对象状态同步变化。
- 示例：直接赋值或通过
Object.clone()（Java中需实现Cloneable接口）。
- 深拷贝（Deep Copy）
-
递归复制所有引用字段指向的对象，生成完全独立的新对象。
-
实现复杂（需手动处理或通过序列化），但确保对象完全隔离。
-
示例：通过序列化/反序列化实现深拷贝：
public Prototype deepClone() { try { ByteArrayOutputStream bos = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(bos); oos.writeObject(this); ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); ObjectInputStream ois = new ObjectInputStream(bis); return (Prototype) ois.readObject(); } catch (Exception e) { /* 异常处理 */ } }
-
4. 典型应用场景
- 对象创建成本高
- 如需要复杂计算、数据库查询或资源加载（如游戏中的3D模型）。
- 示例：克隆敌人角色而非重新初始化。
- 动态配置对象类型
- 运行时根据配置或用户输入选择原型类型。
- 示例：文档编辑器中，通过原型生成不同类型的文档（报告、简历）。
- 避免子类化膨胀
- 当类层次复杂时，通过原型模式简化对象创建逻辑。
- 示例：不同形状的图形对象（圆形、矩形）通过克隆生成。
- 框架与库设计
-
允许用户自定义对象类型并动态扩展（如Spring Bean的原型作用域）。
-
5. 优缺点分析
| 优点 | 缺点 |
|---|---|
| 避免重复初始化，提升性能 | 深拷贝实现复杂，可能引入性能损耗 |
| 动态配置对象类型，提高灵活性 | 需所有类实现克隆方法，侵入性强 |
| 解耦对象创建与使用 | 浅拷贝可能导致意外副作用 |
| 简化继承结构，减少子类数量 |
6. 与其他模式的对比
-
工厂模式：通过工厂类创建对象，需提前知道具体类。
-
抽象工厂模式：创建一系列相关对象，适用于产品族。
-
建造者模式：分步构建复杂对象，强调构造过程。
-
原型模式：通过克隆现有对象创建新对象，强调对象复制。
7. 注意事项
- 深拷贝 vs 浅拷贝
- 根据需求选择拷贝方式，避免因引用共享导致状态混乱。
- 性能权衡
- 深拷贝可能带来额外开销，需评估是否必要。
- 克隆方法设计
- 确保
clone()方法返回正确类型的对象（如使用协变返回类型）。
- 确保
- Java中的Cloneable接口
-
实现
Cloneable标记接口，并重写Object.clone()方法。 -
需处理
CloneNotSupportedException异常。
-
8. 总结
原型模式通过克隆现有对象提供了一种灵活、高效的对象创建方式，尤其适用于对象初始化复杂或需要动态配置的场景。其核心挑战在于正确实现深拷贝，以避免状态共享问题。在实际开发中，需根据具体需求权衡拷贝方式，并确保所有可克隆类遵循统一的接口规范。
2.原型模式与其他创建型模式对比，有啥独特性
原型模式与其他创建型模式的对比及独特性
原型模式（Prototype Pattern）与其他创建型模式（如工厂方法、抽象工厂、建造者、单例等）的核心区别在于对象创建方式和适用场景。以下是详细对比：
1. 核心差异：对象创建方式
| 模式 | 创建方式 | 独特性 |
|---|---|---|
| 原型模式 | 克隆现有对象（通过clone()方法） | 避免重复初始化，直接复制已存在的对象状态，尤其适合复杂对象的创建。 |
| 工厂方法模式 | 通过工厂类调用构造函数实例化 | 依赖子类决定实例化逻辑，需预先定义所有产品类。 |
| 抽象工厂模式 | 通过抽象工厂创建产品族 | 强调产品族的统一创建，扩展需修改工厂接口。 |
| 建造者模式 | 分步骤构建复杂对象 | 关注对象的构造过程，而非对象本身的存在性。 |
| 单例模式 | 确保全局唯一实例 | 控制实例数量，与对象创建方式无关。 |
2. 原型模式的独特优势
- 动态配置与灵活性
- 运行时决定对象类型：通过修改原型实例（如替换为子类对象），客户端无需感知具体类即可克隆不同对象。
- 示例：游戏中的敌人类型根据关卡配置动态切换，无需修改工厂类。
- 高性能对象创建
- 避免重复初始化：若对象创建需要复杂计算（如数据库查询、资源加载），克隆比重新实例化更高效。
- 对比工厂模式：工厂模式每次调用
create()均需执行构造函数，而原型模式仅需一次初始化。
- 简化继承结构
- 减少子类化：通过统一接口
clone()替代工厂方法，避免为不同产品类创建大量工厂子类。 - 示例：文档编辑器中，通过原型生成“报告”“简历”等文档类型，无需为每个类型定义工厂。
- 减少子类化：通过统一接口
- 支持深拷贝与状态隔离
-
深拷贝能力：可完全复制对象及其引用字段，确保克隆对象与原型状态独立（需手动实现）。
-
对比其他模式：工厂模式生成的对象默认独立，但无法直接复制已有对象状态。
-
3. 局限性与其他模式的互补性
- 深拷贝复杂性：需手动处理引用字段的递归复制，可能引入性能损耗。
- 替代方案：结合工厂模式，对复杂对象使用原型克隆，简单对象使用工厂创建。
- 侵入性设计：所有可克隆类需实现
clone()方法，违反开闭原则（对扩展开放，对修改关闭）。- 优化方案：通过接口隔离，仅对需要克隆的类实现原型接口。
- 静态类型限制：克隆返回的对象类型需与原型一致（或协变返回类型），灵活性低于工厂模式的动态类型选择。
-
互补策略：结合抽象工厂模式，通过原型生成产品族中的默认对象。
-
4. 典型场景对比
| 场景 | 原型模式 | 工厂模式 | 建造者模式 |
|---|---|---|---|
| 对象创建成本高（如复杂初始化） | ✅ 优先使用（克隆现有对象） | ❌ 需重复调用构造函数 | ❌ 需重新构建对象 |
| 需要动态切换对象类型 | ✅ 通过修改原型实例实现 | ❌ 需扩展工厂类或修改配置 | ❌ 需重新构建对象 |
| 对象构造过程复杂（如分步骤配置） | ❌ 不适用（关注复制而非构建） | ❌ 不适用（需预先定义产品类） | ✅ 优先使用（分步骤构建） |
| 需要控制实例数量（如单例） | ❌ 不适用（需结合其他模式） | ❌ 不适用（需额外逻辑控制） | ❌ 不适用 |
5. 总结：原型的独特性
原型模式的核心价值在于通过对象复制而非类实例化来创建新对象，其独特性体现在：
- 性能优化：避免重复初始化开销。
- 动态灵活性：运行时切换对象类型，符合开闭原则。
- 简化设计：减少工厂子类，统一克隆接口。
- 状态隔离：通过深拷贝实现对象独立性。
适用场景：对象创建成本高、需动态配置类型、或需隔离对象状态的场景。若需复杂构造逻辑或控制实例数量，则需结合其他模式（如工厂+原型、建造者+原型）。
扫一扫
943
到【灌水乐园】发言
