原型模式详解

最新推荐文章于 2024-10-24 09:45:00 发布
原创 最新推荐文章于 2024-10-24 09:45:00 发布 · 212 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#原型 #设计模式

原型模式（Prototype pattern）
定义

通过已有对象，拷贝出一个新对象，具有一模一样的属性，存放在不同的内存地址上

模式总结过程

游戏DOTA，简化规则如下：

  1. 分上中下三路，每路、每30秒就出现一波小兵，各路小兵沿种路向对方进发。
  2. 每波小兵由一个远程小兵和三个进战小兵组成。
  3. 当攻破一路兵营后，小兵会升级成中后，当攻破三路兵营后，会升级成大兵。
  4. 小中大兵的区别在于血量、攻击力和体积不同。
  5. 每个小兵有自己的状态，所以得有一个小兵一个对象。
  6. 游戏分近卫、天灾两大阵营。
  1. 初步的设计，可能是这样子的
// 士兵类
public class Soldier {

    // 等级，1 2 3级
    private int level;

    // 血量
    private double blood;

    // 类型，进战、远程
    private String classify;

    // 攻击力
    private int attack;

    // 体积，大、中、小
    private String display;

    // 阵营，近卫、天灾
    private String camp;

    // 路线，上路、中路、下路
    private String route;
    
    // 其它共有属性没有列出，如速度、仇恨等

    // get set constructor toString
}
// 客户端，以近卫中路作为演示
public class Client {

    // 以近卫中路作为演示
    public static void main(String[] args) {
        System.out.println("游戏开始，时间：00:00");

        System.out.println("近卫中路创建一波小兵，3个近战、1个远程");

        Soldier soldier0001 = new Soldier(1, 600, "进战", 30, "小兵", "近卫", "中路");
        Soldier soldier0002 = new Soldier(1, 600, "进战", 30, "小兵", "近卫", "中路");
        Soldier soldier0003 = new Soldier(1, 600, "进战", 30, "小兵", "近卫", "中路");
        Soldier soldier0004 = new Soldier(1, 300, "远程", 28, "小兵", "近卫", "中路");
        print(soldier0001, soldier0002, soldier0003, soldier0004);

        System.out.println("游戏时间：00:30");

        System.out.println("近卫中路创建一波小兵，3个近战、1个远程");

        Soldier soldier0005 = new Soldier(1, 600, "进战", 30, "小兵", "近卫", "中路");
        Soldier soldier0006 = new Soldier(1, 600, "进战", 30, "小兵", "近卫", "中路");
        Soldier soldier0007 = new Soldier(1, 600, "进战", 30, "小兵", "近卫", "中路");
        Soldier soldier0008 = new Soldier(1, 300, "远程", 28, "小兵", "近卫", "中路");
        print(soldier0005, soldier0006, soldier0007, soldier0008);

        System.out.println("每30秒创建一波小兵，每波小兵会进行攻击、也会被攻击，血量会减少、增多（加血）");

        System.out.println("...");

        System.out.println("当天灾中路兵营被攻破后，近卫中路的小兵升级为中兵（新创建的）");

        System.out.println("近卫中路创建一波中兵，3个近战、1个远程");

        Soldier soldier0009 = new Soldier(2, 1200, "进战", 60, "中兵", "近卫", "中路");
        Soldier soldier0010 = new Soldier(2, 1200, "进战", 60, "中兵", "近卫", "中路");
        Soldier soldier0011 = new Soldier(2, 1200, "进战", 60, "中兵", "近卫", "中路");
        Soldier soldier0012 = new Soldier(2, 600, "远程", 56, "中兵", "近卫", "中路");
        print(soldier0009, soldier0010, soldier0011, soldier0012);

        System.out.println("...");

        System.out.println("当天灾三路兵营被攻破后，近卫中路的中兵升级为大兵（新创建的）");

        System.out.println("近卫中路创建一波大兵，3个近战、1个远程");

        Soldier soldier0013 = new Soldier(3, 2400, "进战", 60, "大兵", "近卫", "中路");
        Soldier soldier0014 = new Soldier(3, 2400, "进战", 60, "大兵", "近卫", "中路");
        Soldier soldier0015 = new Soldier(3, 2400, "进战", 60, "大兵", "近卫", "中路");
        Soldier soldier0016 = new Soldier(3, 1200, "远程", 56, "大兵", "近卫", "中路");
        print(soldier0013, soldier0014, soldier0015, soldier0016);
    }

    // 方便打印
    private static void print(Soldier... soldiers) {
        for (Soldier s : soldiers) {
            System.out.println(s);
        }
        System.out.println();
    }
}
/*
游戏开始，时间：00:00
近卫中路创建一波小兵，3个近战、1个远程
Soldier{level=1, blood=600.0, classify='进战', attack=30, display='小兵', camp='近卫', route='中路'}
Soldier{level=1, blood=600.0, classify='进战', attack=30, display='小兵', camp='近卫', route='中路'}
Soldier{level=1, blood=600.0, classify='进战', attack=30, display='小兵', camp='近卫', route='中路'}
Soldier{level=1, blood=300.0, classify='远程', attack=28, display='小兵', camp='近卫', route='中路'}

游戏时间：00:30
近卫中路创建一波小兵，3个近战、1个远程
Soldier{level=1, blood=600.0, classify='进战', attack=30, display='小兵', camp='近卫', route='中路'}
Soldier{level=1, blood=600.0, classify='进战', attack=30, display='小兵', camp='近卫', route='中路'}
Soldier{level=1, blood=600.0, classify='进战', attack=30, display='小兵', camp='近卫', route='中路'}
Soldier{level=1, blood=300.0, classify='远程', attack=28, display='小兵', camp='近卫', route='中路'}

每30秒创建一波小兵，每波小兵会进行攻击、也会被攻击，血量会减少、增多（加血）
...
当天灾中路兵营被攻破后，近卫中路的小兵升级为中兵（新创建的）
近卫中路创建一波中兵，3个近战、1个远程
Soldier{level=2, blood=1200.0, classify='进战', attack=60, display='中兵', camp='近卫', route='中路'}
Soldier{level=2, blood=1200.0, classify='进战', attack=60, display='中兵', camp='近卫', route='中路'}
Soldier{level=2, blood=1200.0, classify='进战', attack=60, display='中兵', camp='近卫', route='中路'}
Soldier{level=2, blood=600.0, classify='远程', attack=56, display='中兵', camp='近卫', route='中路'}

...
当天灾三路兵营被攻破后，近卫中路的中兵升级为大兵（新创建的）
近卫中路创建一波大兵，3个近战、1个远程
Soldier{level=3, blood=2400.0, classify='进战', attack=60, display='大兵', camp='近卫', route='中路'}
Soldier{level=3, blood=2400.0, classify='进战', attack=60, display='大兵', camp='近卫', route='中路'}
Soldier{level=3, blood=2400.0, classify='进战', attack=60, display='大兵', camp='近卫', route='中路'}
Soldier{level=3, blood=1200.0, classify='远程', attack=56, display='大兵', camp='近卫', route='中路'}
*/

可以看到，对象的创建很频繁、复杂，而且容易出错，这时，原型模式就有用武之地了

  1. 在Soldier类中，提供对象复制的功能，再加一个管理类，管理常用的对象（如大中小兵）
// 士兵类
public class Soldier implements Cloneable {

    // 等级
    private int level;

    // 血量
    private double blood;

    // 类型，进战、远程
    private String classify;

    // 攻击力
    private int attack;

    // 体积
    private String display;

    // 阵营
    private String camp;

    // 路线
    private String route;

    // 其它共有属性没有列出，如速度、仇恨等

    // 提供对象复制的方法
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    
    // get set constructor toString
}
// 士兵管理类
public class SoldierManager {

    // 存放各类小兵，开始就把士兵定义好，后面都要从这里取
    private Map<String, Soldier> map = new HashMap<>();

    // 添加士兵
    public void setSoldier(String classify, Soldier soldier) {
        map.put(classify, soldier);
    }

    // 获取士兵
    public Soldier getSoldier(String classify) {
        return map.get(classify);
    }

    // 移除士兵，并把目标返回
    public Soldier removeSoleier(String classify) {
        return map.remove(classify);
    }
}
// 客户端，以近卫中路作为演示
public class Client {

    // 以近卫中路作为演示
    public static void main(String[] args) throws CloneNotSupportedException {
        System.out.println("游戏开始前，先把各类士兵定义好，并保存到士兵管理类中");
        SoldierManager manager = new SoldierManager();

        Soldier soldier1 = new Soldier(1, 600, "进战", 30, "小兵", "近卫", "中路");
        Soldier soldier2 = new Soldier(1, 300, "远程", 30, "小兵", "近卫", "中路");
        manager.setSoldier("1级近战小兵", soldier1);
        manager.setSoldier("1级远程小兵", soldier2);

        Soldier soldier3 = new Soldier(2, 1200, "进战", 30, "中兵", "近卫", "中路");
        Soldier soldier4 = new Soldier(2, 600, "远程", 30, "中兵", "近卫", "中路");
        manager.setSoldier("2级近战中兵", soldier3);
        manager.setSoldier("2级远程中兵", soldier4);

        Soldier soldier5 = new Soldier(3, 2400, "进战", 30, "大兵", "近卫", "中路");
        Soldier soldier6 = new Soldier(3, 1200, "远程", 30, "大兵", "近卫", "中路");
        manager.setSoldier("3级近战大兵", soldier5);
        manager.setSoldier("3级远程大兵", soldier6);

        System.out.println("游戏开始，时间：00:00");

        System.out.println("近卫中路创建一波小兵，3个近战、1个远程");

        Soldier soldier0001 = manager.getSoldier("1级近战小兵");
        Soldier soldier0002 = (Soldier) soldier0001.clone(); // 这里为什么不用manager.getSoldier("1级近战小兵")？因为这样返回的对象就是同一个了（引用指向一个内存地址）
        Soldier soldier0003 = (Soldier) soldier0001.clone();
        Soldier soldier0004 = manager.getSoldier("1级远程小兵");
        print(soldier0001, soldier0002, soldier0003, soldier0004);

        System.out.println("游戏时间：00:30");

        System.out.println("近卫中路创建一波小兵，3个近战、1个远程");

        Soldier soldier0005 = (Soldier) soldier0001.clone();
        Soldier soldier0006 = (Soldier) soldier0001.clone();
        Soldier soldier0007 = (Soldier) soldier0001.clone();
        Soldier soldier0008 = (Soldier) soldier0004.clone();
        print(soldier0005, soldier0006, soldier0007, soldier0008);

        System.out.println("每30秒创建一波小兵，每波小兵会进行攻击、也会被攻击，血量会减少、增多（加血）");

        System.out.println("...");

        System.out.println("当天灾中路兵营被攻破后，近卫中路的小兵升级为中兵（新创建的）");

        System.out.println("近卫中路创建一波中兵，3个近战、1个远程");

        Soldier soldier0009 = manager.getSoldier("2级近战中兵");
        Soldier soldier0010 = (Soldier) soldier0009.clone();
        Soldier soldier0011 = (Soldier) soldier0009.clone();
        Soldier soldier0012 = manager.getSoldier("2级远程中兵");
        print(soldier0009, soldier0010, soldier0011, soldier0012);

        System.out.println("...");

        System.out.println("当天灾三路兵营被攻破后，近卫中路的中兵升级为大兵（新创建的）");

        System.out.println("近卫中路创建一波大兵，3个近战、1个远程");

        Soldier soldier0013 = manager.getSoldier("3级近战大兵");
        Soldier soldier0014 = (Soldier) soldier0013.clone();
        Soldier soldier0015 = (Soldier) soldier0013.clone();
        Soldier soldier0016 = manager.getSoldier("3级远程大兵");
        print(soldier0013, soldier0014, soldier0015, soldier0016);
    }

    // 方便打印
    private static void print(Soldier... soldiers) {
        for (Soldier s : soldiers) {
            System.out.println(s);
        }
        System.out.println();
    }
}
/*
游戏开始前，先把各类士兵定义好，并保存到士兵管理类中
游戏开始，时间：00:00
近卫中路创建一波小兵，3个近战、1个远程
Soldier{level=1, blood=600.0, classify='进战', attack=30, display='小兵', camp='近卫', route='中路'}
Soldier{level=1, blood=600.0, classify='进战', attack=30, display='小兵', camp='近卫', route='中路'}
Soldier{level=1, blood=600.0, classify='进战', attack=30, display='小兵', camp='近卫', route='中路'}
Soldier{level=1, blood=300.0, classify='远程', attack=30, display='小兵', camp='近卫', route='中路'}

游戏时间：00:30
近卫中路创建一波小兵，3个近战、1个远程
Soldier{level=1, blood=600.0, classify='进战', attack=30, display='小兵', camp='近卫', route='中路'}
Soldier{level=1, blood=600.0, classify='进战', attack=30, display='小兵', camp='近卫', route='中路'}
Soldier{level=1, blood=600.0, classify='进战', attack=30, display='小兵', camp='近卫', route='中路'}
Soldier{level=1, blood=300.0, classify='远程', attack=30, display='小兵', camp='近卫', route='中路'}

每30秒创建一波小兵，每波小兵会进行攻击、也会被攻击，血量会减少、增多（加血）
...
当天灾中路兵营被攻破后，近卫中路的小兵升级为中兵（新创建的）
近卫中路创建一波中兵，3个近战、1个远程
Soldier{level=2, blood=1200.0, classify='进战', attack=30, display='中兵', camp='近卫', route='中路'}
Soldier{level=2, blood=1200.0, classify='进战', attack=30, display='中兵', camp='近卫', route='中路'}
Soldier{level=2, blood=1200.0, classify='进战', attack=30, display='中兵', camp='近卫', route='中路'}
Soldier{level=2, blood=600.0, classify='远程', attack=30, display='中兵', camp='近卫', route='中路'}

...
当天灾三路兵营被攻破后，近卫中路的中兵升级为大兵（新创建的）
近卫中路创建一波大兵，3个近战、1个远程
Soldier{level=3, blood=2400.0, classify='进战', attack=30, display='大兵', camp='近卫', route='中路'}
Soldier{level=3, blood=2400.0, classify='进战', attack=30, display='大兵', camp='近卫', route='中路'}
Soldier{level=3, blood=2400.0, classify='进战', attack=30, display='大兵', camp='近卫', route='中路'}
Soldier{level=3, blood=1200.0, classify='远程', attack=30, display='大兵', camp='近卫', route='中路'}
*/

这样，不用每个士兵对象都new出来，不容易出错，也提高了程序效率；还有，游戏开始前对各类士兵的定义，可以放在manager类，这样可以对客户端隐藏对象的创建过程，简化使用。

例子仅仅为了体现原型模式，没有做线程安全、代码优化、抽取接口等操作，就是怎么方便怎么来

注意

这个例子通过重写Object类的clone方法，实现对象的拷贝，这是一种方法，但是，当对象的属性为引用类型时，需要层层重写clone，这样，会很麻烦。所以，实现对象的拷贝，还可以通过对象序列化进行实现。具体可了解另一篇文章：java浅克隆与深克隆详解

优点
  1. 提供创建相同对象的方法，简单易用、安全高效
  2. 提供管理类，让对象可以理好地分类管理
  3. 让代码更简洁，提高易读性和可维护性
缺点

需要对对象序列化、深克隆和浅克隆的一定理解

应用

在一个程序中，需要大量的对象时，采用原型模式是不错的选择

原型模式是创建型模式，创建型模式还有四个，分别为单例模式、工厂方法模式、抽象工厂模式和建造者模式

Java设计模式——工厂设计模式详解
08-28
Java设计模式——工厂设计模式详解 在软件设计中，工厂设计模式是一种常用的设计模式，主要用于实例化有共同接口的类。Java设计模式——工厂设计模式是Java中的一种常用的设计模式，主要用于实例化有共同接口的类。...
23种设计模式详解PDF
08-03
设计模式 的分类 总体来说设计模式分为三大类： 创建型模式（5）： 工厂方法模式 、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式（7）： 适配器模式、装饰器模式、代理模式、外观模式、桥接模式、...
原型模式详解 (附java语言源码)
热门推荐
数据知道的博客
06-04 1万+
原型模式（Prototype Pattern）: 用原型实例指定创建对象的种类，并且通过拷贝这个原型来创建新的对象。(Specify the kinds of objects to create using a prototypical instance, and create new objects by copying the prototype.) 通过原型模式，绕过构造方法创建对象，利...
原型模式超详解！
daniu_weilai的博客
10-11 337
前言 当系统中需要大量创建相同或者相似的对象时，就可以通过“原型设计模式”来实现。原型模式是属于创建型模式。 核心思想：通过拷贝指定的"原型实例"来创建跟对象一样的新对象，一句话就是：克隆指定对象。 浅拷贝与深拷贝： 对象内部存在的指向其他对象数组或者引用则不复制 浅拷贝：拷贝一个对象时，只复制对象内部的基本数据类型，对象内部指向引用类型或者数组不复制。 深拷贝：拷贝一个对象时，对象内部的无论基本类型还是引用类型还是数组都复制。 //TODO 浅拷贝和深拷贝的原理图 通过Cloneable 把要克
黑马Java设计模式详解，23种设计模式
最新发布
06-28
在《黑马Java设计模式详解，23种设计模式》这一资料中，系统地介绍了23种经典的设计模式，覆盖了创建型模式、结构型模式和行为型模式三大类别。 创建型模式主要包含五个模式，它们分别是：单例模式、工厂方法模式、...
java23种设计模式详解
01-19
java23种设计模式详解附带所有代码实现，适合初学者，请点个赞，谢谢
23种设计模式详解及案例
12-24
"23种设计模式详解及案例"涵盖了这些模式的理论基础和实际应用，旨在帮助开发者更好地理解和掌握它们。 1. **单例模式**：保证一个类只有一个实例，常用于管理共享资源，如数据库连接。在Android中，单例模式常用于...
设计模式-原型模式详解
rizon886的博客
06-27 154
一、原型模式的概念 　　原型模式属于创建型设计模式。当要创建的对象类型由原型实例确定时使用它，该实例被克隆以生成新对象。 　　此模式用于 　　1、避免客户端应用程序中的对象创建者的子类，如工厂方法模式。 　　2、避免以标准方式创建新对象的固有成本（例如，使用'new'关键字），当它对于给定的应用程序来说过于昂贵时。 　　上述定义来自wiki，简单来说，就是创建一个全新的对象代价太高时，比如耗时太长时，能直接从现有实例中以较小的代价克隆出一个对象。 二、原型模式的实现 　　实现原型模式的方式之一为克...
详解设计模式：原型模式
栗筝i的博客
11-28 3960
原型模式（Prototype Pattern） ，是 GoF 的 23 种设计模式的一种，是用于创建重复的对象，同时又能保证性能。属于创建型模式，提供创建对象的最佳方式。 原型（Prototype），在制造业中通常是指大批量生产开始之前研发出的概念模型，并基于各种参数指标对其进行检验，如果达到了质量要求，即可参照这个原型进行批量生产。 本篇内容包括：关于原型模式、原型模式-浅拷贝实现、原型模式-深拷贝实现
设计模式之原型模式详解（附应用举例实现）
pursuit的博客
04-22 8506
设计模式之原型模式详解（附应用举例实现）
【设计模式-原型模式】设计模式学习记录
weixin_44044600的博客
03-09 350
学习设计模式记录
设计模式（五）原型模式详解
楠寻寻的博客
10-24 1209
定义：原型模型是一种创建型设计模型，它允许通过克隆/复制现有对象来创建新的对象，而无需通过常规的构造函数进行实例化。这种方式的主要优势是在运行时不需要知道具体的类，只需一个实例对象即可。实现方法实现Cloneable接口：在Java中，如果一个类想要支持克隆操作，通常需要实现Cloneable接口，并重写Object类中的clone()方法。深拷贝与浅拷贝浅拷贝：只复制对象本身，对于对象内部引用的其他对象，仍然共享同一个引用。深拷贝。
原型模式
Erick Lv的笔记
06-11 326
模式简介 当一个对象需要完全拷贝另一个对象的状态时，需要使用这个模式。此时，拷贝的新对象和原来的对象拥有同样的行为状态。这么做的优势是，新建对象的时候，我们不需要人工把新对象改变到原来对象的状态，而是复制函数帮我们处理完毕了。 这个模式一般用在那些需要克隆有特定状态的对象。比如一个对象当前存储了某些特定的数值，这些值非常多而且复杂，那么此时就可以使用这个模式了。C++中通过拷贝构造函数来实现。 模...
原型模式理解
mrwangyifei的博客
11-02 232
原型模式: 原型模式可以理解为，以某一个对象为原型，生成一个新的毫无关联，但是初始化数值一致的全新对象。 看一下关系图 几个需要深拷贝的对象以及内嵌对象后面是通过序列化的形式作为解决方案所以需要实现序列化接口。 Monkey.class 作为统一的父类，拥有两个基本类型: 年龄、名称和一个引用类型：生日 在浅拷贝中，引动对象会使用相同的内存地址中的对象，而深拷贝是完全隔离开来的，本次只介绍深拷贝。 Monkey.class最终也是通过序列化转为字节码所以也需要实现序列化接口 GoldenHoop.cl
设计模式之原型模式
helinlin007的专栏
03-18 2919
原型模式也是属于创建者模式中的一种，他与之前的几种模式想比较而言，可能更加方便理解。记得小时候吃的那些有颜色的米糕，每一个米糕上卖弄都有花纹，虽然每一个米糕都不尽相同，但是上面的花纹都是来自同一个板模上来的。        上面的比喻不太合理，换一个比喻吧，假如你到商场去买衣服，上面挂着很多的样品，然后你会试穿样品，等到感觉合身的时候。你肯定会叫售货员换一套不是样品的衣服给你的，同时你也可以换其
原型模式详解及其Java实现源码
在实际的代码实现中，人们常常将实现Cloneable接口并重写clone方法的类命名为Prototype，以此来明确表明该类遵循原型设计模式。 在Java中实现原型模式的关键点如下： 1. 实现Cloneable接口。一个类实现Cloneable...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值