面向对象高级(06)-抽象类与接口、模板设计模式、代理设计模式

1、18. 面向对象高级（06） 本季要点：讲解抽象类与接口的关系。本季讲解了java中关于抽象类与接口的具体区别，同时讲解了两者的一些其他联系。之后讲解了模板设计模式、代理设计模式，最后又重点强调了抽象类和接口之间的关系blog: 零基础学JAVAJava SE面向对象部分-18.面向对象高级（06） 2009-02-08上季内容回顾：1、面向对象中接口与抽象类的具体应用。   可以通过对象的多态性，为父类实例化，之后一切的操作标准以父类为主。本季主要知识点：讲解抽象类与接口的关系。1、一个抽象类中能否包含一个接口呢？abstract class A

2、60;               public abstract void fun();            interface B             

3、;                   public void print();                我们来验证测试下哈发现生成A$B.class，表示B作为A的内部接口，证明一个抽象类中可以包含一个内部接口。那怎么使用

4、呢？我们看下面哈首先我们先子类X覆写父类A方法但不覆写接口B中的方法abstract class A                public abstract void fun();            interface B  &#

5、160;                             public void print();               &#

6、160;    class X extends A                /覆写父类fun()方法            public void fun()     

7、60;                          System.out.println("Hello World!");                

8、发现编译没有问题哈现在我们测试覆写接口方法哈abstract class A                public abstract void fun();            interface B    &#

9、160;                           public void print();                 &#

10、160;  class X extends A                /覆写父类fun()方法            public void fun()       

11、60;                        B b = new Y();                    b.print()

12、;                        class Y implements B                    

13、            /覆写父类接口中的方法print()                    public void print()          &

14、#160;                             System.out.println("Hello Java!");             

15、;                       现在我们加上主方法进行测试哈abstract class A                public abstract 

16、;void fun();            interface B                                pub

17、lic void print();                    class X extends A                /覆写父类fun()方法  &

18、#160;         public void fun()                                B b = new Y(

19、);                    b.print();                        class Y implem

20、ents B                                /覆写父类接口中的方法print()             &

21、#160;      public void print()                                      &#

22、160; System.out.println("Hello Java!");                                        public

23、 class Demo01                public static void main(String args)                     

24、0;          A a = new X();                    a.fun();              &#

25、160; 证明一个抽象类中可以包含一个接口，之后在抽象类的子类中可以有选择的是否实现抽象类中的接口。2、一个接口中能否包含一个抽象类呢？同上，都是可以选择是否实现interface A                public void fun();            ab

26、stract class B                                public abstract void print();      

27、0;         下面我们写上个子类，检验一下是否可以有选择实现抽象类Binterface A                public void fun();            abstr

28、act class B                                public abstract void print();       &

29、#160;            class X implements A                public void fun()           

30、;                  验证可以哈下面覆写抽象类B中print()方法interface A                public void fun();    

31、0;       abstract class B                                public abstract void pr

32、int();                    class X implements A                public void fun()  

33、0;                             new Y().print();                 &

34、#160;      class Y extends B                                public void print() 

35、                                       System.out.println("Hello World!");   

36、60;                                    public class Demo02        

37、0;       public static void main(String args)                                A a = ne

38、w X();                    a.fun();                 3、观察以下的程序，验证输出结果abstract class A   

39、;             public A()                                this.print();&

40、#160;                       public abstract void print();        class B extends A     

41、60;          private int i = 30;            public B(int i)                  

42、60;             this.i = i;                        public void print()      

43、;                          System.out.println("i = "+i);                 &#

44、160;  public class Demo03                public static void main(String args)                  

45、              new B(50);                输出结果为0哈，这与子类对象实例化过程有关哈回顾：子类对象的实例化过程   · 子类对象使用new关键字要调用构造方法   ·  调用构造方

46、法时的顺序：先去调用父类中的构造方法（默认为无参构造），之后再调用子类中的构造方法。   · 调用构造方法的目的：为其内部的属性初始化   · 子类中的属性在没有完成父类中的构造方法之前，所有的内容都是默认值，整型是“0” 。思考：   我们知道一个子类如果实现了一个接口则肯定要覆写接口中的全部抽象方法。那问？是否可以采用一种方式，让子类可以有选择的去覆写自己真正需要的方法。interface Door        

47、0;       /开门            public void openDoor();            /关门            p

48、ublic void closeDoor();            /维修            public void repairDoor();            /拆除 

49、0;          public void removeDoor();            /锁门            public void lockDoor();    

50、;    class D implements Door                /子类现在肯定要覆写里面全部的抽象方法    矛盾点：   · 子类不需要覆写全部的方法   · 如果子类直接实现了接口则肯定要覆写全部的方法   ·

51、解决：如果中间加入了一个过渡端呢？    接口  -> 过渡端 -> 子类 |-  此过渡端不应该被直接使用。 -> 抽象类过渡端使用抽象类实现最合适，因为抽象类可以实现一个接口同时可以有一些抽象方法，并且不能直接被new关键字实例化。interface Door                /开门    &

52、#160;       public void openDoor();            /关门            public void closeDoor();      

53、60;     /维修            public void repairDoor();            /拆除            public

54、0;void removeDoor();            /锁门            public void lockDoor();        abstract class DoorAdapter imple

55、ments Door                /但是以下的方法虽然实现了，可是没有具体的方法体            public void openDoor()          &

56、#160; public void closeDoor()            public void repairDoor()            public void removeDoor()       &#

57、160;    public void lockDoor()        class D extends DoorAdapter                /子类现在肯定要覆写里面全部的抽象方法      

58、;      /只需要打开门            public void openDoor()                         &#

59、160;      System.out.println("开门");                    public class Demo04            

60、0;   public static void main(String args)                                new D().openDoor();  &

61、#160;              此处是有选择的在子类实现了所需要的方法。这种设计称为Adapter（适配器设计） 4、模拟：   · 张三 很老实  -> 李四，借10000000元，不还   · 张三  -> 讨债公司  -> 李四  -> 还钱 张三和讨债公司的目的 -> 还钱。/主题：讨债

62、0;   interface Subject                /完成具体的操作            public void giveMe();        /真正

63、要讨债的人    class RealSubject implements Subject                public void giveMe()               

64、0;                System.out.println("还我滴Money");                    /代理人    class Pr

65、oxySubject implements Subject                private Subject sub = null;            public ProxySubject(Subject sub)   &

66、#160;                            this.sub = sub;                  

67、0;     public void before()                                System.out.println("需要一些准备");