享元模式（Flyweight Pattern）是一种结构型设计模式，旨在通过共享对象来最大限度地减少内存使用和提高性能。它适用于需要创建大量相似对象的情况，通过共享相同的状态来减少对象的数量，从而节省内存和提高系统的效率。
通俗易懂的解释： 想象一下，你在一个游戏中扮演军队指挥官，需要管理成千上万的士兵。每个士兵都有自己的外观、武器等属性，如果每个士兵都创建一个独立的对象，将会消耗大量的内存。而享元模式就像是在军队里共享相同外观的士兵，节省了内存空间。
享元模式适用于以下情况：
下面是一个简单的示例代码来说明享元模式的应用：
假设我们要创建一个文字处理器，需要处理大量的文本字符。为了节省内存，我们希望共享相同字符的对象。
首先，我们定义一个接口 TextCharacter，表示文本字符：
public interface TextCharacter {
void display();
}
然后，我们实现具体的文本字符类 ConcreteCharacter，包含一个字符属性 character：
public class ConcreteCharacter implements TextCharacter {
private char character;
public ConcreteCharacter(char character) {
this.character = character;
}
@Override
public void display() {
System.out.println("Character: " + character);
}
}
接下来，我们创建一个工厂类 CharacterFactory，用于管理和共享文本字符对象。它包含一个字符对象池 characterPool，使用 HashMap 来存储共享的字符对象：
public class CharacterFactory {
private Map<Character, TextCharacter> characterPool;
public CharacterFactory() {
characterPool = new HashMap<>();
}
public TextCharacter getCharacter(char character) {
TextCharacter textCharacter = characterPool.get(character);
if (textCharacter == null) {
textCharacter = new ConcreteCharacter(character);
characterPool.put(character, textCharacter);
}
return textCharacter;
}
}
最后，我们可以使用享元模式来创建和展示文本字符：
public class TextProcessor {
public static void main(String[] args) {
CharacterFactory characterFactory = new CharacterFactory();
TextCharacter charA = characterFactory.getCharacter('A');
charA.display();
TextCharacter charB = characterFactory.getCharacter('B');
charB.display();
TextCharacter charA2 = characterFactory.getCharacter('A');
charA2.display();
}
}
在上述示例中，我们使用享元模式来共享相同的文本字符对象。通过工厂类 CharacterFactory 来管理对象池，并根据需要返回共享的对象。在 TextProcessor 类中，我们获取了三个字符对象：‘A’、‘B’ 和 ‘A’，其中第一个和第三个对象是相同的，通过共享对象来节省内存空间。
假设你是一个游戏开发者，正在开发一个角色扮演游戏。在游戏中，有许多不同类型的怪物，每个怪物都有自己的外观和属性。为了提高游戏的性能和减少内存占用，你决定使用享元模式来管理怪物对象。
在游戏中，有三种类型的怪物：巨人、骷髅和史莱姆。每个怪物都有自己的外观和属性，例如巨人有高耐力和强力攻击，骷髅具有高速度和弱攻击，史莱姆则具有低耐力和中等攻击。
为了实现享元模式，首先你需要创建一个抽象的怪物类 Monster，它包含了共享的状态和行为：
public abstract class Monster {
protected String appearance;
protected int health;
protected int attack;
public void display() {
System.out.println("Appearance: " + appearance);
System.out.println("Health: " + health);
System.out.println("Attack: " + attack);
}
public abstract void attack();
}
然后，你可以实现具体的怪物类，包括巨人、骷髅和史莱姆。这些具体的怪物类只需实现它们特定的属性，而共享的属性则可以在抽象类中定义：
public class GiantMonster extends Monster {
public GiantMonster() {
appearance = "Giant";
health = 100;
attack = 50;
}
@Override
public void attack() {
System.out.println("Giant monster is attacking!");
}
}
public class SkeletonMonster extends Monster {
public SkeletonMonster() {
appearance = "Skeleton";
health = 50;
attack = 10;
}
@Override
public void attack() {
System.out.println("Skeleton monster is attacking!");
}
}
public class SlimeMonster extends Monster {
public SlimeMonster() {
appearance = "Slime";
health = 20;
attack = 20;
}
@Override
public void attack() {
System.out.println("Slime monster is attacking!");
}
}
接下来，你需要创建一个怪物工厂类 MonsterFactory，用于管理和共享怪物对象。它包含一个怪物对象池 monsterPool，使用 HashMap 来存储共享的怪物对象：
public class MonsterFactory {
private Map<String, Monster> monsterPool;
public MonsterFactory() {
monsterPool = new HashMap<>();
}
public Monster getMonster(String type) {
Monster monster = monsterPool.get(type);
if (monster == null) {
switch (type) {
case "giant":
monster = new GiantMonster();
break;
case "skeleton":
monster = new SkeletonMonster();
break;
case "slime":
monster = new SlimeMonster();
break;
default:
throw new IllegalArgumentException("Invalid monster type!");
}
monsterPool.put(type, monster);
}
return monster;
}
}
最后，你可以使用享元模式来创建和展示怪物：
public class Game {
public static void main(String[] args) {
MonsterFactory monsterFactory = new MonsterFactory();
Monster giant1 = monsterFactory.getMonster("giant");
giant1.display();
Monster skeleton = monsterFactory.getMonster("skeleton");
skeleton.display();
Monster slime1 = monsterFactory.getMonster("slime");
slime1.display();
Monster giant2 = monsterFactory.getMonster("giant");
giant2.display();
}
}
在上述示例中，我们使用享元模式来共享相同的怪物对象。通过工厂类 MonsterFactory 来管理对象池，并根据需要返回共享的对象。在 Game 类中，我们获取了四个怪物对象：巨人、骷髅、史莱姆和另一个巨人。其中第一个和最后一个怪物对象是相同的，通过共享对象来节省内存空间。
通过这个故事中的角色扮演游戏的例子，希望你能更好地理解享元模式的概念和应用，以及它如何通过共享对象来减少内存消耗和提高性能。