如果系统中可能存在大量相同的对象，那么我们可以建立缓存池之类的东西，将这些重复对象进行复用。这种设计模式就是享元模式。

假设有一个游戏，里面需要汽车和摩托车两种载具。我们希望这些载具可以在游戏中复用，而不是每次都创建新对象。所以这个例子就可以使用享元模式来做。

首先是汽车和摩托车的抽象。我们使用Visible接口表示这个对象将要在游戏中显示。

public interface Visible {
    void show();
}

public class Car implements Visible {
    private int id;

    public Car(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    @Override
    public void show() {
        System.out.println("This is a car " + id);
    }
}

public class Motorcycle implements Visible {
    private int id;

    public Motorcycle(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    @Override
    public void show() {
        System.out.println("THis is a motorcycle "+id);
    }
}

然后是一个缓存池，充当着这些对象的工厂。我们可以将池中的对象复用。这里直接将对象放到了HashMap中了。

public class ObjectPool {
    private HashMap<Integer, Car> carMap = new HashMap<>();
    private HashMap<Integer, Motorcycle> motorcycleMap = new HashMap<>();

    public void putCar(Car car) {
        carMap.put(car.getId(), car);
    }

    public Car getCar(int id) {
        return carMap.get(id);
    }

    public void putMotorcycle(Motorcycle motorcycle) {
        motorcycleMap.put(motorcycle.getId(), motorcycle);
    }

    public Motorcycle getMotorcycle(int id) {
        return motorcycleMap.get(id);
    }
}

最后再来测试一下。可以看到对象被成功的复用了。

    public void run() {
        ObjectPool pool = new ObjectPool();
        pool.putCar(new Car(1));
        pool.putCar(new Car(2));
        pool.putCar(new Car(3));
        pool.putCar(new Car(4));
        pool.putCar(new Car(5));

        pool.putMotorcycle(new Motorcycle(1));
        pool.putMotorcycle(new Motorcycle(2));
        pool.putMotorcycle(new Motorcycle(3));

        pool.getCar(1).show();
        pool.getCar(2).show();
        pool.getCar(3).show();

        pool.getMotorcycle(1).show();
        pool.getMotorcycle(2).show();

    }