面向对象高级(03)-final关键字、抽象类和接口的基本概念及使用限制

1、15. 面向对象高级（03） 本季要点： final关键字、 简单了解一下抽象类与接口（JAVA中最重要的部分）。 本季讲解了Java中的final关键字、抽象类和接口的基本概念及使用限 制。blog:零基础学JAVAJava SE面向对象部分-15.面向对象高级（03） 2009-01-13上季内容回顾：1、super与this关键字 2、方法的重载与覆写本季主要知识点：1、final关键字 2、简单了解一下抽象类与接口(是JAVA中最重要的部分)final关键字终结器 final1、被final标记的类不能被继承 final class A

2、            class B extends A        验证一下：2、被final标记的方法不能被子类覆写final class A                publ

3、ic final void print()        class B extends A                public void print()    3、被final标记的变量就成为常量，如果成为常量，则以后不能修改cl

4、ass A                final String NAME = "Hello"            public final void print()    &

5、#160;                           NAME = "World"                 &#

6、160;   之前在声明变量的时候是第一个单词的首字母小写，之后每个单词的首字母大写。如果使用final声明常量，则所有单词的字母都要大写。重点：全局常量： · static：是所有对象共享的 · final：是一个常量 · public：表示可以让外部看见public static final String FLAG = ""    全局常量抽象类抽象类：包含一个抽象方法的类就称为抽象类。 抽象方法：只声明而未实现的方法称为抽象方法。 

7、;方法没有方法体（方法体：“”），则称为是一个抽象方法。除了抽象方法之外其他的定义如同普通类一样。 抽象类 = 普通类的功能 + 抽象方法abstract class A                public static final String FLAG = ""      &#

8、160;     public void print()                                /有方法体，所以是一个普通方法     

9、               System.out.println("Hello World");                           

10、0; /此处定义了一个抽象方法            public abstract void fun();        public class Demo04               

11、; public static void main(String args)                                A a = new A();    &#

12、160;           如果要使用一个抽象类，不能直接实例化，抽象类是必须有子类的。 抽象类必须被继承，被继承的子类如果不是一个抽象类的话，则肯定要覆写全部的抽象方法。abstract class A                public static final&#

13、160;String FLAG = ""            public void print()                           &#

14、160;    /有方法体，所以是一个普通方法                    System.out.println("Hello World");               

15、60;             /此处定义了一个抽象方法            public abstract void fun();        /子类中覆写了抽象类中的全部抽象方法    cla

16、ss B extends A                public void fun()                        

17、0;       /super.FLAG也可以写成FLAG,因为FLAG已经是全局常量了哈                    System.out.println("FLAG="+super.FLAG);        

18、60;           public class Demo04                public static void main(String args)         &

19、#160;                      B b = new B();                    b.fun();  

20、;                  b.print();                验证效果，证明抽象类必须这样写哈抽象类的定义抽象类的使用规则抽象类的思考abstract class Person   

21、             /Person类应该有姓名和年龄            private String name;            private int age;  

22、;          public Person(String name,int age)                                thi

23、 = name;                    this.age = age;                        public&

24、#160;void setName(String name)                                 = name;         &#

25、160;              public void setAge(int age)                            &#

26、160;   this.age = age;                        public String getName()               &

27、#160;                return ;                        public int getAge()

28、0;                               return this.age;               &

29、#160;        /定义一个输出方法，但是此方法为抽象方法            public abstract String getInfo();    我们测试一下，发现编译正常，说明抽象类可以有构造方法哈我们继续哈abstract class Person    &

30、#160;           /Person类应该有姓名和年龄            private String name;            private int age;   

31、         public Person()            /如果已经不是无参的，则必须在子类中明确调用无参构造            public Person(String name,int age)  

32、                               = name;                 &

33、#160;  this.age = age;                        public void setName(String name)             

34、0;                   = name;                        public void setAge(

35、int age)                                this.age = age;             &#

36、160;          public String getName()                                return this

37、.name;                        public int getAge()                    &

38、#160;           return this.age;                        /定义一个输出方法，但是此方法为抽象方法       &#

39、160;    public abstract String getInfo();        class Student extends Person                public Student(String name,int a

40、ge)                                /调用Person类中有两个参数的构造方法              

41、      super(name,age);                        /覆写父类的抽象方法            public String get

42、Info()                                return "姓名："+super.getName()+"，年龄："+super.getAge();    &#

43、160;               public class Demo05                public static void main(String args)     

44、                           Student s = new Student("王乾",27);              &

45、#160;     System.out.println(s.getInfo();                抽象类中允许有构造方法，但是此构造方法并不是直接实例化抽象类自己的对象使的，如果在抽象类中没有明确的无参构造方法，即：存在有参构造，则必须在子类明确的使用super指明要调用父类中的那个构造方法。注意： 如果一个抽象类中没有任何一个抽象方法，则也是不能直接实例化的。

46、abstract class A                public void print()        public class Demo06            

47、    public static void main(String args)                                new A();   &#

48、160;            final可以声明一个类，但是此类是绝对不能有子类的。 而抽象类又必须被子类继承。 =>矛盾的final abstract class A        验证下效果，我们发现抽象类是不能使用final声明的。如果假设一个类就是抽象方法和常量的集合，那么此时往往都不再使用抽象类声明了，而使用接口声明。接口（interfac

49、e）interface A                /接口中包含了抽象方法和全局常量            public static String NAME=""        &#

50、160;   public abstract void print();    接口的使用规则（1） 一个子类继承接口实际上称为实现了接口。 如果实现接口的子类不是抽象类的话，则子类必须覆写接口中的全部抽象方法。interface A                /接口中包含了抽象方法和全局常量 

51、           public static String NAME=""            public abstract void print();        class B impl

52、ements A                public void print()                           

53、     System.out.println("NAME="+NAME);                    public class Demo09             

54、   public static void main(String args)                                B b = new B();  

55、60;                 b.print();                 接口使用的事项： 1、抽象类使的是extends关键字，表示一个类只能继承一个父类，但是接口不同，一个类可以同时实现多个接口，但是此时子类就必须同时覆写好多

56、个接口中的抽象方法。interface A                /接口中包含了抽象方法和全局常量            public static String NAME=""       

57、     public abstract void print();        interface X                public abstract void fun();    

58、    class B implements A,X                public void print()                   

59、             System.out.println("NAME="+NAME);                        public void fun() &#

60、160;                              this.print();                 &

61、#160;  public class Demo10                public static void main(String args)                  

62、;              B b = new B();                    b.fun();          

63、60;      抽象类拥有单继承的局限，而接口没有此限制，即：一个子类可以同时实现多个接口。2、既然在定义中已经明确的说明了接口是抽象方法和全局常量的集合，则在定义接口的时候就可以简单定义。interface A                /接口中包含了抽象方法和全局常量       

64、0;    /public static String NAME=""            String NAME=""            /public abstract void print();      &

65、#160;     void print();        class B implements A                public void print()      

66、60;                         System.out.println("NAME="+NAME);                 &#

67、160;  public class Demo11                public static void main(String args)                  

68、              B b = new B();                    b.print();          &#

69、160;     简化后实现的效果一样哈一般习惯在简化时还在前面加上public,呵呵interface A                /接口中包含了抽象方法和全局常量            /public static String NAME="

70、;"            public String NAME=""            /public abstract void print();            public 

71、;void print();        class B implements A                public void print()            &

72、#160;                   System.out.println("NAME="+NAME);                    public class&

73、#160;Demo12                public static void main(String args)                       

74、0;        B b = new B();                    b.print();                

75、接口的使用规则（2）interface A                public void printA();        interface B              

76、;  public void printB();        interface C extends A,B                public void printC();       &

77、#160;class X implements C                /如果实现了（继承）C接口，则在子类中就必须覆写全部的抽象方法            public void printA()     &

78、#160;                          System.out.println("A接口 => Hello World");              &

79、#160;         public void printB()                                System.out.println(

80、"B接口 => Hello World");                        public void printC()               &

81、#160;                System.out.println("C接口 => Hello World");                    public class De

82、mo13                public static void main(String args)                         

83、;       X x = new X();                    x.printA();                 

84、   x.printB();                    x.printC();                如果一个子类即要实现一个接口又要继承一个抽象类呢？ 则此时按以下格式编写： class 类名称 extends 抽象类 implements 接口interface X                public void printX();        interface Y    &#