设计模式之组合模式&享元模式

设计模式之组合模式

组合模式概念

将n个对象组合成一个树形结构，目的是用来表示整体和局部的层次，使得用户对单个对象和组合对象的使用有一个整体的一致性

应用场景

1. 需要凸显整体和局部关系的时候，需要使用组合模式
2. 一个功能模块要求可以从整体独立出来的时候，需要用组合模式

组合模式角色

1） 抽象根节点

可以使接口也可以是抽象类，这里规定了整体统一的方法属性

2 ）具体子节点

实现（继承）根节点的具体节点，

3 ）叶子节点

是特殊的具体子节点，它不可以被继承，即没有子节点

组合模式原形举例

抽象根节点

/角色一：抽象节点
public abstract class Component {

    //节点名称  每个节点都有名称
    private String nodeName;
    public Component(String nodeName){
        this.nodeName = nodeName;
    }
    //定义一些业务逻辑  节点可以做的公共操作
    public abstract void doSomeThing();
    public abstract void addChild(Component child);
    public abstract void removeChild(Component child);
    public abstract Component getComponent(int index);

}

具体子节点

//角色二：具体节点
public class Composite extends Component {

    //存放节点的子节点数据
    private List<Component> componentList = new ArrayList<Component>();

    public Composite(String nodeName){
        super(nodeName);
    }

    @Override
    public void doSomeThing() {
        Log.i("main", "具体节点");
    }

//增加子节点
    @Override
    public void addChild(Component child){
        this.componentList.add(child);
    }
//删除子节点
    @Override
    public void removeChild(Component child){
        this.componentList.remove(child);
    }
//获取子节点
    @Override
    public Component getComponent(int index){
        return this.componentList.get(index);
    }

}

叶子节点

//角色三：叶子节点 final修饰 不可被继承
public final class Leaf extends Component {

    public Leaf(String nodeName){
        super(nodeName);
    }

    @Override
    public void doSomeThing() {
        Log.i("main", "叶子节点");
    }

    @Override
    public void addChild(Component child){
        Log.i("main", "我是叶子节点，没有子节点");
    }

    @Override
    public void removeChild(Component child){
        Log.i("main", "我是叶子节点，没有子节点");
    }

    @Override
    public Component getComponent(int index){
        Log.i("main", "我是叶子节点，没有子节点");
        return null;
    }

}

设计模式之享元模式

享元模式概念

使用共享对象可以有效的支持大量的细粒对象。

应用场景

1. 系统中存在大量的相似（相同）对象。
2. 需要缓冲池。
   缓存池：线程池、List集合、Map集合等等…

享元模式角色

1） 享元对象（抽象）

可以使接口也可以是抽象类，这里规定了整体统一的方法属性

2 ）具体享元对象（具体）

实现（继承）抽象享元对象

3 ）享元工厂（工厂模式：创建对象和管理对象）

享元工厂特点：需要有缓存池->缓存享元对象

享元模式原形举例

案例场景：购买车票

抽象享元对象

public interface ITicket {
//共有的查询余票的方法
    void query(String from, String to);
}

具体享元对象

//实现抽象享元对象
public class CarTicket implements ITicket {

    @Override
    public void query(String from, String to) {
        Log.i("main", "汽车票：" + " 起点：" + from + ", 终点：" + to);
    }
}

public class TrainTicket implements ITicket {

    @Override
    public void query(String from, String to) {
        Log.i("main", "火车票：" + " 起点：" + from + ", 终点：" + to);
    }

}

享元工厂

//简单工厂模式
public class TicketFactory {

    public enum TicketType{
        Train, Car;
    }

 //缓存池 缓存享元对象
    private static HashMap<TicketType, ITicket> ticketMap = new HashMap<TicketType, ITicket>();

//工厂创建票
    public static ITicket getTicket(TicketType type){
        ITicket ticket = ticketMap.get(type);
        if (ticket == null){
            if (type == TicketType.Train){
                ticket = new TrainTicket();
            } else if (type == TicketType.Car){
                ticket = new CarTicket();
            }
            ticketMap.put(type, ticket);
        }
        return ticket;
    }

}