【设计模式-3.3】结构型——享元模式

这篇具有很好参考价值的文章主要介绍了【设计模式-3.3】结构型——享元模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

说明:说明:本文介绍设计模式中结构型设计模式中的,享元模式;

游戏地图

在一些闯关类的游戏,如超级玛丽、坦克大战里面,游戏的背景每一个关卡都不相同,但仔细观察可以发现,其都是用一些基础图标组成的,背景的变化实际上就是改变了其基础图标的位置。

如坦克大战,游戏背景实际上就是通过敌方坦克、我方坦克、砖墙、铁墙、海洋、草丛、基地等这些图标组成的。

【设计模式-3.3】结构型——享元模式,设计模式,享元模式,java

基础图标,坦克、草地、河流……

【设计模式-3.3】结构型——享元模式,设计模式,享元模式,java

【设计模式-3.3】结构型——享元模式,设计模式,享元模式,java

【设计模式-3.3】结构型——享元模式,设计模式,享元模式,java

现在,如果要我们来开发这样一个游戏地图。首先,我们会创建一个地图块类,如下:

(Tile,图块类)

/**
 * 图块类
 */
public class Tile {

    /**
     * 图块名称
     */
    private String image;

    /**
     * 图块的x坐标
     */
    private int x;

    /**
     * 图块的y坐标
     */
    private int y;

    /**
     * 创建图块对象
     */
    public Tile(String image, int x, int y) {
        this.image = image;
        this.x = x;
        this.y = y;
        System.out.println("加载图片:" + image);
    }

    /**
     * 绘制图块
     */
    public void draw() {
        System.out.println("绘制图片:" + image + ",坐标:" + x + "," + y);
    }
}

(Client,客户端,演示游戏地图创建过程)

/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        // 在地图上绘制两个“海洋”图块
        new Tile("海洋", 1, 2).draw();
        new Tile("海洋", 2, 3).draw();

        // 在地图上绘制两个“草丛”图块
        new Tile("草丛", 1, 3).draw();
        new Tile("草丛", 2, 4).draw();

        // 在地图上绘制两“砖墙”图块
        new Tile("砖墙", 1, 4).draw();
        new Tile("砖墙", 2, 5).draw();
    }
}

运行程序,加载游戏地图

【设计模式-3.3】结构型——享元模式,设计模式,享元模式,java

分析以上过程,会发现问题很大。每次创建一个图块对象,都需要new,加载时间特别长,且浪费资源。

为了解决这个问题,我们似乎可以考虑用原型设计模式解决。但是我们需要考虑,对于一个游戏地图来说,图块种类的数量可能是非常庞大的,使用原型模式对对象进行克隆,会有大量的内存开销,如果没有良好的内存回收机制,可能会导致内存溢出,造成系统崩溃。因此,使用原型模式来解决游戏地图的设计,不一定是合适的。

享元模式

享元,元指的是最小的单元,也就是上面坦克大战中草丛、海洋这些最小的图块,享元就是共享这些最小图块。通过享元模式对上面地图加载代码改进,如下:

(Drawable,绘画接口)

/**
 * 绘画接口
 */
public interface Drawable {
    
    /**
     * 绘制图块
     */
    void draw(int x, int y);
}

(Grass,草地图块)

/**
 * 草地图块
 */
public class Grass implements Drawable {

    /**
     * 图块名称
     */
    private String name;

    public Grass() {
        this.name = "草地";
        System.out.println("创建图块:" + name);
    }

    @Override
    public void draw(int x, int y) {
        System.out.println("绘制【" + name + "】图块:" + name + ",位置:(" + x + ", " + y + ")");
    }
}

(Wall,墙壁图块)

/**
 * 墙壁图块
 */
public class Wall implements Drawable {

    /**
     * 图块名称
     */
    private String name;

    public Wall() {
        this.name = "墙壁";
        System.out.println("创建墙壁图块:" + name);
    }

    @Override
    public void draw(int x, int y) {
        System.out.println("绘制【" + name + "】图块:" + name + ",位置:(" + x + ", " + y + ")");
    }
}

(River,河流图块)

/**
 * 河流图块
 */
public class River implements Drawable {

    /**
     * 图块名称
     */
    private String name;

    public River() {
        this.name = "河流";
        System.out.println("创建图块:" + name);
    }

    @Override
    public void draw(int x, int y) {
        System.out.println("绘制【" + name + "】图块:" + name + ",位置:(" + x + ", " + y + ")");
    }
}

(Home,基地图块)

/**
 * 基地图块
 */
public class Home implements Drawable {

    /**
     * 基地图块名称
     */
    private String name;

    public Home() {
        this.name = "基地";
        System.out.println("创建图块:" + name);
    }

    @Override
    public void draw(int x, int y) {
        System.out.println("绘制【" + name + "】图块:" + name + ",位置:(" + x + ", " + y + ")");
    }
}

(TileFactory,图块工厂)

import java.util.HashMap;
import java.util.Map;

/**
 * 图块工厂
 */
public class TileFactory {

    /**
     * 图块集合
     */
    private Map<String, Drawable> Tiles;

    /**
     * 图块工厂构造函数
     */
    public TileFactory() {
        Tiles = new HashMap<String, Drawable>();
    }

    /**
     * 根据图块名称获取图块,没有就创建并返回,有就直接从集合中获取并返回
     */
    public Drawable getTile(String name) {
        // 没有就创建
        if (!Tiles.containsKey(name)) {
            switch (name) {
                case "河流":
                    Tiles.put(name, new Wall());
                    break;
                case "草地":
                    Tiles.put(name, new Grass());
                    break;
                case "基地":
                    Tiles.put(name, new Home());
                    break;
                case "墙壁":
                    Tiles.put(name, new Wall());
                    break;
                default:
                    break;
            }
        }
        // 有就直接返回
        return Tiles.get(name);
    }
}

(Client,客户端,演示游戏地图加载过程)

/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        // 创建图块工厂
        TileFactory tileFactory = new TileFactory();

        // 绘制地图
        tileFactory.getTile("草地").draw(0, 0);
        tileFactory.getTile("草地").draw(1, 0);
        tileFactory.getTile("草地").draw(2, 0);

        tileFactory.getTile("河流").draw(0, 1);
        tileFactory.getTile("河流").draw(1, 1);

        tileFactory.getTile("墙壁").draw(0, 2);
        tileFactory.getTile("墙壁").draw(1, 2);

        tileFactory.getTile("基地").draw(0, 3);
    }
}

可以发现,各个图块构造器内的输出语句只执行了一次,说明后续图块的创建没有调用其构造方法,实现了享元

【设计模式-3.3】结构型——享元模式,设计模式,享元模式,java

以上就是通过享元模式对游戏地图设计的过程,实际上就是对最小单元对象的共享,使其不重复去创建对象。

需要注意区分于工厂设计模式,工厂模式是创建型设计模式,关注对象的创建,而享元模式是对已创建对象的一种利用,是结构型设计模式

总结

本文参考《设计模式的艺术》、《秒懂设计模式》两书文章来源地址https://www.toymoban.com/news/detail-794686.html

到了这里,关于【设计模式-3.3】结构型——享元模式的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 笨蛋学设计模式结构型模式-享元模式【13】

    7.7.1概念 ​ 享元模式是通过共享对象减少内存使用,来提高程序性能。在此模式中,分为内部状态和外部状态,其中相似的对象被存储在享元对象内部,并对于所有享元对象都是相同的,且状态通常是不变的。只在需要时内部共享,而不是每次创建新的对象。而外部状态是享

    2024年01月23日
    浏览(43)
  • 【十】设计模式~~~结构型模式~~~享元模式(Java)

    【学习难度:★★★★☆,使用频率:★☆☆☆☆】         面向对象技术可以很好地解决一些灵活性或可扩展性问题,但在很多情况下需要在系统中增加类和对象的个数。当对象数量太多时,将导致运行代价过高,带来性能下降等问题。 享元模式正是为解决这一类问题

    2024年02月08日
    浏览(49)
  • 【结构型设计模式】C#设计模式之享元模式

    享元模式(Flyweight Pattern)是一种结构型设计模式,旨在通过尽可能共享对象来减少内存使用和提高性能。它将对象分为两种类型:内部状态(Intrinsic State)和外部状态(Extrinsic State)。内部状态是可以共享的,而外部状态是独立于享元对象的,并且在使用时需要注入。 使用

    2024年02月13日
    浏览(39)
  • 【设计模式】第13节:结构型模式之“享元模式”

    所谓“享元”,顾名思义就是被共享的单元。享元模式的意图是复用对象,节省内存,前提是享元对象是不可变对象。 实现:通过工厂模式,在工厂类中,通过一个Map或者List来缓存已经创建好的享元对象,以达到复用的目的。把实例的共享状态和不共享状态分开。 以下是画

    2024年02月08日
    浏览(41)
  • 【Java 设计模式】结构型之享元模式

    享元模式(Flyweight Pattern)是一种结构型设计模式,它旨在减少对象的数量以节省内存和提高性能。享元模式通过共享大量相似对象的状态,使得这些对象可以共享,而不需要在每个对象中都存储相同的数据。在本文中,我们将深入研究Java中享元模式的定义、结构、使用场景

    2024年01月22日
    浏览(53)
  • Java设计模式之结构型-享元模式(UML类图+案例分析)

    目录 一、基本概念 二、UML类图 三、角色设计 四、案例分析 4.1、基本实现 4.2、游戏角色 五、总结 享元模式是一种结构型设计模式,主要用于减少创建大量相似对象所占用的内存,它通过共享技术来有效支持大量细粒度的对象。 角色 描述 抽象享元角色 定义出对象的外部状

    2024年02月16日
    浏览(45)
  • 设计模式--------结构型模式

    结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式,前者采用继承机制来组织接口和类,后者釆用组合或聚合来组合对象。 由于组合关系或聚合关系比继承关系耦合度低,满足“合成复用原则”,所以对象结构型模式比类结构

    2024年02月13日
    浏览(48)
  • 设计模式结构型——外观模式

    目录 什么是外观模式 外观模式的实现 外观模式角色 外观模式举例 外观模式类图 外观模式代码实现 外观模式的特点 优点 缺点 注意事项 应用场景 总结         外观模式(Facade Pattern):又叫作门面模式,归属于结构型模式。外观模式定义了提供了定义了一个统一的高层

    2024年02月16日
    浏览(54)
  • 设计模式之结构型模式

    本文已收录于专栏 《设计模式》   大话设计模式主要分为三部分,第一部分是创建型模式,第二部分是结构型模式,第三部分是行为型模式。至于为什么要分为这三部分,我的理解是创建型是用于创建对象的而结构型是发生在类与类之间的关系是比较宏观的,比如说组合

    2024年02月11日
    浏览(37)
  • 结构型设计模式——外观模式

    有句话说这个世界就是个草台班子,只不过排面做的好看而已,里面都是一包糠。这句话来形容外观模式非常准确,外观模式又叫门面模式,顾名思义一个系统我不管你里面有多复杂有多少屎山代码,我只要求你提供的接口好用,简单就行,即门面要有排面!用专业的话讲是

    2024年01月22日
    浏览(44)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包