万字解析设计模式之组合模式、亨元模式

一、组合模式

1.1概述

组合模式是一种结构型设计模式，它允许将对象组合成树形结构，以表示“部分-整体”的层次结构。组合模式使得客户端可以一致地对待单个对象和对象组合，从而将复杂的层次结构展现为一个统一的树形结构。

在组合模式中，一般会定义一个抽象类或接口来表示组合中的所有对象，包括叶子对象和容器对象；叶子对象表示树形结构中的最底层节点，容器对象表示树形结构中的分支节点，同时容器对象可以包含叶子对象或其他容器对象。

组合模式能够有效地简化代码结构，提高代码的可维护性和可扩展性，同时也具有良好的透明性和灵活性。在实际编程中，组合模式广泛应用于树形结构的处理、图形绘制、文件系统等领域。

对于这个图片肯定会非常熟悉，上图我们可以看做是一个文件系统，对于这样的结构我们称之为树形结构。在树形结构中可以通过调用某个方法来遍历整个树，当我们找到某个叶子节点后，就可以对叶子节点进行相关的操作。可以将这颗树理解成一个大的容器，容器里面包含很多的成员对象，这些成员对象即可是容器对象也可以是叶子对象。但是由于容器对象和叶子对象在功能上面的区别，使得我们在使用的过程中必须要区分容器对象和叶子对象，但是这样就会给客户带来不必要的麻烦，作为客户而已，它始终希望能够一致的对待容器对象和叶子对象。

 1.2结构

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

  • 抽象根节点（Component）：定义系统各层次对象的共有方法和属性，定义组合中所有对象的通用接口，可以是抽象类或接口，包含了组合对象和叶子对象的公共操作。
  • 树枝节点（Composite）：定义树枝节点的行为，存储子节点，组合树枝节点和叶子节点形成一个树形结构。表示组合对象，包含了一个子对象的集合，并实现了抽象构件中的公共操作。
  • 叶子节点（Leaf）：叶子节点对象，其下再无分支，是系统层次遍历的最小单位。

1.3实现

软件菜单

如下图，我们在访问别的一些管理系统时，经常可以看到类似的菜单。一个菜单可以包含菜单项（菜单项是指不再包含其他内容的菜单条目），也可以包含带有其他菜单项的菜单，因此使用组合模式描述菜单就很恰当，我们的需求是针对一个菜单，打印出其包含的所有菜单以及菜单项的名称。

要实现该案例，我们先画出类图：

 抽象构件角色（抽象根节点）

package com.yanyu.Component;//菜单组件  不管是菜单还是菜单项，都应该继承该类
public abstract class MenuComponent {protected String name;protected int level;//添加菜单public void add(MenuComponent menuComponent){throw new UnsupportedOperationException();}//移除菜单public void remove(MenuComponent menuComponent){throw new UnsupportedOperationException();}//获取指定的子菜单public MenuComponent getChild(int i){throw new UnsupportedOperationException();}//获取菜单名称public String getName(){return name;}//打印菜单public void print(){throw new UnsupportedOperationException();}
}

 树枝节点（组合部件）

package com.yanyu.Component;import java.util.ArrayList;
import java.util.List;//菜单类，继承自菜单组件
public class Menu extends MenuComponent {private List<MenuComponent> menuComponentList;//构造函数public Menu(String name, int level){this.level = level;this.name = name;menuComponentList = new ArrayList<MenuComponent>();}//添加菜单项或子菜单@Overridepublic void add(MenuComponent menuComponent) {menuComponentList.add(menuComponent);}//移除菜单项或子菜单@Overridepublic void remove(MenuComponent menuComponent) {menuComponentList.remove(menuComponent);}//获取指定的子菜单@Overridepublic MenuComponent getChild(int i) {return menuComponentList.get(i);}//打印菜单及子菜单@Overridepublic void print() {for (int i = 1; i < level; i++) {System.out.print("--");}System.out.println(name);for (MenuComponent menuComponent : menuComponentList) {menuComponent.print();}}
}

叶子节点（叶子构件）

package com.yanyu.Component;//菜单项类，继承自菜单组件
public class MenuItem extends MenuComponent {//构造函数public MenuItem(String name, int level) {this.name = name;this.level = level;}//打印菜单项@Overridepublic void print() {for (int i = 1; i < level; i++) {System.out.print("--");}System.out.println(name);}
}

客户端类

package com.yanyu.Component;public class Client {public static void main(String[] args) {//创建菜单树MenuComponent menu1 = new Menu("菜单管理", 2);menu1.add(new MenuItem("页面访问", 3));menu1.add(new MenuItem("展开菜单", 3));menu1.add(new MenuItem("编辑菜单", 3));menu1.add(new MenuItem("删除菜单", 3));menu1.add(new MenuItem("新增菜单", 3));MenuComponent menu2 = new Menu("权限管理", 2);menu2.add(new MenuItem("页面访问", 3));menu2.add(new MenuItem("提交保存", 3));MenuComponent menu3 = new Menu("角色管理", 2);menu3.add(new MenuItem("页面访问", 3));menu3.add(new MenuItem("新增角色", 3));menu3.add(new MenuItem("修改角色", 3));//创建一级菜单MenuComponent component = new Menu("系统管理", 1);component.add(menu1);component.add(menu2);component.add(menu3);component.print();}
}

  • 组合模式可以清楚地定义分层次的复杂对象，表示对象的全部或部分层次，它让客户端忽略了层次的差异，方便对整个层次结构进行控制。
  • 客户端可以一致地使用一个组合结构或其中单个对象，不必关心处理的是单个对象还是整个组合结构，简化了客户端代码。
  • 在组合模式中增加新的树枝节点和叶子节点都很方便，无须对现有类库进行任何修改，符合“开闭原则”。
  • 组合模式为树形结构的面向对象实现提供了一种灵活的解决方案，通过叶子节点和树枝节点的递归组合，可以形成复杂的树形结构，但对树形结构的控制却非常简单。 

 1.4组合模式的分类

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

  • 透明组合模式

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

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

  • 安全组合模式

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

1.5使用场景

  • 如果你需要实现树状对象结构， 可以使用组合模式。

组合模式为你提供了两种共享公共接口的基本元素类型： 简单叶节点和复杂容器。 容器中可以包含叶节点和其他容器。 这使得你可以构建树状嵌套递归对象结构。

  • 如果你希望客户端代码以相同方式处理简单和复杂元素， 可以使用该模式。

组合模式中定义的所有元素共用同一个接口。 在这一接口的帮助下， 客户端不必在意其所使用的对象的具体类。

组合模式正是应树形结构而生，所以组合模式的使用场景就是出现树形结构的地方。比如：文件目录显示，多级目录呈现等树形结构数据的操作。

二、享元模式 

2.1概述

享元模式是一种结构型设计模式，旨在减少内存占用和提高性能。它将对象分解为可共享的和不可共享的部分。可共享的部分是多个对象共有的、不变的部分，它们可以被多个对象共享使用，从而减少内存占用。不可共享的部分是对象不同的、可变的部分，每个对象各自拥有不同的副本。

通过应用享元模式，我们可以大幅度减少系统中的对象数量，提高系统的性能和响应速度。然而，享元模式会增加程序的复杂性和开发难度，因为需要将对象分解为可共享和不可共享的部分，并维护对象的共享池。因此，需要在实际应用中根据具体情况进行权衡和取舍。

定义

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

2.2结构

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

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

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

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

2.3实现

【例】俄罗斯方块

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

先来看类图：

抽象享元

package com.yanyu.Flyweight;// 抽象享元类
public abstract class AbstractBox {// 声明一个抽象方法，用于获取方块形状public abstract String getShape();// 实现一个公共方法，用于显示方块的形状和颜色public void display(String color) {System.out.println("方块形状：" + this.getShape() + " 颜色：" + color);}
}

具体亨元

package com.yanyu.Flyweight;/*** IBox是一个继承自AbstractBox的类。* 它代表一个I形状的方块。*/
public class IBox extends AbstractBox {/*** 重写了AbstractBox中的getShape方法。* 返回"I"表示这个方块是一个I形状的方块。*/@Overridepublic String getShape() {return "I";}
}

package com.yanyu.Flyweight;public class LBox extends AbstractBox {@Overridepublic String getShape() {return "L";}
}
package com.yanyu.Flyweight;public class OBox extends AbstractBox {@Overridepublic String getShape() {return "O";}
}

享元工厂

package com.yanyu.Flyweight;import java.util.HashMap;// 创建一个BoxFactory类
public class BoxFactory {// 创建一个静态的HashMap用于存储不同类型的AbstractBoxprivate static HashMap<String, AbstractBox> map;// 私有构造函数，初始化HashMap并将不同类型的AbstractBox放入其中private BoxFactory() {map = new HashMap<String, AbstractBox>();AbstractBox iBox = new IBox(); // 创建IBox对象AbstractBox lBox = new LBox(); // 创建LBox对象AbstractBox oBox = new OBox(); // 创建OBox对象map.put("I", iBox); // 将IBox对象放入HashMapmap.put("L", lBox); // 将LBox对象放入HashMapmap.put("O", oBox); // 将OBox对象放入HashMap}// 创建一个静态内部类SingletonHolder用于实现单例模式private static class SingletonHolder {private static final BoxFactory INSTANCE = new BoxFactory(); // 创建BoxFactory的单例实例}// 获取BoxFactory的实例public static final BoxFactory getInstance() {return SingletonHolder.INSTANCE; // 返回BoxFactory的单例实例}// 根据key获取对应的AbstractBoxpublic AbstractBox getBox(String key) {return map.get(key); // 根据key从HashMap中获取对应的AbstractBox对象}
}

客户端类

package com.yanyu.Flyweight;public class Client {public static void main(String[] args) {AbstractBox box1 = BoxFactory.getInstance().getBox("I");box1.display("灰色");AbstractBox box2 = BoxFactory.getInstance().getBox("L");box2.display("绿色");AbstractBox box3 = BoxFactory.getInstance().getBox("O");box3.display("灰色");// 再次获取相同的图形对象AbstractBox box4 = BoxFactory.getInstance().getBox("O");box4.display("红色");System.out.println("再次获取到的图形对象是否是同一个对象: " + (box3 == box4));}
}

2.4 优缺点

1，优点

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

2，缺点：

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

2.5应用场景

  1. 仅在程序必须支持大量对象且没有足够的内存容量时使用享元模式。

  2. 应用该模式所获的收益大小取决于使用它的方式和情景。 它在下列情况中最有效：

  • 程序需要生成数量巨大的相似对象
  • 这将耗尽目标设备的所有内存
  • 对象中包含可抽取且能在多个对象间共享的重复状态。

2.6 JDK源码解析

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

运行上面代码，结果如下：

 三、组合模式实验

任务描述

使用组合模式设计一个杀毒软件（AntiVirus）的框架，该软件既可以对某个文件夹（Folder）杀毒，也可以对某个指定的文件（File）进行杀毒，文件种类包括文本文件 TextFile，图片文件 ImageFile、视频文件 VideoFile。

本关任务：根据 UML 类图编程模拟实现。

,

实现方式

  1. 确保应用的核心模型能够以树状结构表示。 尝试将其分解为简单元素和容器。 记住， 容器必须能够同时包含简单元素和其他容器。

  2. 声明组件接口及其一系列方法， 这些方法对简单和复杂元素都有意义。

  3. 创建一个叶节点类表示简单元素。 程序中可以有多个不同的叶节点类。

  4. 创建一个容器类表示复杂元素。 在该类中， 创建一个数组成员变量来存储对于其子元素的引用。 该数组必须能够同时保存叶节点和容器， 因此请确保将其声明为组合接口类型。实现组件接口方法时， 记住容器应该将大部分工作交给其子元素来完成。

  5. 最后， 在容器中定义添加和删除子元素的方法。

记住，这些操作可在组件接口中声明。 这将会违反接口隔离原则，因为叶节点类中的这些方法为空。 但是，这可以让客户端无差别地访问所有元素， 即使是组成树状结构的元素。

编程要求

根据提示，在右侧编辑器 Begin-End 内补充 "AbstractFile.java" 和 "Folder.java" 文件代码，其它文件不需要修

抽象构建

package step1;
//抽象文件类:抽象构件
/********** Begin *********/public abstract class AbstractFile {public abstract void add(AbstractFile file);public abstract void remove(AbstractFile file);public abstract void scan();
}/********** End *********/

组合部件

package step1;import java.util.ArrayList;
import java.util.List;// 文件夹类，属于组合模式中的容器构件
public class Folder extends AbstractFile {private String name; // 文件夹名称private List<AbstractFile> files = new ArrayList<>(); // 存储文件夹中的文件或子文件夹public Folder(String name) {this.name = name;}// 添加文件或子文件夹public void add(AbstractFile file) {files.add(file);}// 移除文件或子文件夹public void remove(AbstractFile file) {files.remove(file);}// 获取子文件或子文件夹public AbstractFile getChild(int i) {return files.get(i);}// 扫描文件夹public void scan() {System.out.println("开始扫描文件夹：" + name); // 打印扫描文件夹的信息for (AbstractFile file : files) {file.scan(); // 调用子文件或子文件夹的扫描方法}}
}

叶子构建

package step1;//图片文件类:叶子构件
public class ImageFile extends AbstractFile{private String fileName;public ImageFile(String fileName){this.fileName = fileName;}@Overridepublic void add(AbstractFile element) {System.out.println("对不起，不支持该方法");}@Overridepublic void remove(AbstractFile element) {System.out.println("对不起，不支持该方法");}@Overridepublic void scan() {System.out.println("扫描图片文件:"+fileName);}
}

package step1;//文本文件类:叶子构件
public class TextFile extends  AbstractFile{private String fileName;public TextFile(String fileName){this.fileName = fileName;}@Overridepublic void add(AbstractFile element) {System.out.println("对不起，不支持该方法");}@Overridepublic void remove(AbstractFile element) {System.out.println("对不起，不支持该方法");}@Overridepublic void scan() {System.out.println("扫描文本文件:"+fileName);}
}

package step1;//视频文件类:叶子构件
public class VideoFile extends AbstractFile{private String fileName;public VideoFile(String fileName){this.fileName = fileName;}@Overridepublic void add(AbstractFile element) {System.out.println("对不起，不支持该方法");}@Overridepublic void remove(AbstractFile element) {System.out.println("对不起，不支持该方法");}@Overridepublic void scan() {System.out.println("扫描视频文件:"+fileName);}
}

客户端类

// 定义客户端类
package step1;public class Client {public static void main(String[] args) {// 创建文件和文件夹对象AbstractFile file1, file2, file3, file4, file5, folder1, folder2, folder3;// 创建各种类型的文件对象file1 = new ImageFile("pic1.gif");file2 = new ImageFile("pic2.jpg");file3 = new TextFile("txt1.txt");file4 = new TextFile("txt2.doc");file5 = new VideoFile("video1.rmvb");// 创建文件夹对象folder1 = new Folder("图片文件夹");folder1.add(file1); // 将图片文件添加到图片文件夹中folder1.add(file2);folder2 = new Folder("文本文件夹");folder2.add(file3); // 将文本文件添加到文本文件夹中folder2.add(file4);folder3 = new Folder("个人资料");folder3.add(file5); // 将视频文件添加到个人资料文件夹中folder3.add(folder1); // 将图片文件夹添加到个人资料文件夹中folder3.add(folder2); // 将文本文件夹添加到个人资料文件夹中// 扫描文件夹folder3.scan(); // 调用文件夹的扫描方法，实现对整个文件夹结构的扫描}
}

四、享元模式 实验

任务描述

在一个虚拟仿真程序中需要渲染一片森林 （1,000,000 棵树）！ 每棵树对象都包含一些状态（品种名 name，屏幕坐标 x,屏幕坐标 y,颜色 color，其它附带数据 otherTreeData）。

本关任务：太多树对象包含重复数据，因此我们可用享元模式来将这些数值存储在单独的享元对象中（TreeType 类）。请分析“树”的状态中哪些是外在状态，哪些是内部状态，然后补全代码。

实现方式

  1. 将需要改写为享元的类成员变量拆分为两个部分：内在状态，包含不变的、 可在许多对象中重复使用的数据的成员变量。外在状态， 包含每个对象各自不同的情景数据的成员变量；

  2. 保留类中表示内在状态的成员变量， 并将其属性设置为不可修改。 这些变量仅可在构造函数中获得初始数值；

  3. 找到所有使用外在状态成员变量的方法， 为在方法中所用的每个成员变量新建一个参数， 并使用该参数代替成员变量；

  4. 你可以有选择地创建工厂类来管理享元缓存池， 它负责在新建享元时检查已有的享元。 如果选择使用工厂， 客户端就只能通过工厂来请求享元， 它们需要将享元的内在状态作为参数传递给工厂；

  5. 客户端必须存储和计算外在状态 （情景） 的数值， 因为只有这样才能调用享元对象的方法。 为了使用方便， 外在状态和引用享元的成员变量可以移动到单独的情景类中。

编程提示

TreeType.java ：内在状态享元类； Tree.java：树对象类； TreeFactory.java：内在状态享元工厂类； Forest.java：森林对象类。

本地 windows 系统调式时，可将图形代码恢复，观看实际效果。提交测试时，务必屏蔽图形代码

编程要求

根据提示，在右侧编辑器 Begin-End 内补充 “Tree.java”,“TreeType.java” 和 “TreeFactory.java” 文件的代码（其它文件不需要更改），计算对比，优化前后分别占用的内存数。

抽象享元

import java.awt.*;public class Tree {// 享元对象和外在状态private int x; // 外在状态：树的x坐标private int y; // 外在状态：树的y坐标private TreeType type; // 享元对象：树的类型// 构造方法public Tree(int x, int y, TreeType type) {this.x = x;this.y = y;this.type = type;}public void draw(Graphics g) {type.draw(g, x, y); // 调用享元对象的绘制方法}
}

import java.awt.*;public class TreeType {/********** 内在状态 *********/// 内在状态private String name; // 树的名称private Color color; // 树的颜色private String texture; // 树的纹理/********** End *********//********** 构造方法 *********/public TreeType(String name, Color color, String texture) {this.name = name;this.color = color;this.texture = texture;}/********** End *********/public void draw(Graphics g, int x, int y) {//本地测试时，可使用图形化代码/*g.setColor(Color.BLACK);g.fillRect(x - 1, y, 3, 5);g.setColor(color);g.fillOval(x - 5, y - 10, 10, 10);*/}
}

享元工厂

import java.awt.*;
import java.util.HashMap;
import java.util.Map;public class TreeFactory {private Map<String, TreeType> treeTypes = new HashMap<>();public TreeType getTreeType(String name, Color color, String texture) {String key = name + color + texture; // 内在状态的唯一关键字参数TreeType result = treeTypes.get(key);if (result == null) {// 创建一个享元对象result = new TreeType(name, color, texture);// 将新的享元对象放入对象池中treeTypes.put(key, result);}return result;}public int getTotalTreetype() {return treeTypes.size();}
}

在上述代码中，`treeTypes.get(key)`和`treeTypes.put(key, result)`是享元模式中的关键操作。具体解释如下：

- `treeTypes.get(key)`: 这行代码用于从对象池中获取具有特定内在状态的享元对象。在这里，我们使用`key`作为唯一的标识符来检索享元对象。如果对象池中已经存在具有相同内在状态的享元对象，则直接返回该对象；否则返回null。

- `treeTypes.put(key, result)`: 这行代码用于将新创建的享元对象放入对象池中。如果对象池中不存在具有相同内在状态的享元对象，那么我们需要将新创建的享元对象放入对象池中，以便后续重复使用。

这两行代码共同实现了享元模式中的对象共享和复用，通过对象池管理和重复利用享元对象，以节省内存和提高性能。

import javax.swing.*;
import java.awt.*;
import java.util.ArrayList;
import java.util.List;public class Forest /*extends JFrame*/ {private List<Tree> trees = new ArrayList<>(); // 存储森林中的树private TreeFactory treeFactory; // 树工厂对象，用于创建和管理树的类型public Forest(TreeFactory treeFactory) {this.treeFactory = treeFactory;}// 添加树到森林中public void plantTree(int x, int y, String name, Color color, String otherTreeData) {// 从树工厂中获取树的类型TreeType type = treeFactory.getTreeType(name, color, otherTreeData);// 创建树对象并添加到森林中Tree tree = new Tree(x, y, type);trees.add(tree);}// 获取森林中的树的数量public int getTotalTree() {return trees.size();}// 获取树工厂中的树的类型数量public int getTotalTreetype() {return treeFactory.getTotalTreetype();}//@Override// 本地测试时,可继承JFrame类，并恢复以下图形化代码/*public void paint(Graphics graphics) {for (Tree tree : trees) {tree.draw(graphics);}}*/
}

客户端类

import java.awt.*;// 客户端类，用于测试和演示
public class Client {// 画布大小static int CANVAS_SIZE = 500;// 需要绘制的树的数量static int TREES_TO_DRAW = 1000000;// 树的类型数量static int TREE_TYPES = 2;public static void main(String[] args) {// 创建树工厂TreeFactory factory = new TreeFactory();// 创建森林Forest forest = new Forest(factory);// 根据树的类型数量和需要绘制的树的数量，随机生成不同类型的树并添加到森林中for (int i = 0; i < Math.floor(TREES_TO_DRAW / TREE_TYPES); i++) {// 随机生成夏季橡树并添加到森林中forest.plantTree(random(0, CANVAS_SIZE), random(0, CANVAS_SIZE),"Summer Oak", Color.GREEN, "Oak texture stub");// 随机生成秋季橡树并添加到森林中forest.plantTree(random(0, CANVAS_SIZE), random(0, CANVAS_SIZE),"Autumn Oak", Color.ORANGE, "Autumn Oak texture stub");}// 输出绘制的树的数量System.out.println(forest.getTotalTree() + " trees drawn");// 输出内存使用情况System.out.println("Memory usage:");System.out.println("Tree size (8 bytes) * " + forest.getTotalTree());System.out.println("+ TreeTypes size (~30 bytes) * " + forest.getTotalTreetype() + "");System.out.println("Total: " + ((forest.getTotalTree() * 8 + forest.getTotalTreetype() * 30) / 1024 / 1024) +"MB (instead of " + ((forest.getTotalTree() * 38) / 1024 / 1024) + "MB)");}// 生成指定范围内的随机数private static int random(int min, int max) {return min + (int) (Math.random() * ((max - min) + 1));}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/159761.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

设计模式-16-Spring源码中的设计模式

设计模式-16-Spring源码中的设计模式

1-Spring之观察者模式 Java、Google Guava都提供了观察者模式的实现框架。Java提供的框架比较简单&#xff0c;只包含java.util.Observable和java.util.Observer两个类。Google Guava提供的框架功能比较完善和强大&#xff1a;通过EventBus事件总线来实现观察者模式。实际上&am…
阅读更多...
表格制作软件排行榜，热门做表格的软件推荐

表格制作软件排行榜，热门做表格的软件推荐

在数字化时代&#xff0c;表格不仅仅是企业管理和数据整理的重要工具&#xff0c;更是学术研究、项目规划以及日常生活中必不可少的一部分。为了更高效地进行表格制作&#xff0c;选择一款优秀的表格制作软件是至关重要的。在众多的软件中&#xff0c;我们特别推荐一款备受好评…
阅读更多...
java.lang.IllegalStateException: Can not add resource

java.lang.IllegalStateException: Can not add resource

安卓解决 java.lang.IllegalStateException: Can not add resource 放两个链接 解决Can not add resource (com.android.aaptcompiler.ParsedResourcea980fbb) to table_言并肃的博客-CSDN博客 android attr何时会冲突_android attr冲突-CSDN博客 然后去新增的依赖找资源…
阅读更多...
（01）vite 从启动服务器开始

（01）vite 从启动服务器开始

文章目录 前言在浏览器中使用es模块初始化环境vite依赖预构建解决了什么问题创建vite.config.js配置vite为什么vite.config.js可以用esmodule规范 前言 Vite&#xff08;发音为"veet"&#xff09;是一种现代化的前端构建工具&#xff0c;旨在提供快速的开发体验。它…
阅读更多...
【Java】用Java库中自带的阻塞队列以及用阻塞队列实现生产者-消费者模型

【Java】用Java库中自带的阻塞队列以及用阻塞队列实现生产者-消费者模型

1、阻塞队列(BlockingDeque) 首先我们来认识一下什么是堵塞队列 阻塞队列即实现了线程安全和阻塞的队列。在队列为空时&#xff0c;获取元素的线程会等待队列存放元素变为非空&#xff1b;在队列满时&#xff0c;存放元素的线程会等待队列取出元素变为不满。 阻塞队列常应用于生…
阅读更多...
盖雅绩效应用通过SAP认证并斩获创新方案奖

盖雅绩效应用通过SAP认证并斩获创新方案奖

近日&#xff0c;在「不啻微芒 造炬成阳」为主题的SAP合作伙伴创新大赛上&#xff0c;盖雅工场「G移动绩效创新方案」荣获创新解决方案奖。该方案核心是一款基于SAP SuccessFactors套件及SAP BTP平台的扩展应用&#xff0c;主要针对一线人员绩效管理场景&#xff0c;借助简洁的…
阅读更多...
Elasticsearch中的语义检索

Elasticsearch中的语义检索

一、传统检索的背景痛点 和传统的基于关键词的匹配方式不同&#xff0c;语义检索&#xff0c;利用大模型&#xff0c;将文本内容映射到神经网络空间&#xff0c;最终记忆token做检索。 例如想要搜索中国首都&#xff0c;例如数据集中&#xff0c;只有一篇文章在描述北京&#x…
阅读更多...
【NLP】培训LLM的不同方式

【NLP】培训LLM的不同方式

在大型语言模型&#xff08;LLM&#xff09;领域&#xff0c;存在多种具有不同手段、要求和目标的培训机制。由于它们有不同的用途&#xff0c;因此重要的是不要将它们相互混淆并了解它们适用的不同场景。 在本文中&#xff0c;我想概述一些最重要的训练机制&#xff0c;包括预…
阅读更多...
「Verilog学习笔记」根据状态转移图实现时序电路

「Verilog学习笔记」根据状态转移图实现时序电路

专栏前言 本专栏的内容主要是记录本人学习Verilog过程中的一些知识点&#xff0c;刷题网站用的是牛客网 这是一个典型的米利型状态机。三段式即可解决。 米利型状态机&#xff1a;即输出不仅和当前状态有关&#xff0c;也和输入有关。 其中ST0&#xff0c;ST1&#xff0c;ST3的…
阅读更多...
IPFoxy：什么是数据中心代理IP？好用吗？

IPFoxy：什么是数据中心代理IP？好用吗？

数据中心代理是代理IP中最常见的类型&#xff0c;也被称为机房IP。这些代理服务器为用户分配不属于 ISP&#xff08;互联网服务提供商&#xff09;而来自第三方云服务提供商的 IP 地址。数据中心代理的最大优势——它们允许在访问网络时完全匿名。 如果你正在寻找海外代理IP&am…
阅读更多...
Android跨进程传图片或者大数据（解决TransactionTooLargeException）

Android跨进程传图片或者大数据（解决TransactionTooLargeException）

跨进程传图片方案 直接intent传bitmap使用文件读写intent传递自定义binder&#xff0c;binder中传递image使用网络传输 一、直接intent传bitmap 优势 使用简单 劣势 相关代码可能有侵入性&#xff0c;必须在四大组件中接收。 intent传递数据的总大小是1MB&#xff0c;其中…
阅读更多...
在Jupyter Lab中使用多个环境，及魔法命令简介

在Jupyter Lab中使用多个环境，及魔法命令简介

一、Jupyter Lab使用conda虚拟环境 1、给虚拟环境添加 ipykernel 方法一: 创建环境时直接添加ipykernel 方法&#xff1a;conda create -n 【虚拟环境名称】python3.8 ipykernel实例如下&#xff1a; conda create -n tensorflow_cpu python3.8 ipykernel 方法二&#xff…
阅读更多...
VR全景：赋能城市园区建设，打造3DVR城市名片

VR全景：赋能城市园区建设，打造3DVR城市名片

近年来&#xff0c;很多城市都在大力发展数字化经济建设&#xff0c;以VR全景技术赋能现代化城市和园区建设&#xff0c;为城市园区展示带来了全新的可能性。借助3D、VR技术把现实城市和园区搬到互联网上进行全方位展示&#xff0c;将城市园区的形象、景观、规划布局等1&#x…
阅读更多...
『亚马逊云科技产品测评』活动征文｜AWS 存储产品类别及其适用场景详细说明

『亚马逊云科技产品测评』活动征文｜AWS 存储产品类别及其适用场景详细说明

授权声明&#xff1a;本篇文章授权活动官方亚马逊云科技文章转发、改写权&#xff0c;包括不限于在 Developer Centre, 知乎&#xff0c;自媒体平台&#xff0c;第三方开发者媒体等亚马逊云科技官方渠道 目录 前言、AWS 存储产品类别 1、Amazon Elastic Block Store (EBS) …
阅读更多...
echarts 几千条分钟级别在小时级别图标上展示

echarts 几千条分钟级别在小时级别图标上展示

需求背景解决效果ISQQW代码地址strategyChart.vue 需求背景 需要实现 秒级数据几千条在图表上显示&#xff0c;(以下是 设计图表上是按小时界别显示数据&#xff0c;后端接口为分钟级别数据) 解决效果 ISQQW代码地址 链接 strategyChart.vue <!--/** * author: liuk *…
阅读更多...
编译安装redis及配置多实例

编译安装redis及配置多实例

yum安装是这种十分简单的方法我们就不在提及了&#xff0c;今天我们来做一下redis的编译安装 Redis源码包官方下载链接&#xff1a;http://download.redis.io/releases/ 一、编译安装&#xff1a; 安装依赖包 dnf -y install make gcc jemalloc-devel systemd-devel如果是…
阅读更多...
数据结构中树、森林 与 二叉树的转换

数据结构中树、森林 与 二叉树的转换

1 树转换为 二叉树 将树转换成二叉树的步骤是&#xff1a; 加线。在所有的兄弟结点之间加一条线。去线。对于树中的每个结点&#xff0c;只保留它与第一个孩子结点的连线&#xff0c;删除该结点其他孩子结点之间的连线。调整。以树的根结点为轴心&#xff0c;将整个树顺时针旋…
阅读更多...
SMBGhost_RCE漏洞（CVE-2020-0796永恒之黑）

SMBGhost_RCE漏洞（CVE-2020-0796永恒之黑）

https://blog.csdn.net/qq_45372008/article/details/106980409 https://zhuanlan.zhihu.com/p/374949632 SMB 3.1.1协议处理某些请求的方式中存在远程执行代码漏洞&#xff0c;可能被攻击者利用远程执行任意代码。该漏洞的后果十分接近永恒之蓝系列&#xff0c;都利用Windows …
阅读更多...
银行业务测试

银行业务测试

1、商业银行四大类&#xff1a; 业务类系统、渠道类面试、MIS类系统、其他基础平台系统 2、银行系统开发流程&#xff08;UAT是行方&#xff09; 3、银行系统测试流程 4、对于不同的服务方式也不同&#xff0c;如:柜台、手机银行、网上银行&#xff0c;电话外呼&#xff0c;…
阅读更多...
89. 格雷编码

89. 格雷编码

89. 格雷编码 Java代码&#xff1a;2DFS class Solution {List<Integer> res new ArrayList<>();public List<Integer> grayCode(int n) {dfs(n, new StringBuffer(), new int[]{0, 1});return res;}public void dfs(int n, StringBuffer sb, int[] nums){i…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023