《设计模式》11.享元模式（结构型）

最新推荐文章于 2024-11-10 22:06:14 发布
最新推荐文章于 2024-11-10 22:06:14 发布
阅读量103 收藏
点赞数
分类专栏： 设计模式 文章标签： Java 设计模式 享元模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37477523/article/details/89714083
版权

运用共享技术来有効地支持大量细粒度对象的复用。享元对象的两个状态：内部状态和外部状态。

角色

抽象享元（Flyweight）：接口或抽象类，定义可共享的内部状态和公共接口，不可共享的外部状态（非享元）作为接口参数的方式传入
具体享元（Concrete Flyweight）：实现抽象享元角色中所规定的接口
非享元（Unsharable Flyweight)：不可以共享的外部状态，以参数的形式传入享元的接口
享元工厂（Flyweight Factory）：负责创建和管理享元角色。先检查缓存中是否存在符合要求的享元对象，如果存在直接返回，不存在创建新的享元对象

抽象享元 Flyweight

抽象方法，定义可共享的内部状态，公共接口

public abstract class Flyweight {
    protected String innerStatus;
    public Flyweight(String innerStatus) {
        this.innerStatus = innerStatus;
    }

    abstract void operation(UnsharedConcreteFlyweight outerStatus);
}

具体享元 Concrete Flyweight

继承享元基类，实现公共接口

public class ConcreteFlyweight extends Flyweight {
    public ConcreteFlyweight(String innerStatus) {
        super(innerStatus);
    }

    @Override
    public void operation(UnsharableConcreteFlyweight outerStatus) {
        System.out.print(", inner status: " + innerStatus);
        System.out.println(", outer status: " + outerStatus);
    }
}

非享元 Unsharable Flyweight

定义不可共享的外部状态

public class UnsharableConcreteFlyweight {
    private String info;
    public UnsharedConcreteFlyweight(String info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return info;
    }
}

享元工厂 FlyweightFactory

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

public class FlyweightFactory {
    private static final ConcurrentMap<String, Flyweight> flyweights = new ConcurrentHashMap<>();

    public Flyweight getFlyweight(String innerStatus) {
        if (flyweights.containsKey(innerStatus)) {
            System.out.print(String.format("\tGet exist Flyweight: %s", innerStatus));
            return flyweights.get(innerStatus);
        }

        Flyweight flyweight = new ConcreteFlyweight(innerStatus);
        flyweights.put(innerStatus, flyweight);
        System.out.print(String.format("Create new Flyweight: %s", innerStatus));
        return flyweight;
    }
}

测试类

public class FlyweightTester {
    public static void main(String args[]) {
        FlyweightFactory factory = new FlyweightFactory();
        Random random = new Random();
        String innerStatus;
        UnsharableConcreteFlyweight outerStatus = null;
        for (int i = 0; i < 5; i++) {
            innerStatus = String.format("%5d", random.nextInt(2));
            String uuid = UUID.randomUUID().toString().replace("-", "");
            outerStatus = new UnsharableConcreteFlyweight(uuid);
            factory.getFlyweight(innerStatus).operation(outerStatus);
        }
    }
}

Create new Flyweight:     1, inner status:     1, outer status: c057fe41093247f8bf92344fd5a25194
Create new Flyweight:     0, inner status:     0, outer status: cfbf38fedbe948d782a6b7efd32e2767
	Get exist Flyweight:     1, inner status:     1, outer status: b40861ba38ea4272832e25c458ec4c9a
	Get exist Flyweight:     1, inner status:     1, outer status: 4f03baf03cab4e219be84793d7500c1c
	Get exist Flyweight:     0, inner status:     0, outer status: 2f769afc0290441a93af812e58d2b236

举例1：围棋

围棋分为黑子和白子，颜色仅两种，可共享作为内部状态，在棋盘的位置属于外部状态不可共享，在下棋时确认

public abstract class Chess {
    abstract void drop(Coordinate coordinate);
}

public class ChessPiece extends Chess {
    private Color color;
    public ChessPiece(Color color) {
        this.color = color;
    }

    public void drop(Coordinate coordinate) {
        System.out.println(String.format("%s落在：%s", color.type(), coordinate.position()));
    }

    public enum Color {
        White("白子"),
        Black("黑子");
        private String type;
        Color(String type) {
            this.type = type;
        }

        public String type() {
            return type;
        }
    }
}

public class Coordinate {
    private int x;
    private int y;
    public Coordinate(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public String position() {
        return String.format("%2d, %2d", x, y);
    }
}

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

public class ChessPieceFactory {
    public static final ConcurrentMap<ChessPiece.Color, ChessPiece> chessPieceCaches = new ConcurrentHashMap<>(2);
    public static ChessPiece getChessPiece(ChessPiece.Color color) {
        if (chessPieceCaches.containsKey(color)) {
            return chessPieceCaches.get(color);
        }

        ChessPiece chessPiece = new ChessPiece(color);
        chessPieceCaches.put(color, chessPiece);
        return chessPiece;
    }
}

public class ChessPieceTester {
    public static void main(String args[]) {
        ChessPiece whiteChessPiece = ChessPieceFactory.getChessPiece(ChessPiece.Color.White);
        whiteChessPiece.drop(new Coordinate(1, 1));

        ChessPiece blackChessPiece = ChessPieceFactory.getChessPiece(ChessPiece.Color.Black);
        blackChessPiece.drop(new Coordinate(1, 2));
    }
}

白子落在： 1,  1
黑子落在： 1,  2

举例2：麻将

四川麻将共108张，分为筒、条、万三种牌型，包含 1-9 数字，同一花色有4张，类型和数字可作为内部状态，而打牌的人属于外部状态

public class Mahjong implements Comparable<Mahjong> {
    private Type type;
    private Number number;

    public Mahjong(Type type, Number number) {
        this.type = type;
        this.number = number;
    }

    public void play(String name) {
        System.out.println(String.format("%s play %s %s", name, number, type));
    }

    public String getType() {
        return type.getDesc();
    }

    public String getNumber() {
        return number.getDesc();
    }

    public String getDescription() {
        return String.format("%s%s", number.getDesc(), type.getDesc());
    }

    @Override
    public int compareTo(Mahjong another) {
        if (this.type.equals(another.type) && this.number.equals(another.number))
            return 0;
        if (this.type.compareTo(another.type) != 0) {
            return this.type.compareTo(another.type);
        }
        return this.number.compareTo(another.number);
    }

    public enum Type {
        TONG("筒"),
        TIAO("条"),
        WAN("万");

        private String desc;
        Type(String desc) {
            this.desc = desc;
        }

        public String getDesc() {
            return desc;
        }
    }

    public enum Number {
        ONE("一"),
        TWO("二"),
        THREE("三"),
        FOUR("四"),
        FIVE("五"),
        SIX("六"),
        SEVEN("七"),
        EIGHT("八"),
        NINE("九");

        private String desc;
        Number(String desc) {
            this.desc = desc;
        }

        public String getDesc() {
            return desc;
        }
    }
}

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

public class MahjongFactory {
    private static final ConcurrentMap<String, Mahjong> mahjongCaches = new ConcurrentHashMap<>(27);
    public static Mahjong getMahjong(Mahjong.Type type, Mahjong.Number number) {
        String key = type.name() + "#" +  number.name();
        if (mahjongCaches.containsKey(key)) {
            return mahjongCaches.get(key);
        }

        Mahjong newInstance = new Mahjong(type, number);
        mahjongCaches.put(key, newInstance);
        return newInstance;
    }
}

import java.util.*;

public class Player {
    private static final Random random = new Random((int) (Math.random() * 10));
    private String name;
    private List<Mahjong> mahjongs;
    public Player(String name) {
        this.name = name;
        mahjongs = new ArrayList<>(13);
    }

    public void touchCard(Mahjong mahjong, boolean display) {
        if (display) {
            System.out.println(String.format("%s 摸牌，摸到: %s", name, mahjong.getDescription()));
        }
        mahjongs.add(mahjong);
        Collections.sort(mahjongs);
        if (display) {
            display();
        }
    }

    public void playCard() {
        Iterator<Mahjong> iterator = mahjongs.iterator();
        Mahjong mahjong = mahjongs.remove(random.nextInt(mahjongs.size() - 1));
        System.out.println(String.format("%s 打出: %s", name, mahjong.getDescription()));
        Collections.sort(mahjongs);
        display();
    }

    public int cardCount() {
        return mahjongs.size();
    }

    public void display() {
        StringBuffer sb = new StringBuffer();
        Iterator<Mahjong> iterator = mahjongs.iterator();
        while (iterator.hasNext()) {
            Mahjong mahjong = iterator.next();
            if (sb.length() > 0) {
                sb.append(" ");
            }
            sb.append(mahjong.getDescription());
        }
        sb.insert(0, String.format("[%s] (%2d) ", name, cardCount()));
        System.out.println(sb.toString());
    }
}

public class MahjongMachine {
    private static final Random random = new Random((int) (Math.random() * 10));
    private static final Map<String, List<Mahjong>> mahjongCaches = new HashMap<>(27);
    private List<Mahjong> mahjongs = new ArrayList<>();

    public void touchCard(Player player) {
        Iterator<Mahjong> iterator = mahjongs.iterator();
        if (iterator.hasNext()) {
            Mahjong mahjong = iterator.next();
            player.touchCard(mahjong, true);
            iterator.remove();
        }
    }

    public List<Player> licensing(int cardCount, String ... playerNames) {
        Player player = null;
        List<Player> players = new ArrayList<>(playerNames.length);
        for (String playerName : playerNames) {
            player = new Player(playerName);
            players.add(player);
        }

        int counter = 0, playerCount = playerNames.length;
        Mahjong mahjong;
        Iterator<Mahjong> iterator = mahjongs.iterator();
        while (iterator.hasNext()) {
            player = players.get(counter % playerCount);
            if (player.cardCount() < cardCount + 1) {
                mahjong = iterator.next();
                player.touchCard(mahjong, false);
                iterator.remove();
                counter++;

                if (player.cardCount() == cardCount + 1) {
                    break;
                }
            }
        }

        for (Player temp : players) {
            temp.display();
        }
        return players;
    }

    public void reshuffle() {
        List<Mahjong> result = new ArrayList<>(108);
        for (Map.Entry<String, List<Mahjong>> entry : mahjongCaches.entrySet()) {
            result.addAll(entry.getValue());
        }
        mahjongs.addAll(result);
        Collections.shuffle(mahjongs);
    }

    public void init() {
        if (mahjongCaches != null && !mahjongCaches.isEmpty()) {
            return;
        }

        List<Mahjong> temp = null;
        for (Mahjong.Type type : Mahjong.Type.values()) {
            for (Mahjong.Number number : Mahjong.Number.values()) {
                String key = String.format("%s#%s", type.name(), number.name());
                for (int i = 0; i < 4; i++) {
                    if (!mahjongCaches.containsKey(key)) {
                        temp = new ArrayList<>(4);
                        temp.add(MahjongFactory.getMahjong(type, number));
                        mahjongCaches.put(key, temp);
                    } else if ((temp = mahjongCaches.get(key)).size() < 4) {
                        temp.add(MahjongFactory.getMahjong(type, number));
                        mahjongCaches.put(key, temp);
                    }
                }
            }
        }
    }

    public int cardCount() {
        return mahjongs.size();
    }

    private <T extends Enum<T>> T random(Class<T> tClass) {
        if (!tClass.isEnum()) {
            throw new RuntimeException("Class is not a enum: " + tClass.getName());
        }

        int bound = Mahjong.Type.values().length;
        int randomIndex = random.nextInt(bound);
        return tClass.getEnumConstants()[randomIndex];
    }
}

import java.util.List;

public class MahjongTester {
    public static void main(String args[]) {
        MahjongMachine machine = new MahjongMachine();
        machine.init();
        machine.reshuffle();

        int round = 1;
        String[] playerNames = new String[] { "张三", "李四", "王二", "麻子" };
        System.out.println("===============================================");
        System.out.println(String.format("                   开始第%3d局                   ", round));
        System.out.println("===============================================");
        List<Player> players = machine.licensing(12, playerNames);
        System.out.println(String.format("剩余：%3d 张牌", machine.cardCount()));

        int counter = 1, playerCount = playerNames.length;

        System.out.println("\n");
        Player player;
        player = players.get(0);
        player.playCard();
        counter++;

        while (machine.cardCount() > 0 && round <= 100) {
            System.out.println("\n");
            player = players.get(counter % playerCount);
            machine.touchCard(player);
            System.out.println(String.format("剩余：%3d 张牌", machine.cardCount()));
            counter++;
            player.playCard();
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if (machine.cardCount() == 0) {
                System.out.println("Game Over!");
                if (++round <= 100) {
                    System.out.println("===============================================");
                    System.out.println(String.format("                   开始第%3d局                   ", round));
                    System.out.println("===============================================");
                    machine.reshuffle();
                }
            }
        }
    }
}

参考：
http://c.biancheng.net/view/1371.html
https://blog.csdn.net/Elsa15/article/details/87930541
https://www.cnblogs.com/V1haoge/p/6542449.html

johnjoe.xie
关注
专栏目录
设计模式 - 结构型设计模式小结
了解➔熟悉➔掌握➔精通
02-02 6万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net Definition Specify the kind of objects to create using a prototypical instance, and create new objects by copying this prot...
12结构型设计模式——享元模式
qq_55610255的博客
08-26 1168
享元模式的核心思想就是分离对象的变与不变部分，将可以共享的部分（不变部分）提取出来进行共享，以减少内存消耗和提高系统性能，例如flyweight.cpp中的代码设计中把字体的大小作为相同（不变）的部分，作为共享对象数据，而不同的形态则作为外部对象引入。
设计模式 - 结构型设计模式 - 享元模式（Java）
热门推荐
了解➔熟悉➔掌握➔精通
02-11 6万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net Definition Use sharing to support large numbers of fine-grained objects efficiently. Participants The classes and/or ...
C++ 设计模式——享元模式
qq_68194402的博客
08-26 1389
享元模式也称为蝇量模式旨在解决面向对象程序设计中的性能问题。享元的英文名“Flyweight”意为“轻量级”，源于拳击比赛中较轻的选手。该模式的核心目标是让对象变得“轻”，即减少内存占用。在需要某个对象时，尽量共享已经创建的同类对象，以避免频繁使用 `new` 创建同类或相似的对象。在对象数量非常庞大的情况下，这种共享可以显著节省内存占用并提升程序运行效率。
前端开发设计模式——享元模式
jxnd123456的博客
10-02 2060
享元模式是一种结构型设计模式，旨在通过共享对象来减少内存使用并提高性能。在前端开发中，它用于处理大量细粒度对象的情况，将对象的状态划分为内部状态（可共享）和外部状态（不可共享）。
结构型设计模式（组合、享元）
无简介
08-28 1159
本文将介绍结构型设计模式中的组合模式、享元模式。组合模式和享元模式都是结构型设计模式，用于管理对象之间的关系和提高系统的灵活性和性能。组合模式主要关注构建具有层次结构的对象，使得客户端可以以一致的方式处理单个对象和组合对象。享元模式主要关注减小内存开销，通过共享内部状态来避免重复创建相似对象，从而提高性能。组合模式适用于需要构建树状结构的场景，而享元模式适用于需要大量相似对象的场景。两者的关键差异在于目标：组合模式关注对象的结构，而享元模式关注对象的共享。
Java设计模式- 结构型设计模式-享元模式
Fatter$hday的博客
07-02 842
Java设计模式- 结构型设计模式-享元模式
设计模式之享元模式(C++)
翟天保的博客
04-06 2万+
介绍设计模式之享元模式
【设计模式】——享元模式（Flyweight Pattern）
J^T的博客
08-06 1564
享元模式（Flyweight Pattern）是一种对象结构型模式，它通过共享已经存在的对象来减少内存使用量和提高系统性能。享元模式特别适用于那些创建大量相似对象而导致内存消耗过大的场景。本文将详细介绍享元模式在C++中的实现和应用。
【结构型模型】享元模式
Emily的博客
04-23 1054
享元模式定义又叫蝇量模式，运用共享技术有效地支持大量细粒度对象的复用。系统只使用少量的对象，而这些对象都很相似，状态变化很小，可以实现对象的多次复用。由于享元模式要求能够共享的对象必须是细粒度对象，因此它又称为轻量级模式。对象结构型模式享元模式的设计一个关键的地方是先要区分内部状态和外部状态内部状态：存储在享元对象内部并且不会随环境改变而改变的状态，内部状态可以共享（例如：字符的内容）外部状态：随环境改变而改变的、不可以共享的状态。
js设计模式之结构型享元模式详解
10-19
享元模式是一种结构型设计模式，它是软件工程中常用的一种设计模式，旨在通过共享来有效支持大量细粒度对象的复用，从而减少内存消耗或提升性能。在JavaScript中，享元模式通常用于Web页面的性能优化，尤其是当页面...
设计模式_结构型_享元模式.md
04-23
享元模式（Flyweight）是23种设计模式之一，属于结构型设计模式。该模式通过共享技术，有效地支持大量细粒度对象的复用。享元模式的目的是为了减少创建对象的数量，以减少内存占用和提高性能。 ### 细粒度对象 享元...
JAVA-设计模式-结构型模式-享元模式
08-10
JAVA-设计模式-结构型模式-享元模式
【设计模式】结构型模式（四）：组合模式、享元模式
书山有路，学海无涯。记录成长，追逐梦想
11-09 780
组合模式（Composite Pattern）是一种设计模式，用于处理树形结构的数据。它的主要目的是将对象组合成树形结构来表示 “部分 - 整体” 的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
JavaScript 23种经典设计模式简介
前端梦工厂
11-06 1161
23种JavaScript经典设计模式。
设计模式学习总结（一）
huanggang982的专栏
11-09 314
设计模式学习笔记面向对象、设计原则、设计模式、编程规范、重构之间的关系 面向对象、设计原则、设计模式、编程规范、重构之间的关系 面向对象 现在，主流的编程范式或者是编程风格有三种：面向过程、面向对象和函数式编程。 需要掌握七大知识点： 1、面向对象的四大特性：封装、抽象、继承、多态 2、面向对象编程与面向过程编程的区别和联系 3、面向对象分析、面向对象设计、面向对象编程 4、接口和抽象类的区别以及各自的应用场景 5、基于接口而非实现编程的设计思想 6、多用组合少用继承的设计思想 7、面向过程的贫血模型和面
设计模式之责任链模式（Chain Of Responsibility）
最新发布
liang8999的博客
11-10 447
4）职责链模式常被用在框架开发中，用来实现框架的过滤器、拦截器功能，让框架的使用者在不修改源码的情况下，添加新的过滤拦截功能。3）客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不。1）抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和。处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。并且每个类只需要处理自己该处理的工作，不能处理的传递给下一个对象。5）责任分担，每个类只需要处理自己该处理的工作，不能处理的传递给下一个对象完成，
Unity中RTS游戏的设计模式处理： 游戏中的对象选择和命令委托的基本框架
网易搬砖选手
11-06 383
单个集中类（例如，）跟踪当前选择的单元/对象，并处理用于选择游戏中对象的任何光线投射逻辑。可选对象附加了一个组件，其中公开了一个公共函数，该函数返回一个实现该接口的类。类实现特定于控制单个单元的自定义逻辑。这是通过一个公共函数完成的，每次玩家单击一个新对象时都会调用该函数。当玩家单击屏幕时，单个类会进行光线投射，以获取有关单击哪个对象的信息。该类还跟踪当前正在控制的单元，并将新单击的对象提供给该单元的控制逻辑。如果没有选择任何内容，我们将尝试选择接下来单击的对象。
备忘录模式：保存对象状态的设计模式
wrxfxdd的博客
11-06 561
备忘录模式：保存对象状态的设计模式
享元模式：高效支持大量细粒度对象的结构型设计
享元模式（Flyweight Pattern），也被称为“高效对象池”或“轻量级对象”，是结构型设计模式之一，它关注于如何通过共享技术高效地管理大量细粒度对象，以降低内存消耗和提高系统性能。在软件设计中，当面对大量...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值