Java 23种设计模式（12.结构型模式-享元模式）

朱雀 2023-09-23 22:58 110阅读 0赞

> # 结构型模式-`享元模式` #

# 代码分析 #

## 类图![在这里插入图片描述][253826b35dda4b77930771a6ff7fe526.png] ##

## 代码 ##

abstract class Flyweight {
        
        abstract void operation(int ex);
    }

public class ConcreteFlyweight extends Flyweight{
        
        @Override
        void operation(int ex) {
        
            System.out.println("具体Flyweight"+ex);
        }
    }

public class UnsharedConcreteFlyweight extends Flyweight {
        
        @Override
        void operation(int ex) {
        
            System.out.println("不共享具体Flyweight"+ex);
        }
    }

public class FlyweightFactory {
        
        private Hashtable<String,Flyweight> table;
        private  FlyweightFactory(){
        
            table = new Hashtable<>();
            table.put("X",new ConcreteFlyweight());
            table.put("Y",new ConcreteFlyweight());
        }
    
        public static  FlyweightFactory getInstance(){
        
            return fly;
        }
        private static FlyweightFactory fly = new FlyweightFactory();
        public Flyweight getFlyweight(String key){
        
            return table.get(key);
        }
    }

public class Client {
        
        public static void main(String[] args) {
        
            Flyweight fx1 = FlyweightFactory.getInstance().getFlyweight("X");
            fx1.operation(1);
            Flyweight fx2 = FlyweightFactory.getInstance().getFlyweight("X");
            fx2.operation(2);
    
            Flyweight fx3 = FlyweightFactory.getInstance().getFlyweight("Y");
            fx3.operation(1);
            Flyweight fx4 = FlyweightFactory.getInstance().getFlyweight("Y");
            fx4.operation(2);
        }
    }

具体Flyweight1
    具体Flyweight2
    具体Flyweight1
    具体Flyweight2

## 运行结果 ##

# 1.概述 #

**定义：**  
运用共享技术来有效地支持大量细粒度对象的复用。它**通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似对象的开销，从而提高系统资源的利用率**。

# 2.结构 #

`享元（Flyweight ）模式`中存在以下两种状态：

1.  `内部状态`，即不会**随着环境的改变而改变的可共享部分**。
2.  `外部状态`，指**随环境改变而改变的不可以共享的部分**。享元模式的实现要领就是区分应用中的这两种状态，并将外部状态外部化。

享元模式的主要有以下角色：

*  **抽象享元角色（Flyweight）**：通常**是一个接口或抽象类**，在**抽象享元类中声明了具体享元类公共的方法，这些方法可以向外界提供享元对象的内部数据（内部状态）**，同时也可以通过这些方法来设置外部数据（外部状态）。
 *  **具体享元（Concrete Flyweight）角色** ：它实现了抽象享元类，称为享元对象；在具体享元类中为内部状态提供了存储空间。通常我们可以**结合单例模式来设计具体享元类，为每一个具体享元类提供唯一的享元对象。**
 *  **非享元（Unsharable Flyweight)角色** ：并不是所有的抽象享元类的子类都需要被共享，不能被共享的子类可设计为非共享具体享元类；当需要一个非共享具体享元类的对象时可以直接通过实例化创建。
 *  **享元工厂（Flyweight Factory）角色** ：**负责创建和管理享元角色**当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。

# 3. 类图 #

【例】俄罗斯方块  
下面的图片是众所周知的俄罗斯方块中的一个个方块，如果在俄罗斯方块这个游戏中，每个不同的方块都是一个实例对象，这些对象就要占用很多的内存空间，下面利用享元模式进行实现。

![在这里插入图片描述][5286202ff1cc4712bfa570e6d874a1e6.png]

# 4. 代码 #

abstract class AbstractBox {
        
        abstract String getShape();//获取图形的方法
        public void display(String color){
         //显示图形及颜色
            System.out.println("Shape:" + this.getShape()+" "+"Color:"+color);
        }
    }

public class IBox extends AbstractBox{
        
        @Override
        String getShape() {
        
            return "I";
        }
    }

public class LBox extends AbstractBox{
        
        @Override
        String getShape() {
        
            return "L";
        }
    }

public class OBox extends AbstractBox{
        
        @Override
        String getShape() {
        
            return "O";
        }
    }

public class BoxFactory {
        
        private HashMap<String,AbstractBox> map;
        private BoxFactory(){
         //在构造方法中进行初始化操作
            map= new HashMap<>();
            map.put("I",new IBox());
            map.put("L",new LBox());
            map.put("O",new OBox());
    
        }
    
        public static final BoxFactory getInstance(){
        //提供一个方法获取该工厂类对象
            return Singleton.instance;
    
        }
        private static class Singleton{
        //单例模式的静态内部类方式，对外提供静态方法获取该对象
            private static final BoxFactory instance = new BoxFactory();
        }
    
    
        //和上面代码执行流程相同，但是上面代码采用了单例模式的静态内部类方式，对外提供静态方法获取对象，下面代码存在线程安全的问题
    
        //提供一个方法获取该工厂类对象
        //    public static BoxFactory getInstance() {
        
        //        return factory;
        //    }
        //
        //    private static BoxFactory factory = new BoxFactory();
        public AbstractBox getShape(String name){
        //根据名称获取图形对象
            return map.get(name);
    
        }
    
    }

public class Client {
        
        public static void main(String[] args) {
        
            AbstractBox box1 = BoxFactory.getInstance().getShape("I");
            box1.display("grey");
            AbstractBox box2 = BoxFactory.getInstance().getShape("L");
            box2.display("red");
            AbstractBox box3 =  BoxFactory.getInstance().getShape("O");
            box3.display("green");
            AbstractBox box4 =  BoxFactory.getInstance().getShape("O");
            box4.display("white");
            System.out.println("==============");
            System.out.println(box3==box4);
    
        }
    }

Shape:I Color:grey
    Shape:L Color:red
    Shape:O Color:green
    Shape:O Color:white
    ==============
    true

# 5.优缺点 #

**优点**

*  **极大减少内存中相似或相同对象数量**，节约系统资源，提供系统性能
 *  享元模式中的外部状态相对独立，且不影响内部状态

**缺点：**

*  为了使对象可以共享，**需要将享元对象的部分状态外部化，分离内部状态和外部状态**，使程序逻辑复杂

# 6. 使用场景 #

*  一个**系统有大量相同或者相似的对象**，造成内存的大量耗费。
 *  **对象的大部分状态都可以外部化**，可以将这些**外部状态传入对象**中。
 *  在使用**享元模式时需要维护一个存储享元对象的享元池，而这需要耗费一定的系统资源，因此，应当在需要多次重复使用享元对象时才值得使用享元模式。**

# 7.源码解析 #

**Integer类使用了享元模式。**

public class Demo {
        
        public static void main(String[] args) {
        
            Integer i1 = 127;
            Integer i2 = 127;
    
            System.out.println("i1和i2对象是否是同一个对象？" + (i1 == i2));
    
            Integer i3 = 128;
            Integer i4 = 128;
    
            System.out.println("i3和i4对象是否是同一个对象？" + (i3 == i4));
        }
    }

i1和i2对象是否是同一个对象？true
    i3和i4对象是否是同一个对象？false

为什么第一个输出语句输出的是true，第二个输出语句输出的是false？通过反编译软件进行反编译

public class Demo {
        
        public static void main(String[] args) {
        
            Integer i1 = Integer.valueOf((int)127);
            Integer i2 Integer.valueOf((int)127);
            System.out.println((String)new StringBuilder().append((String)"i1\u548ci2\u5bf9\u8c61\u662f\u5426\u662f\u540c\u4e00\u4e2a\u5bf9\u8c61\uff1f").append((boolean)(i1 == i2)).toString());
            Integer i3 = Integer.valueOf((int)128);
            Integer i4 = Integer.valueOf((int)128);
            System.out.println((String)new StringBuilder().append((String)"i3\u548ci4\u5bf9\u8c61\u662f\u5426\u662f\u540c\u4e00\u4e2a\u5bf9\u8c61\uff1f").append((boolean)(i3 == i4)).toString());
        }
    }

上面代码可以看到，直接给Integer类型的变量赋值基本数据类型数据的操作底层使用的是 `valueOf()` ，所以只需要看该方法即可

public final class Integer extends Number implements Comparable<Integer> {
        
        
    	public static Integer valueOf(int i) {
        
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }
        
        private static class IntegerCache {
        
            static final int low = -128;
            static final int high;
            static final Integer cache[];
    
            static {
        
                int h = 127;
                String integerCacheHighPropValue =
                    sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
                if (integerCacheHighPropValue != null) {
        
                    try {
        
                        int i = parseInt(integerCacheHighPropValue);
                        i = Math.max(i, 127);
                        // Maximum array size is Integer.MAX_VALUE
                        h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                    } catch( NumberFormatException nfe) {
        
                    }
                }
                high = h;
                cache = new Integer[(high - low) + 1];
                int j = low;
                for(int k = 0; k < cache.length; k++)
                    cache[k] = new Integer(j++);
                // range [-128, 127] must be interned (JLS7 5.1.7)
                assert IntegerCache.high >= 127;
            }
    
            private IntegerCache() {
        }
        }
    }

[253826b35dda4b77930771a6ff7fe526.png]: https://img-blog.csdnimg.cn/253826b35dda4b77930771a6ff7fe526.png
[5286202ff1cc4712bfa570e6d874a1e6.png]: https://img-blog.csdnimg.cn/5286202ff1cc4712bfa570e6d874a1e6.png