一、基本概念

享元模式是一种结构型设计模式，主要用于减少创建大量相似对象所占用的内存，它通过共享技术来有效支持大量细粒度的对象。

二、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<String, Flyweight> 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<String, GameRole> 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");

    }
}

运行结果如下：