Java设计模式之结构型-享元模式（UML类图+案例分析）
目录
一、基本概念
二、UML类图
三、角色设计
四、案例分析
1、基本实现
2、游戏角色
五、总结
一、基本概念
享元模式是一种结构型设计模式，主要用于减少创建大量相似对象所占用的内存，它通过共享技术来有效支持大量细粒度的对象。
二、UML类图
三、角色设计
| 角色 | 描述 |
|---|---|
| 抽象享元角色 | 定义出对象的外部状态和内部状态的接口或属性。 |
| 具体享元角色 | 实现抽象享元角色，定义内部状态，可以保存共享对象的状态 |
| 享元工厂角色 | 负责创建和管理享元对象 |
| 客户端角色 | 存储外部状态，在需要时通过享元工厂获取享元对象 |
四、案例分析
享元模式中的享元对象可以认为是一种可复用的组件。比如在游戏中,有许多类型相同的敌人，这时就可以使用享元模式。
1、我们会创建一个享元工厂类，这个类就像一个存放享元对象的仓库。客户端需要对象时，就来这个工厂类这里取。
2、工厂类存放的是享元对象。享元对象有两种状态：内部状态与外部状态。
内部状态是对象共享的部分，不会改变，比如敌人的形状、颜色等。
外部状态是对象依赖的可变部分，比如敌人的位置。
3、当客户端需要一个享元对象时，会先从工厂请求。
如果工厂里已有该对象，就直接返回已有实例，复用该对象。
如果没有，则创建新实例，并存入工厂后返回。
4、客户端拿到对象后,将外部状态设置给该对象,然后显示。
5、对象使用完后并不销毁，而是返还给工厂继续复用。这样通过管理可复用的享元对象，就可以大量减少对象的创建，节省内存空间，提高性能。
本篇共举了2个简单的小案例进行分析，可以更好的去理解这个设计模式。
1、基本实现
首先定义一个享元接口并声明了一个操作方法：
interface Flyweight {
void operate(String extrinsicState);
}创建具体的享元类，实现享元接口，并包含内部状态：
class ConcreteFlyweight implements Flyweight {
private String intrinsicState;
public ConcreteFlyweight(String intrinsicState) {
this.intrinsicState = intrinsicState;
}
public void operate(String extrinsicState) {
System.out.println("内部状态: " + intrinsicState);
System.out.println("外部状态: " + extrinsicState);
// 执行享元操作
}
}创建享元工厂类，用于管理和共享享元对象：
import java.util.HashMap;
import java.util.Map;
class FlyweightFactory {
private Map flyweights;
public FlyweightFactory() {
flyweights = new HashMap<>();
}
public Flyweight getFlyweight(String intrinsicState) {
if (flyweights.containsKey(intrinsicState)) {
return flyweights.get(intrinsicState);
} else {
Flyweight flyweight = new ConcreteFlyweight(intrinsicState);
flyweights.put(intrinsicState, flyweight);
return flyweight;
}
}
} 在客户端中使用享元工厂类来获取和使用享元对象：
public class Client {
public static void main(String[] args) {
FlyweightFactory factory = new FlyweightFactory();
// 获取或创建享元对象
Flyweight flyweight1 = factory.getFlyweight("SharedState");
Flyweight flyweight2 = factory.getFlyweight("SharedState");
// 使用享元对象
flyweight1.operate("ExtrinsicState1");
flyweight2.operate("ExtrinsicState2");
}
}运行结果如下：
2、游戏角色
我们举一个形象一些的例子，游戏中需要显示大量的相似的敌人角色，这时就可以使用享元模式复用对象以减少内存开销。
定义角色（抽象享元角色）接口：
public interface GameRole {
void display(String name);
}
具体角色（具体享元角色）实现：
public class Enemy implements GameRole {
private String type;
public Enemy(String type){
this.type = type;
}
@Override
public void display(String attackType) {
System.out.println(type+"敌人已启用！"+"攻击方式："+attackType);
}
}
角色工厂（享元工厂角色）实现：
import java.util.HashMap;
import java.util.Map;
public class RoleFactory {
private Map pool;
public RoleFactory() {
pool = new HashMap<>();
}
GameRole getRole(String type) {
if(!pool.containsKey(type)) {
pool.put(type, new Enemy(type));
}
return pool.get(type);
}
} 客户端：
public class Client {
public static void main(String[] args) {
RoleFactory factory = new RoleFactory();
GameRole a = factory.getRole("A");
GameRole b = factory.getRole("B");
a.display("boom");
b.display("fly");
}
}
运行结果如下：
五、总结
优点：
1、减少内存占用，降低系统资源消耗。
2、提高系统性能。
缺点：
1、增加了系统的复杂度;
2、区分内部状态和外部状态可能会很复杂;
3、享元模式使得系统难以维护和扩展。
应用场景：
1、一个应用程序使用大量的相似对象。
2、对象的大多数状态都可以外部化。
3、在内存是关键资源的系统中。
4、系统要求消除大量相似类的重复对象。
例如游戏设计中复用相同的角色对象、网站设计的外观样式、多线程池中的线程对象等都适合使用享元模式。
符合的设计原则：
1、单一职责原则（Single Responsibility Principle）
享元模式分离了内部状态和外部状态。
2、开闭原则（Open Close Principle）
新增享元对象不影响其他对象。
3、组合复用原则（Composite Reuse Principle）
享元对象可以被组合、聚合。