桥模式设计学习总结

注意，在一个普通的类前面，只能有四种修饰方式：public default abstract final。绝对不能用private，protected等访问修饰符，也不能用static来修饰，因为static表示的是类的成员。

 

理解static的关键是“静态的东西只有一个，与对象没有任何关系”

 

import java.io.*;

 interface Function{

       public void fn();

}

 

abstract class Door{

       public abstract void close();

       public abstract void open();

}

 

public class MyDoor extends Door implements  Function{

      

       public void close(){

              System.out.println ("用手关闭");

       }

       public void open(){

              System.out.println ("用手打开");

       }    

       public void fn(){

              System.out.println ("Avoid fire");

       }

      

       public static void main(String[] args){

      Door door1 =new MyDoor ();

         Door1.open();

      //door1.fn();       错误，因为已经转型为Door对象door，所以它不具备接口的fn()方法，如果将对象door转型为Function，也存在问题，因为对象不具备open()和close()行为.

     /*如果采用下面的方式，实例化一个test对象，它同时拥有open(),close()和fn()方法，但是这样的坏处是：它的本质的东西已经完全的固定，假若有一天我们要求门还要具有防盗的方法，那就要修改代码才能实现，这就违反了开闭原则*/

MyDoor door2 =new MyDoor ();

door2.fn(); 

              }

       }

 

//举例，为什么前面我们的防火（盗）门的设计要不得

//概念:桥模式，在一个抽象类中放另一个抽象的东西

import java.io.*;//public default abstract final

interface Function{

       public void fn();

}

 

class  AvoidThief implements Function{

       public void fn(){

                     System.out.println ("Avoid thief");

       }

}

 

class  AvoidFire implements Function{

       public void fn(){

              System.out.println ("Avoid fire");

       }

}

      

abstract class Door{

       public abstract void close();

       public abstract void open();

       private Function f;//private Function[] f;假如它有很多的功能，如实现防火，防盗，智能化等，只需要返回一个数组就OK了

       public void setF(Function f){

              this.f = f;

       }

      

       public void invoke(){

              f.fn();

       }

}

 

class MyDoor extends Door{

       public void close(){

              System.out.println ("用手关闭");

       }

       public void open(){

              System.out.println ("用手打开");

       }    

}

 

public class FireDoor{

       public static void main(String[] args){

              Door d = new MyDoor();

              d.setF(new AvoidThief());

              d.invoke();

              d.setF(new AvoidFire());

              d.invoke();

              

    }

}

 

下面的例子同样的采取了桥模式,它同上面的例子相比有一个很大的缺陷，甚至是原则上错误，你能开出来吗？(在Person s = new Student("yht");//Chinese处，可以思考下为什么。)

对于抽象的人具有姓名(name)和行为(action()方法)，但是一个具体的人，如一个学生(Student)和一个员工(Emp),它只是人这个抽象类的一个表现形式，是部分人的性质或者特点，

abstract class Person{

       private String name = null;

       public abstract void action();

      

       public Person(String name){

              this.name = name;

       }

      

       private Role r = null;

       public void setR(Role r){

              this.r = r;

       }

      

       public void envoke(){

              r.fn();

       }

}

 

public class Demo{

       public static void main(String[] args){

               Person s = new Student("yht");//Chinese

               s.setR(new Student());

               s.setR(new EMP());

               s.setR(new MB)

    }

}

 

abstract class Role{

       public abstract void fn();      

}

class Student extends Role{  

       public void fn(){

              System.out.println ("study");

       }

}

 

class Emp extends Role{      

       public void fn(){

              System.out.println ("work");

       }

}

 

class MBA extends Role{     

       public void fn(){

              System.out.println ("execute");

       }

}