1. 定义

又叫享元模式。一个类的实例可以提供多个虚拟实例，用同个方法控制。以共享的方式高效地支持大量的细粒度对象。

• 内蕴状态：不会随环境的改变而改变的，存储在实际对象内部
• 外蕴状态：随环境的改变而改变的，不可以共享。由客户端保存，在需要使用的时候再传入到实际对象内部

2. 使用

（1）单纯蝇量模式

所有的实际对象都是可以共享的

• 抽象蝇量：定义蝇量的基本方法
• 具体蝇量类：实现抽象方法，为内蕴状态提供存储空间
• 蝇量工厂：创建和管理蝇量。检查系统中是否已经有一个符合要求的对象。如果已经有了就提供；否则，创建一个合适的对象。
• 客户：通过蝇量工厂获取蝇量并使用

package FlyweightPattern;

/**
 * 抽象蝇量
 */
public interface Flyweight {

    //业务方法
    public void operate(String ExternalState);
}

package FlyweightPattern;

/**
 * 具体蝇量
 */
public class ConcreteFlyweight implements Flyweight {

    //内蕴状态
    private String internalState;

    public ConcreteFlyweight(String state){
        this.internalState = state;
    }

    //业务方法
    @Override
    public void operate(String externalState) {
        System.out.println("外蕴状态:"+externalState);
        System.out.println("内蕴状态:"+internalState);
    }
}

package FlyweightPattern;

import java.util.HashMap;

/**
 * 生成工厂
 */
public class FlyweightFactory {
    HashMap<String,Flyweight> flyweights;

    public FlyweightFactory() {
        this.flyweights = new HashMap<>();
    }

    public Flyweight getFlyweight(String state) {
        Flyweight flyweight = flyweights.get(state);
        if (flyweight == null){
            flyweight = new ConcreteFlyweight(state);
            flyweights.put(state,flyweight);
        }
        return flyweight;
    }
}

package FlyweightPattern;

public class Test {
    public static void main(String[] args) {
        FlyweightFactory factory = new FlyweightFactory();
        Flyweight a = factory.getFlyweight("A");
        a.operate("X");
        Flyweight b = factory.getFlyweight("B");
        b.operate("XX");
        a = factory.getFlyweight("A");
        a.operate("XXX");
    }
}

（2）复合蝇量模式

将一些单纯蝇量使用合成模式加以复合，形成复合蝇量对象。复合蝇量对象本身不能共享，但是它们可以分解成单纯蝇量对象共享。

• 抽象蝇量：定义蝇量的基本方法
• 具体蝇量类：实现抽象方法，为内蕴状态提供存储空间
• 复合蝇量类：多个本身是单纯蝇量对象的组合
• 蝇量工厂：创建和管理蝇量。检查系统中是否已经有一个符合要求的对象。如果已经有了就提供；否则，创建一个合适的对象。
• 客户：通过蝇量工厂获取蝇量并使用

package FlyweightPattern.ComplexFlyweight;

/**
 * 抽象蝇量
 */
public interface Flyweight {

    //业务方法
    public void operate(String ExternalState);
}

package FlyweightPattern.ComplexFlyweight;

/**
 * 具体蝇量
 */
public class ConcreteFlyweight implements Flyweight {

    //内蕴状态
    private String internalState;

    public ConcreteFlyweight(String state){
        this.internalState = state;
    }

    //业务方法
    @Override
    public void operate(String externalState) {
        System.out.println("外蕴状态:"+externalState);
        System.out.println("内蕴状态:"+internalState);
    }
}

package FlyweightPattern.ComplexFlyweight;

import java.util.ArrayList;
import java.util.List;

/**
 * 复合蝇量
 */
public class ComplexFlyweight implements Flyweight{

    private List<Flyweight> flyweights;

    public ComplexFlyweight(){
        flyweights = new ArrayList<>();
    }

    //组合单纯蝇量
    public void add(Flyweight flyweight){
        flyweights.add(flyweight);
    }

    //业务方法
    @Override
    public void operate(String ExternalState) {
        for (Flyweight flyweight:
             flyweights) {
            flyweight.operate(ExternalState);
        }
    }
}

package FlyweightPattern.ComplexFlyweight;

import java.util.HashMap;
import java.util.List;

/**
 * 生成工厂
 */
public class FlyweightFactory {
    HashMap<String, Flyweight> flyweights;

    public FlyweightFactory() {
        this.flyweights = new HashMap<>();
    }

    //获取单纯蝇量
    public Flyweight getFlyweight(String state) {
        Flyweight flyweight = flyweights.get(state);
        if (flyweight == null){
            flyweight = new ConcreteFlyweight(state);
            flyweights.put(state,flyweight);
        }
        return flyweight;
    }

    //获取复合蝇量
    public Flyweight getComplexFlyweight(List<String> states){
        ComplexFlyweight complexFlyweight = new ComplexFlyweight();
        for (String state:
             states) {
            Flyweight flyweight = getFlyweight(state);
            complexFlyweight.add(flyweight);
        }
        return complexFlyweight;
    }
}

package FlyweightPattern.ComplexFlyweight;

import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        FlyweightFactory factory = new FlyweightFactory();
        List<String> states = new ArrayList<>();
        states.add("A");
        states.add("B");
        states.add("C");
        Flyweight complexFlyweight1 = factory.getComplexFlyweight(states);
        Flyweight complexFlyweight2 = factory.getComplexFlyweight(states);
        System.out.println(complexFlyweight1 == complexFlyweight2);
        Flyweight flyweight1 = factory.getFlyweight(states.get(0));
        Flyweight flyweight2 = factory.getFlyweight(states.get(0));
        System.out.println(flyweight1 == flyweight2);
    }
}

3. 特点

• 节省内存
• 集中管理多个虚拟对象
• 逻辑实例无法拥有独立的行为
• 将蝇量对象的状态外部化，而读取外部状态使得运行时间稍微变长。