17 结构型模式-享元模式

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

1 享元模式介绍

17 结构型模式-享元模式,设计模式,享元模式,java,开发语言
17 结构型模式-享元模式,设计模式,享元模式,java,开发语言

2 享元模式原理

17 结构型模式-享元模式,设计模式,享元模式,java,开发语言
17 结构型模式-享元模式,设计模式,享元模式,java,开发语言
17 结构型模式-享元模式,设计模式,享元模式,java,开发语言

3 享元模式实现

抽象享元类可以是一个接口也可以是一个抽象类,作为所有享元类的公共父类, 主要作用是提高系统的可扩展性.

//* 抽象享元类
public abstract class Flyweight {
	public abstract void operation(String extrinsicState);
}

具体享元类
具体享元类中要将内部状态和外部状态分开处理,内部状态作为具体享元类的成员变量,而外部状态通过注入的方式添加到具体享元类中.

/**
 * 可共享的-具体享元类
 * 注意: 在具体享元类中,需要将内部状态和外部状态分开处理.
 **/
public class ConcreteFlyweight extends Flyweight{

    //内部状态 : inState作为一个成员变量,同一个享元对象的内部状态是一致的.
    private String inState;

    public ConcreteFlyweight(String inState) {
        this.inState = inState;
    }

    /**
     * 外部状态在使用的时候,通常是有外部设置,不保存在享元对象中,即使是同一个对象
     * @param state
     */
    @Override
    public void operation(String state) {

        System.out.println("=== 享元对象的内部状态: " + inState + ",外部状态: " + state );
    }
}

非共享享元类,不复用享元工厂内部状态,但是是抽象享元类的子类或实现类

/**
 * 非共享的具体享元类
 **/
public class UnsharedFlyweight  extends Flyweight{

    private String inState;

    public UnsharedFlyweight(String inState) {
        this.inState = inState;
    }

    @Override
    public void operation(String state) {
        System.out.println("=== 使用不共享对象,内部状态: " + inState + ",外部状态: " + state );
    }
}

享元工厂类, 管理一个享元对象类的缓存池。它会存储享元对象之间需要传递的共有状态,比如,按照大写英文字母来作为状态标识,这种只在享元对象之间传递的方式就叫内部状态。同时,它还提供了一个通用方法getFlyweight(),主要通过内部状态标识来获取享元对象。

/**
 * 享元工厂类
 * 作用: 作为存储享元对象的享元池.用户获取享元对象时先从享元池中获取,有则返回,没有创建新的返回给用户,
 * 并且在享元池中保存
 **/
public class FlyweightFactory {

    //定义一个Map集合用于存储享元对象,实现享元池
    private Map<String,Flyweight> pool = new HashMap<>();

    //实现享元对象之间的状态传递
    public FlyweightFactory() {
        //添加对应的内部状态
        pool.put("A",new ConcreteFlyweight("A"));
        pool.put("B",new ConcreteFlyweight("B"));
        pool.put("C",new ConcreteFlyweight("C"));
    }

    //根据内部状态进行查找
    public Flyweight getFlyweight(String key){
        //对象是否存在
        if(pool.containsKey(key)){
            System.out.println("=== 享元池中存在,直接复用,key : " + key);
            return pool.get(key);
        }else{
            //如果对象不存在,就创建一个添加到享元池,然后返回
            System.out.println("=== 享元池中不存在,创建并复用,key: " + key);
            Flyweight fw = new ConcreteFlyweight(key);
            pool.put(key,fw);
            return  fw;
        }
    }
}
public class Client {

    public static void main(String[] args) {

        //获取工厂对象
        FlyweightFactory factory = new FlyweightFactory();

        //通过工厂对象获取共享的享元对象
        Flyweight a1 = factory.getFlyweight("A");
        a1.operation("a1ExState");

        Flyweight a2 = factory.getFlyweight("A");
        a2.operation("a2ExState");
        System.out.println(a1 == a2);

        //获取非共享的享元对象
        UnsharedFlyweight u1 = new UnsharedFlyweight("A");
        UnsharedFlyweight u2 = new UnsharedFlyweight("A");
        System.out.println(u1 == u2);
    }
}
4 享元模式应用实例

17 结构型模式-享元模式,设计模式,享元模式,java,开发语言
17 结构型模式-享元模式,设计模式,享元模式,java,开发语言

/**
 * 抽象享元类: 五子棋
 **/
public abstract class GobangFlyweight {

    public abstract String getColor();

    public void display(){
        System.out.println("棋子颜色: " + this.getColor());
    }
}
/**
 * 共享享元类-白色棋子
 **/
public class WriteGobang extends GobangFlyweight {


    @Override
    public String getColor() {
        return "白色";
    }
}
/**
 * 共享享元类-黑色棋子
 **/
public class BlackGobang extends GobangFlyweight {


    @Override
    public String getColor() {
        return "黑色";
    }
}
/**
 * 享元工厂类-生产五子棋棋子
 **/
public class GobangFactory {

    //享元池
    private static Map<String,GobangFlyweight> pool;

    //创建共享享元对象,设置对象的内部状态
    private GobangFactory() {
        pool = new HashMap<>();
        GobangFlyweight black = new BlackGobang(); //黑子
        GobangFlyweight write = new WriteGobang(); //白子

        pool.put("b",black);
        pool.put("w",write);
    }


    //获取唯一享元工厂对象的方法
    public static GobangFactory getInstance(){
       return SingletonHolder.INSTANCE;
    }

    //静态内部类
    private static class SingletonHolder{
        private static final GobangFactory INSTANCE = new GobangFactory();
    }

    //通过key获取集合中的享元对象
    public GobangFlyweight getGobang(String key){
        return pool.get(key);
    }

}
public class Client {

    public static void main(String[] args) {

        GobangFactory instance = GobangFactory.getInstance();

        //获取3颗黑子
        GobangFlyweight b1 = instance.getGobang("b");
        GobangFlyweight b2 = instance.getGobang("b");
        GobangFlyweight b3 = instance.getGobang("b");
        System.out.println("判断黑子是否是同一对象: " + (b1 == b2));

        GobangFlyweight w1 = instance.getGobang("w");
        GobangFlyweight w2 = instance.getGobang("w");
        System.out.println("判断白子是否是同一对象: " + (w1 == w2));

        //显示棋子
        b1.display();
        b2.display();
        b3.display();
        w1.display();
        w2.display();
    }
}

17 结构型模式-享元模式,设计模式,享元模式,java,开发语言

5 享元模式总结

17 结构型模式-享元模式,设计模式,享元模式,java,开发语言
17 结构型模式-享元模式,设计模式,享元模式,java,开发语言
17 结构型模式-享元模式,设计模式,享元模式,java,开发语言文章来源地址https://www.toymoban.com/news/detail-720190.html

到了这里,关于17 结构型模式-享元模式的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索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日
    浏览(52)
  • Java设计模式之结构型-享元模式(UML类图+案例分析)

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

    2024年02月16日
    浏览(45)
  • 17 结构型模式-享元模式

    1 享元模式介绍 2 享元模式原理 3 享元模式实现 抽象享元类 可以是一个接口也可以是一个抽象类,作为所有享元类的公共父类, 主要作用是提高系统的可扩展性. 具体享元类 具体享元类中要将内部状态和外部状态分开处理,内部状态作为具体享元类的成员变量,而外部状态通过注

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

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

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

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

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

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

    2024年02月11日
    浏览(37)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包