桥接模式（Bridge）--组合模式（Composite）

10、桥接模式（Bridge）

桥接的用意是：将抽象与实现解耦，使得二者可以独立变化，像我们常用的JDBC桥DriverManager一样，JDBC进行连接数据库的时候，在各个数据库之间进行切换，基本不需要动太多的代码，甚至丝毫不用动，原因就是JDBC提供统一接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了。

两个变化因素：品牌，电脑类型

核心要点：处理多层继承结构，处理多维度变化的场景，将各个维度设计成独立的继承结构，使各个维度可以独立的扩展在抽象层建立关联。

抽象与实现：桥接模式分离了抽象部分和实现部分，从而极大的提供了系统的灵活性，让抽象部分和实现部分独立开来，分别定义接口，这有助于系统进行分层设计，从而产生更好的结构化系统。对于系统的高层部分，只需要知道抽象部分和实现部分的接口就可以了。

/**
 * 电脑品牌
 */
public interface Brand {
    void sale();
}

//  创建电脑牌子
class Lenovo implements Brand {

    @Override
    public void sale() {
        System.out.println("出售联想");
    }
}
class Dell implements Brand {

    @Override
    public void sale() {
        System.out.println("出售戴尔");
    }
}

// 新增牌子是十分方便的
class Shenzhou implements Brand {

    @Override
    public void sale() {
        System.out.println("出售神州");
    }
}

// 电脑类型+　获得　品牌的引用
//抽象类接口维护对行为实现（implementation）的引用。它的角色就是桥接类。
public class Computer {

    protected Brand brand;

    public Computer(Brand b) {
        this.brand = b;
    }
    public void sale(){
        brand.sale();
    }
}
//  创建电脑类型
class Desktop extends Computer {

    public Desktop(Brand b) {
        super(b);
    }

    @Override
    public void sale() {
        super.sale();
        System.out.println("出售台式电脑");
    }
}

class Laptop extends Computer {

    public Laptop(Brand b) {
        super(b);
    }

    @Override
    public void sale() {
        super.sale();
        System.out.println("出售笔记本");
    }
}

void main(String[] args)
{
    //  这样就笔记轻松的获得牌子 + 类型
    Computer c = new Laptop(new Lenovo());
    c.sale();

    Computer c2 = new Desktop(new Shenzhou());
    c2.sale();
}

 

 

public interface Sourceable {  

    public void method();  

}  

public class SourceSub1 implements Sourceable {  

    @Override  

    public void method() {  

        System.out.println("this is the first sub!");  

    }  

}  

public class SourceSub2 implements Sourceable {  

    @Override  

    public void method() {  

        System.out.println("this is the second sub!");  

    }  

}  

public abstract class Bridge {  

    private Sourceable source;  

    public void method(){  

        source.method();  

    }  

    public Sourceable getSource() {  

        return source;  

    }  

    public void setSource(Sourceable source) {  

        this.source = source;  

    }  

}  

public class MyBridge extends Bridge {  

    public void method(){  

        getSource().method();  

    }  

}  

 

11、组合模式（Composite）

组合模式有时又叫部分-整体模式。在处理类似树形结构的问题时比较方便：

组合模式：将对象组合成树形结构以表示“部分-整体”的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。
    主要解决：它在我们树型结构的问题中，模糊了简单元素和复杂元素的概念，客户程序可以像处理简单元素一样处理复杂元素，从而使得客户程序与复杂元素的内部结构解耦。
    如何解决：树枝和树叶实现统一接口，树枝内部组合该接口。
    关键代码：树枝内部组合该接口，并且含有内部属性list，里面放Component。

public class TreeNode {  

    private String name;  

    private TreeNode parent;  

    private Vector<TreeNode> children = new Vector<TreeNode>();  

    public TreeNode(String name){  

        this.name = name;  

    }  

    public String getName() {  

        return name;  

    }  

    public void setName(String name) {  

        this.name = name;  

    }  

    public TreeNode getParent() {  

        return parent;  

    }  

    public void setParent(TreeNode parent) {  

        this.parent = parent;  

    }  

    //添加孩子节点  

    public void add(TreeNode node){  

        children.add(node);  

    }  

    //删除孩子节点  

    public void remove(TreeNode node){  

        children.remove(node);  

    }  

    //取得孩子节点  

    public Enumeration<TreeNode> getChildren(){  

        return children.elements();  

    }  

}  

public class Tree {  

    TreeNode root = null;  

    public Tree(String name) {  

        root = new TreeNode(name);  

    }  

    public static void main(String[] args) {  

        Tree tree = new Tree("A");  

        TreeNode nodeB = new TreeNode("B");  

        TreeNode nodeC = new TreeNode("C");  

        nodeB.add(nodeC);  

        tree.root.add(nodeB);  

        System.out.println("build the tree finished!");  

    }  

}  

使用场景：将多个对象组合在一起进行操作，常用于表示树形结构中，例如二叉树等。