• 设计模式——组合模式、享元模式（Integer缓存）（结构型模式）

    1.组合模式

    组合模式主要包含三种角色：

    • 抽象根节点（Component）：定义系统各层次对象的共有方法和属性，可以预先定义一些默认行为和属性。

    • 树枝节点（Composite）：定义树枝节点的行为，存储子节点，组合树枝节点和叶子节点形成一个树形结构。

    • 叶子节点（Leaf）：叶子节点对象，其下再无分支，是系统层次遍历的最小单位。

     

    抽象根节点：

    1. //菜单组件：抽象根节点
    2. //不管是菜单还是菜单项，都应该继承该类
    3. public abstract class MenuComponent {
    4.  
    5.     protected String name;
    6.     protected int level;
    7.  
    8.     public MenuComponent(String name, int level) {
    9.         this.name = name;
    10.         this.level = level;
    11.     }
    12.  
    13.     //添加菜单
    14.     public void add(MenuComponent menuComponent){
    15.         throw new UnsupportedOperationException();
    16.     }
    17.  
    18.     //移除菜单
    19.     public void remove(MenuComponent menuComponent){
    20.         throw new UnsupportedOperationException();
    21.     }
    22.  
    23.     //获取指定的子菜单
    24.     public MenuComponent getChild(int i){
    25.         throw new UnsupportedOperationException();
    26.     }
    27.  
    28.     //获取菜单名称
    29.     public String getName(){
    30.         return name;
    31.     }
    32.  
    33.     public void print(){
    34.         throw new UnsupportedOperationException();
    35.     }
    36. }

    树枝节点：

    1. import java.util.ArrayList;
    2. import java.util.List;
    3.  
    4. //菜单：树枝节点
    5. public class Menu extends MenuComponent {
    6.  
    7.     private List menuComponentList;
    8.  
    9.     public Menu(String name, int level) {
    10.         super(name, level);
    11.         menuComponentList = new ArrayList();
    12.     }
    13.  
    14.     @Override
    15.     public void add(MenuComponent menuComponent) {
    16.         menuComponentList.add(menuComponent);
    17.     }
    18.  
    19.     @Override
    20.     public void remove(MenuComponent menuComponent) {
    21.         menuComponentList.remove(menuComponent);
    22.     }
    23.  
    24.     @Override
    25.     public MenuComponent getChild(int i) {
    26.         return menuComponentList.get(i);
    27.     }
    28.  
    29.     @Override
    30.     public void print() {
    31.         for (int i = 1; i < level; i++) {
    32.             System.out.print("--");
    33.         }
    34.         System.out.println(name);
    35.         for (MenuComponent menuComponent : menuComponentList) {
    36.             menuComponent.print();
    37.         }
    38.     }
    39. }

    叶子节点：

    1. //菜单项：叶子节点
    2. public class MenuItem extends MenuComponent {
    3.  
    4.     public MenuItem(String name, int level) {
    5.         super(name, level);
    6.     }
    7.  
    8.     @Override
    9.     public void print() {
    10.         for (int i = 1; i < level; i++) {
    11.             System.out.print("--");
    12.         }
    13.         System.out.println(name);
    14.     }
    15. }

    测试类：

    1. public class Client {
    2.     public static void main(String[] args) {
    3.         //创建菜单树
    4.  
    5.         //创建一级菜单
    6.         MenuComponent component = new Menu("系统管理", 1);
    7.         //创建二级菜单
    8.         MenuComponent menu1 = new Menu("菜单管理", 2);
    9.         component.add(menu1);
    10.         //创建三级菜单
    11.         menu1.add(new MenuItem("页面访问", 3));
    12.         menu1.add(new MenuItem("展开菜单", 3));
    13.         menu1.add(new MenuItem("编辑菜单", 3));
    14.         menu1.add(new MenuItem("删除菜单", 3));
    15.         menu1.add(new MenuItem("新增菜单", 3));
    16.  
    17.         MenuComponent menu2 = new Menu("权限管理", 2);
    18.         component.add(menu2);
    19.         menu2.add(new MenuItem("页面访问", 3));
    20.         menu2.add(new MenuItem("提交保存", 3));
    21.  
    22.         MenuComponent menu3 = new Menu("角色管理", 2);
    23.         component.add(menu3);
    24.         menu3.add(new MenuItem("页面访问", 3));
    25.         menu3.add(new MenuItem("新增角色", 3));
    26.         menu3.add(new MenuItem("修改角色", 3));
    27.  
    28.         //打印菜单
    29.         component.print();
    30.     }
    31. }

    组合模式的分类

    在使用组合模式时，根据抽象构件类的定义形式，我们可将组合模式分为透明组合模式和安全组合模式两种形式。

    • 透明组合模式

      透明组合模式中，抽象根节点角色中声明了所有用于管理成员对象的方法，比如在示例中 MenuComponent 声明了 add、remove 、getChild 方法，这样做的好处是确保所有的构件类都有相同的接口。透明组合模式也是组合模式的标准形式。

      透明组合模式的缺点是不够安全，因为叶子对象和容器对象在本质上是有区别的，叶子对象不可能有下一个层次的对象，即不可能包含成员对象，因此为其提供 add()、remove() 等方法是没有意义的，这在编译阶段不会出错，但在运行阶段如果调用这些方法可能会出错（如果没有提供相应的错误处理代码）

    • 安全组合模式

      在安全组合模式中，在抽象构件角色中没有声明任何用于管理成员对象的方法，而是在树枝节点 Menu 类中声明并实现这些方法。安全组合模式的缺点是不够透明，因为叶子构件和容器构件具有不同的方法，且容器构件中那些用于管理成员对象的方法没有在抽象构件类中定义，因此客户端不能完全针对抽象编程，必须有区别地对待叶子构件和容器构件。

    2.享元模式

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

    1. 内部状态，即不会随着环境的改变而改变的可共享部分。

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

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

    • 抽象享元角色（Flyweight）：通常是一个接口或抽象类，在抽象享元类中声明了具体享元类公共的方法，这些方法可以向外界提供享元对象的内部数据（内部状态），同时也可以通过这些方法来设置外部数据（外部状态）。

    • 具体享元（Concrete Flyweight）角色 ：它实现了抽象享元类，称为享元对象；在具体享元类中为内部状态提供了存储空间。通常我们可以结合单例模式来设计具体享元类，为每一个具体享元类提供唯一的享元对象。

    • 非享元（Unsharable Flyweight)角色 ：并不是所有的抽象享元类的子类都需要被共享，不能被共享的子类可设计为非共享具体享元类；当需要一个非共享具体享元类的对象时可以直接通过实例化创建。

    • 享元工厂（Flyweight Factory）角色 ：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。

    抽象享元角色：

    1. //抽象享元
    2. public abstract class AbstractBox {
    3.  
    4.     public abstract String getShape();
    5.  
    6.     public void display(String color) {//外部状态
    7.         System.out.println("方块形状：" + this.getShape() + " 颜色：" + color);
    8.     }
    9. }

    具体享元：

    1. //具体享元
    2. public class IBox extends AbstractBox {
    3.     @Override
    4.     public String getShape() {
    5.         return "I";
    6.     }
    7. }
    8.  
    9. //具体享元
    10. public class LBox extends AbstractBox {
    11.  
    12.     @Override
    13.     public String getShape() {
    14.         return "L";
    15.     }
    16. }
    17.  
    18. //具体享元
    19. public class OBox extends AbstractBox {
    20.  
    21.     @Override
    22.     public String getShape() {
    23.         return "O";
    24.     }
    25. }

    享元工厂：

    1. import java.util.HashMap;
    2.  
    3. //享元工厂
    4. public class BoxFactory {
    5.  
    6.     private static HashMap map;
    7.  
    8.     //单例：构造方法私有
    9.     private BoxFactory() {
    10.         map = new HashMap();
    11.         AbstractBox iBox = new IBox();
    12.         AbstractBox lBox = new LBox();
    13.         AbstractBox oBox = new OBox();
    14.         map.put("I", iBox);
    15.         map.put("L", lBox);
    16.         map.put("O", oBox);
    17.     }
    18.  
    19.     //单例：外部访问接口
    20.     public static final BoxFactory getInstance() {
    21.         return SingletonHolder.INSTANCE;
    22.     }
    23.  
    24.     //单例：静态内部类
    25.     private static class SingletonHolder {
    26.         private static final BoxFactory INSTANCE = new BoxFactory();
    27.     }
    28.  
    29.     public AbstractBox getBox(String key) {
    30.         return map.get(key);
    31.     }
    32. }

    测试类：

    1. public class Client {
    2.     public static void main(String[] args) {
    3.         //获取享元工厂对象
    4.         BoxFactory boxFactory = BoxFactory.getInstance();
    5.  
    6.         //获取I图形对象
    7.         AbstractBox IBox = boxFactory.getBox("I");
    8.         IBox.display("red");
    9.  
    10.         //获取L图形对象
    11.         AbstractBox LBox = boxFactory.getBox("L");
    12.         LBox.display("yellow");
    13.  
    14.         //获取O图形对象
    15.         AbstractBox Obox = boxFactory.getBox("O");
    16.         Obox.display("green");
    17.         AbstractBox Obox2 = boxFactory.getBox("O");
    18.         Obox2.display("orange");
    19.         System.out.println(Obox == Obox2);//true
    20.  
    21.     }
    22. }

    1，优点

    • 极大减少内存中相似或相同对象数量，节约系统资源，提供系统性能

    • 享元模式中的外部状态相对独立，且不影响内部状态

    2，缺点：

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

    使用场景

    • 一个系统有大量相同或者相似的对象，造成内存的大量耗费。

    • 对象的大部分状态都可以外部化，可以将这些外部状态传入对象中。

    • 在使用享元模式时需要维护一个存储享元对象的享元池，而这需要耗费一定的系统资源，因此，应当在需要多次重复使用享元对象时才值得使用享元模式。

    Integer详解

    1. public class Demo {
    2.     public static void main(String[] args) {
    3.         Integer i1 = 127;
    4.         Integer i2 = 127;
    5.         System.out.println(i1 == i2);//true
    6.  
    7.         Integer i3 = 128;
    8.         Integer i4 = 128;
    9.         System.out.println(i3 == i4);//false
    10.     }
    11. }

    反编译后：

    1. public class Demo {
    2.     public static void main(String[] args) {
    3.         Integer i1 = Integer.valueOf((int)127);
    4.         Integer i2 Integer.valueOf((int)127);
    5.         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());
    6.         Integer i3 = Integer.valueOf((int)128);
    7.         Integer i4 = Integer.valueOf((int)128);
    8.         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());
    9.     }
    10. }

    Integer中valueOf(int i)的源码：

    1. public final class Integer extends Number implements Comparable {
    2.     
    3. 	public static Integer valueOf(int i) {
    4.         if (i >= IntegerCache.low && i <= IntegerCache.high)
    5.             return IntegerCache.cache[i + (-IntegerCache.low)];//根据数组索引拿值
    6.         return new Integer(i);
    7.     }
    8.     
    9.     private static class IntegerCache {
    10.         static final int low = -128;
    11.         static final int high;//静态代码块中赋值为127
    12.         static final Integer cache[];
    13.  
    14.         static {
    15.             int h = 127;
    16.             String integerCacheHighPropValue =
    17.                 sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
    18.             if (integerCacheHighPropValue != null) {
    19.                 try {
    20.                     int i = parseInt(integerCacheHighPropValue);
    21.                     i = Math.max(i, 127);
    22.                     // Maximum array size is Integer.MAX_VALUE
    23.                     h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
    24.                 } catch( NumberFormatException nfe) {
    25.                 }
    26.             }
    27.             high = h;
    28.             cache = new Integer[(high - low) + 1];
    29.             int j = low;
    30.             for(int k = 0; k < cache.length; k++)
    31.                 cache[k] = new Integer(j++);
    32.             // range [-128, 127] must be interned (JLS7 5.1.7)
    33.             assert IntegerCache.high >= 127;
    34.         }
    35.  
    36.         private IntegerCache() {}
    37.     }
    38. }


    可以看到 Integer 默认先创建并缓存 -128 ~ 127 之间数的 Integer 对象，当调用 valueOf 时如果参数在 -128 ~ 127 之间则计算下标并从缓存中返回，否则创建一个新的 Integer 对象。

  • 相关阅读:
    项目启动 | 盘古信息助力鼎阳科技开启智能制造升级新征程
    SkiaSharp 之 WPF 自绘 粒子花园（案例版）
    成功上岸，刚转行自学Python的小姑娘，每个月入1W+......
    The Cherno——OpenGL
    PXE操作过程 kickstart 无人值守安装
    页面功能并不是所有用户都能执行 点击判断用户权限路由是否进行跳转
    java计算机毕业设计物流企业健康管理系统源代码+数据库+系统+lw文档
    如何将Python文件生成bat脚本，点击bat自动运行Python脚本
    middlebury立体匹配评估使用方法总结（二）——python版离线教程
    【敬伟ps教程】制图操作
  • 原文地址：https://blog.csdn.net/m0_63544124/article/details/126024759