桥接模式

1、什么是桥接模式？

   桥接模式是一种结构型模式，它主要应对的是：由于实际的需要，某个类具有两个或两个以上的维度变化，如果只是用继承将无法实现这种需要，或者使得设计变得相当臃肿。使用桥接模式就是把变化部分与主类分离开来，从而将多个维度的变化彻底分离。最后，提供一个管理类来组合不同维度上的变化，通过这种组合来满足业务的需要。

  意图：

       将抽象部分与实现部分分离，使它们都可以独立的变化。

2、类图

3、代码类

1.Fruit类
package com.abp.bridge;  
  
public abstract class Fruit {  
      
    /** 
     * 抽象方法 
     * @param People 
     * */  
      
    public abstract void eatFruit(People people);  
}  
 
package com.abp.bridge; 
 
public abstract class Fruit {
 
/**
* 抽象方法
* @param People
* */
 
public abstract void eatFruit(People people);
}
 
这是一个抽象类，是所有水果的抽象，其中的一个抽象方法是对水果执行的动作，也就是将来我们需要对水果执行的操作，参数是人。
 

2.Apple类

package com.abp.bridge;  
  
public class Apple extends Fruit{  
  
    @Override  
    public void eatFruit(People people) {  
        // TODO Auto-generated method stub   
        System.out.println(people.getType() + " eat apple !");  
    }  
  
}  
 
package com.abp.bridge; 
 
public class Apple extends Fruit{
 
@Override
public void eatFruit(People people) {
// TODO Auto-generated method stub
System.out.println(people.getType() + " eat apple !");
}
 
}
 
3.Oranger类

package com.abp.bridge;  
  
public class Oranger extends Fruit{  
  
    @Override  
    public void eatFruit(People people) {  
        // TODO Auto-generated method stub   
        System.out.println(people.getType() + " eat oranger !");  
    }  
  
}  
 
package com.abp.bridge; 
 
public class Oranger extends Fruit{
 
@Override
public void eatFruit(People people) {
// TODO Auto-generated method stub
System.out.println(people.getType() + " eat oranger !");
}
 
}
 
这两个类都是水果类的具体实现，都代表的具体的东西，其中需要重载水果类中的抽象方法，且各自都有各自不同的实现。
 
 
 
 
4.People类
 
package com.abp.bridge; 
  
public abstract class People {  
  
    private String type;  
    private Fruit fruit;  
      
      
    public String getType() {  
        return type;  
    }  
  
  
    public void setType(String type) {  
        this.type = type;  
    }  
  
  
    public Fruit getFruit() {  
        return fruit;  
    }  
  
  
    public void setFruit(Fruit fruit) {  
        this.fruit = fruit;  
    }  
  
    //抽象方法   
    public abstract void eat();  
      
      
}  
 
package com.abp.bridge; 
 
public abstract class People {
 
private String type;
private Fruit fruit;
 
 
public String getType() {
return type;
}
 
 
public void setType(String type) {
this.type = type;
}
 
 
public Fruit getFruit() {
return fruit;
}
 
 
public void setFruit(Fruit fruit) {
this.fruit = fruit;
}
 
//抽象方法
public abstract void eat();

}
 
这个类是抽象的人，里面有两个参数，一个参数是水果，一个参数是类型（代表是男人或是女人）
 
 
5.Man类
 
package com.abp.bridge; 
  
public class Man extends People{  
      
    public Man(){  
        setType("Man");  
    }  
  
    @Override  
    public void eat() {  
        // TODO Auto-generated method stub   
        getFruit().eatFruit(this);  
    }  
  
}  
 
package com.abp.bridge; 
public class Man extends People{
 
public Man(){
setType("Man");
}
 
@Override
public void eat() {
// TODO Auto-generated method stub
getFruit().eatFruit(this);
}
 
}
 
6.Woman类
 
package com.abp.bridge; 
  
public class Woman extends People{  
      
    public Woman(){  
        setType("Woman");  
    }  
  
    @Override  
    public void eat() {  
        // TODO Auto-generated method stub   
        getFruit().eatFruit(this);  
    }  
      
}  
 
package com.abp.bridge; 
 
public class Woman extends People{
 
public Woman(){
setType("Woman");
}
 
@Override
public void eat() {
// TODO Auto-generated method stub
getFruit().eatFruit(this);
}
 
}
 
这两个类继承自People类，是具体的“人”，其中重写了父类方法，并在构造函数中说明是“什么人”
 
7.测试类--Main_Test
 
package com.abp.bridge; 
  
public class Main_Test {  
      
    public static void main(String[] args) {  
          
        People man = new Man();  
        People woman = new Woman();  
          
        Fruit apple = new Apple();  
        Fruit oranger = new Oranger();  
          
        apple.eatFruit(man);  
        oranger.eatFruit(woman);  
        apple.eatFruit(woman);  
        oranger.eatFruit(man);  
    }  
}  
 
package com.abp.bridge; 
 
public class Main_Test {
 
public static void main(String[] args) {
 
People man = new Man();
People woman = new Woman();
 
Fruit apple = new Apple();
Fruit oranger = new Oranger();
 
apple.eatFruit(man);
oranger.eatFruit(woman);
apple.eatFruit(woman);
oranger.eatFruit(man);
}
}
 
这里是对桥接模式的测试。

程序执行的结果如下：
  
Man eat apple !  
Woman eat oranger !  
Woman eat apple !  
Man eat oranger !  
 
Man eat apple !
Woman eat oranger !
Woman eat apple !
Man eat oranger !

四、应用场景

   1．如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的联系。 
   2．设计要求实现化角色的任何改变不应当影响客户端，或者说实现化角色的改变对客户端是完全透明的。
    3．一个构件有多于一个的抽象化角色和实现化角色，系统需要它们之间进行动态耦合。 
    4．虽然在系统中使用继承是没有问题的，但是由于抽象化角色和具体化角色需要独立变化，设计要求需要独立管理这两者。