定义：使用共享对象可以有效的支持大量的细粒度对象
使用场景
1、系统中存在大量的相似对象
2、细粒度的对象都具备较接近的外部状态，而且内部状态与环境无关，也就是说对象没有特定省份。
3、需要缓存池的场景。
拿火车票查询举个例子。从城市A到城市B的车辆是有限的，车上的铺位也就是软卧、硬卧、坐票3种。我们把这些可以共享的对象缓存起来，在用户查询时优先使用缓存，如果没有缓存则重新创建，这样就将成千上万的对象变为了可选择的有限数量。

public interface Ticket {
    void showTicketInfo(String bunk);
}

/**
 * 火车票
 */
public class TrainTicket implements Ticket {
    private String from;//始发地
    private String to;//目的地
    private String bunk;//铺位
    private int price;//价格

    public TrainTicket(String from, String to) {
        this.from = from;
        this.to = to;
    }

    @Override
    public void showTicketInfo(String bunk) {
        price = new Random().nextInt(300);
        Log.e("购买 从"+from+"到"+to+"的"+bunk+"火车票，价格："+price);
    }
}

/**
 * 车票工厂，以出发地和目的地为key缓存车票
 */
public class TicketFactory {
    static Map<String,Ticket> sTicketMap=new ConcurrentHashMap<>();
    public static Ticket getTicket(String from,String to){
        String key=from+"-"+to;
        if (sTicketMap.containsKey(key)){
            Log.e("使用缓存 ==> "+key);
            return sTicketMap.get(key);
        }else {
            Log.e("创建新对象 ==> "+key);
            Ticket ticket=new TrainTicket(from,to);
            sTicketMap.put(key,ticket);
            return ticket;
        }
    }
}

public class Test {
    public static void main(String[] args){
        Ticket ticket=TicketFactory.getTicket("北京","青岛");
        ticket.showTicketInfo("软卧");
        ticket=TicketFactory.getTicket("北京","青岛");
        ticket.showTicketInfo("硬卧");
        ticket=TicketFactory.getTicket("北京","青岛");
        ticket.showTicketInfo("坐票");
    }
}

运行结构：
创建新对象 ==> 北京-青岛
购买 从北京到青岛的软卧火车票，价格：3
使用缓存 ==> 北京-青岛
购买 从北京到青岛的硬卧火车票，价格：205
使用缓存 ==> 北京-青岛
购买 从北京到青岛的坐票火车票，价格：66