【Java设计模式】十二、享元模式

ゝ一纸荒年。 2024-04-23 15:53 66阅读 0赞

#### 文章目录 ####

*  1、享元模式
 *  2、案例
 *  3、总结
 *  4、源码中的实际应用

## 1、享元模式 ##

就像人们偶尔想骑自行车，不用人人都买一辆自己的，共享单车就行。享元模式就是用来避免创建大量相似对象的。享元模式的内部状态，指不随环境变化的、可共享的那部分。外部状态，即不可共享的那部分。主要角色有：

*  抽象享元：一个接口或抽象类，提供方法，给外界设置外部状态（下例中的颜色），以及给外界用来获取享元对象的内部状态
 *  具体享元：实现抽象享元，单例模式为每一个具体享元类提供唯一的享元对象
 *  非享元：不能共享的对象
 *  享元工厂：创建和管理享元对象，请求一个享元对象时，查找内存中是否有这个享元对象，有则返回，无则创建并返回

## 2、案例 ##

俄罗斯方块，形状个数有限，颜色随机。不用每次都创建一个方块对象。形状共享、颜色做为外部状态  
![在这里插入图片描述][a1d7275a6b8847d182d320fc212e0929.png]  
类图：

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

先定义抽象享元类

public abstract class AbstractBox {
        
    
    	//获取图形的方法
        public abstract String getShape();
    
    	//显示图形及颜色，传入颜色
        public void display(String color) {
        
            System.out.println("方块形状：" + this.getShape() + " 颜色：" + color);
        }
    }

定义具体享元角色

//返回一个I图形的方块
    public class IBox extends AbstractBox {
        
    
        @Override
        public String getShape() {
        
            return "I";
        }
    }
    //返回一个L图形的方块
    public class LBox extends AbstractBox {
        
    
        @Override
        public String getShape() {
        
            return "L";
        }
    }
    //返回一个O图形的方块
    public class OBox extends AbstractBox {
        
    
        @Override
        public String getShape() {
        
            return "O";
        }
    }

定义工厂类，将该类设计为单例。**使用HashMap做为存储享元对象的享元池**：

public class BoxFactory {
        
    
    	//key为图形名称，value为图形对象
        private static HashMap<String, AbstractBox> map;
    
    	//初始化，构造方法私有
        private BoxFactory() {
        
            map = new HashMap<String, AbstractBox>();
            AbstractBox iBox = new IBox();
            AbstractBox lBox = new LBox();
            AbstractBox oBox = new OBox();
            map.put("I", iBox);
            map.put("L", lBox);
            map.put("O", oBox);
        }
    
    	//获取单例的工厂类对象
        public static final BoxFactory getInstance() {
        
            return SingletonHolder.INSTANCE;
        }
    
    	//静态内部类实现单例模式
        private static class SingletonHolder {
        
            private static final BoxFactory INSTANCE = new BoxFactory();
        }
    	
    	//根据名称获取图形对象
        public AbstractBox getBox(String key) {
        
            return map.get(key);
        }
    }

测试：将外部状态颜色传入对象中

public class Client {
        
        public static void main(String[] args) {
        
            AbstractBox box1 = BoxFactory.getInstance().getBox("I");
            box1.display("灰色");
            AbstractBox box2 = BoxFactory.getInstance().getBox("O");
            box1.display("白色");
            
            AbstractBox box3 = BoxFactory.getInstance().getBox("L");
            box1.display("红色");
            AbstractBox box4 = BoxFactory.getInstance().getBox("L");
            box1.display("绿色");
            System.out.println(box3 == box4);   //true，两次获取到的是同一个L对象
        }
    }

最后两次获取到的是同一个L对象，即形状是共享的

## 3、总结 ##

优点：

*  减少内存中相似对象的数量，节约空间

缺点：

*  将对象分离为内部状态和外部状态，逻辑变复杂了

适用场景：

*  系统中有大量的相似对象

## 4、源码中的实际应用 ##

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));
        }
    }

以上运行结果：

true
    false

反编译发现：

Integer i1 = 127;

结果是：

Integer i1 = Integer.valueOf((int)127);

跟进valueOf方法，发现**Integer默认创建并缓存-128~127之间的Integer对象到一个Integer cache\[ \] 数组中，当调用valueOf方法，且值在这个范围内，则从数组缓存中返回Integer对象共享**，否则新创建Integer对象，因此，前者结果为true。

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() {
        }
        }
    }

[a1d7275a6b8847d182d320fc212e0929.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/c6150c6d93db4840a52df5e03a2c49f4.png
[a8d11f5747e24ada85305c1f8e4930e3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/0d4282a29b464f8bba8fac7097f0f603.png