抽象类与接口的应用(三)

设计模式-->代理设计

范例：代理操作

interface Network{                             //定义Network接口

       public void browse();                   //定义浏览的抽象方法

}

class Real implements Network{          //真实的上网操作

       public void browse(){                  //覆写抽象方法

              System.out.println("上网浏览信息");

       }

}

class Proxy implements Network{              //代理上网

       private Network network;

       public Proxy(Network network){  //设置代理的真实操作

              this.network = network;        //设置代理的子类

       }

       public void check(){                    //与具体上网相关的操作

              System.out.println("检查用户是否合法");

       }

       public void browse(){

              this.check();                        //可以同时调用多个与具体业务相关的操作

              this.network.browse();         //调用真实的上网操作

       }

}

public class ProxyDemo{

       public static void main(String args[]){

              Network net = null;                     //定义接口对象

              net = new Proxy(new Real()); //实例化代理，同时传入代理的真实操作

              net.browse();                       //客户只关心上网浏览一个功能

              }

}

设置模式-->适配器设计

范例：适配器设计实现

interface Window{                      //定义Window接口，表示窗口操作

       public void open();               //窗口打开

       public void close();        //窗口关闭

       public void activated();   //窗口活动

       public void iconified();   //窗口最小化

       public void deiconified();       //窗口恢复大小

}

//定义抽象类实现接口，在此类中覆写方法，但是所有的方法体为空

abstract class WindowAdapter implements Window{

       public void open(){}                    //覆写open()方法，方法体为空

       public void close(){}                   //覆写close()方法，方法体为空

       public void activated(){}              //覆写activated()方法，方法体为空

       public void iconified(){}        //覆写iconified()方法，方法体为空

       public void deiconified(){}           //覆写deiconified()方法，方法体为空

}

//子类直接继承WindowAdapter类，有选择地实现需要的方法

class WindowImpl extends WindowAdapter{

       public void open(){                      //真正实现open()方法

              System.out.println("窗口打开");  

       }

       public void close(){                     //真正实现close()方法

              System.out.println("窗口关闭");

       }

}

public class AdapterDemo{

       public static void main(String args[]){

              Window win = new WindowImpl();     //实现接口对象

              win.open();                                        //调用open()方法

              win.close();                                //调用close()方法

       }

}

 

//适配器设计

内部类的扩展

范例：在一个抽象类中包含接口

abstract class A{                         //定义抽象A

       public abstract void printA();        //定义抽象方法

       interface B{                                       //定义内部接口

              public void printB();                     //定义抽象方法

       }

}

class X extends A{                                    //继承抽象类

       public void printA(){                           //实现抽象方法

              System.out.println("Hello --> A");

       }

       class Y implements B{                        //定义内部类实现内部接口

              public void printB(){                    //实现内部接口的抽象方法

                     System.out.println("Hello -->B");

              }

       }

}

public class InnerExtDemo01{

       public static void main(String args[]){

              A.B b = new X().new Y();            //实例化内部接口对象

              b.printB();                                         //调用内部接口的抽象方法

       }

}

范例：在一个接口中包含抽象类

interface A{                         //定义接口A

       public abstract void printA();        //定义抽象方法

       abstract class B{                                       //定义内部抽象类

              public      abstract void printB();                  //定义抽象方法

       }

}

class X implements A{                                      //实现接口的抽象类

       public void printA(){                           //实现抽象方法

              System.out.println("Hello --> A");

       }

       class Y extends       B{                        //在接口实现类中接口

              public void printB(){                    //实现内部接口的抽象方法

                     System.out.println("Hello -->B");

              }

       }

}

public class InnerExtDemo02{

       public static void main(String args[]){

              A.B b = new X().new Y();            //实例化内部接口对象

              b.printB();                                         //调用内部接口的抽象方法

       }

}

抽象类与接口之间的关系

序号	区别点	抽象类	接口
1	定义	包含一个抽象方法的类	抽象方法和全局常量的集合
2	组成	构造方法、抽象方法、普通方法、常量、变量	常量、抽象方法
3	使用	子类继承抽象类(extends)	子类实现接口 (implements)
4	关系	抽象类可以实现多个接口	接口不能继承抽象类，但允许继承多个接口
5	常见设计模式	模板设计	工厂设计、代理设计
6	对象	都通过对象的多态性产生实例化对象
7	局限	抽象类有单继承的局限	接口没有此局限
8	实际	作为一个模板	作为一个标准或表示一种能力
9	选择	如果抽象类和接口都可以使用，则优先使用接口，避免单继承的局限
10	特殊	一个抽象类中可以包含多个接口，一个接口中可以包含多个抽象类

 

总结：

1、  抽象类和接口的实例化：通过对象多态性

2、  抽象类表示一个模板，接口制定的是一个标准

3、  常见的设计模式：模板设计，工厂设计、代理设计，适配器设计