上季内容回顾：1、super与this关键字2、方法的重载与覆写本季主要知识点：1、final关键字2、简单了解一下抽象类与接口(是JAVA中最重要的部分) final关键字终结器—— final1、被final标记的类不能被继承final class A{};class B extends A{};验证一下：2、被final标记的方法不能被子类覆写final class A{public final void print(){}};class B extends A{public void print(){}};3、被final标记的变量就成为常量，如果成为常量，则以后不能修改class A{final String NAME= "Hello";public final void print(){NAME = "World";}};之前在声明变量的时候是第一个单词的首字母小写，之后每个单词的首字母大写。

如果使用final声明常量，则所有单词的字母都要大写。

重点：全局常量：· static：是所有对象共享的· final：是一个常量· public：表示可以让外部看见public static final String FLAG = ""; 全局常量抽象类抽象类：包含一个抽象方法的类就称为抽象类。

抽象方法：只声明而未实现的方法称为抽象方法。

方法没有方法体（方法体：“{}”），则称为是一个抽象方法。

除了抽象方法之外其他的定义如同普通类一样。

抽象类 = 普通类的功能 + 抽象方法abstract class A{public static final String FLAG = "";public void print(){//有方法体，所以是一个普通方法System.out.println("Hello World~~~");}//此处定义了一个抽象方法public abstract void fun();};public class Demo04{public static void main(String args[]){A a = new A();}};如果要使用一个抽象类，不能直接实例化，抽象类是必须有子类的。

抽象类必须被继承，被继承的子类如果不是一个抽象类的话，则肯定要覆写全部的抽象方法。

abstract class A{public static final String FLAG = "";public void print(){//有方法体，所以是一个普通方法System.out.println("Hello World~~~");}//此处定义了一个抽象方法public abstract void fun();};//子类中覆写了抽象类中的全部抽象方法class B extends A{public void fun(){//super.FLAG也可以写成FLAG,因为FLAG已经是全局常量了哈~~~System.out.println("FLAG="+super.FLAG);}};public class Demo04{public static void main(String args[]){B b = new B();b.fun();b.print();}};验证效果，证明抽象类必须这样写哈~~~抽象类的定义抽象类的使用规则抽象类的思考abstract class Person{//Person类应该有姓名和年龄private String name;private int age;public Person(String name,int age) { = name;this.age = age;}public void setName(String name) = name;}public void setAge(int age){this.age = age;}public String getName(){return ;}public int getAge(){return this.age;}//定义一个输出方法，但是此方法为抽象方法public abstract String getInfo();};我们测试一下，发现编译正常，说明抽象类可以有构造方法哈~我们继续哈~abstract class Person{//Person类应该有姓名和年龄private String name;private int age;public Person(){}//如果已经不是无参的，则必须在子类中明确调用无参构造public Person(String name,int age){ = name;this.age = age;}public void setName(String name){ = name;}public void setAge(int age){this.age = age;public String getName(){return ;}public int getAge(){return this.age;}//定义一个输出方法，但是此方法为抽象方法public abstract String getInfo();};class Student extends Person{public Student(String name,int age){//调用Person类中有两个参数的构造方法super(name,age);}//覆写父类的抽象方法public String getInfo(){return"姓名："+super.getName()+"，年龄："+super.getAge();}};public class Demo05{public static void main(String args[]){Student s = new Student("王乾",27);System.out.println(s.getInfo());}}抽象类中允许有构造方法，但是此构造方法并不是直接实例化抽象类自己的对象使的，如果在抽象类中没有明确的无参构造方法，即：存在有参构造，则必须在子类明确的使用super 指明要调用父类中的那个构造方法。

注意：如果一个抽象类中没有任何一个抽象方法，则也是不能直接实例化的。

abstract class A{public void print(){}};public class Demo06{public static void main(String args[]){new A();}};final可以声明一个类，但是此类是绝对不能有子类的。

而抽象类又必须被子类继承。

==>矛盾的final abstract class A{};验证下效果，我们发现抽象类是不能使用final声明的。

如果假设一个类就是抽象方法和常量的集合，那么此时往往都不再使用抽象类声明了，而使用接口声明。

接口（interface）interface A{//接口中包含了抽象方法和全局常量public static String NAME="";public abstract void print();};接口的使用规则（1）一个子类继承接口实际上称为实现了接口。

如果实现接口的子类不是抽象类的话，则子类必须覆写接口中的全部抽象方法。

interface A{//接口中包含了抽象方法和全局常量public static String NAME="";public abstract void print();};class B implements A{public void print(){System.out.println("NAME="+NAME);}};public class Demo09{public static void main(String args[]){B b = new B();b.print();}};接口使用的事项：1、抽象类使的是extends关键字，表示一个类只能继承一个父类，但是接口不同，一个类可以同时实现多个接口，但是此时子类就必须同时覆写好多个接口中的抽象方法。

interface A{//接口中包含了抽象方法和全局常量public static String NAME="";public abstract void print();};interface X{public abstract void fun();};class B implements A,X{public void print(){System.out.println("NAME="+NAME);}public void fun(){this.print();};public class Demo10{public static void main(String args[]){B b = new B();b.fun();}};抽象类拥有单继承的局限，而接口没有此限制，即：一个子类可以同时实现多个接口。

2、既然在定义中已经明确的说明了接口是抽象方法和全局常量的集合，则在定义接口的时候就可以简单定义。

interface A{//接口中包含了抽象方法和全局常量//public static String NAME="";String NAME="";//public abstract void print();void print();};class B implements A{public void print(){System.out.println("NAME="+NAME);}};public class Demo11{public static void main(String args[]){B b = new B();b.print();};简化后实现的效果一样哈~一般习惯在简化时还在前面加上public,呵呵~~~interface A{//接口中包含了抽象方法和全局常量//public static String NAME="";public String NAME="";//public abstract void print();public void print();};class B implements A{public void print(){System.out.println("NAME="+NAME);}};public class Demo12{public static void main(String args[]){B b = new B();b.print();}};接口的使用规则（2）interface A{public void printA();}interface B{public void printB();}interface C extends A,B{public void printC();}class X implements C{//如果实现了（继承）C接口，则在子类中就必须覆写全部的抽象方法public void printA(){System.out.println("A接口===> Hello World~~~"); }public void printB(){System.out.println("B接口===> Hello World~~~"); }public void printC(){System.out.println("C接口===> Hello World~~~"); }}public class Demo13{public static void main(String args[]){X x = new X();x.printA();x.printB();x.printC();}}如果一个子类即要实现一个接口又要继承一个抽象类呢？则此时按以下格式编写：class 类名称 extends 抽象类 implements 接口interface X{public void printX();}interface Y{public void printY();}//一个抽象类也是可以实现接口的abstract class Z implements Y{public abstract void printZ();}//D类同时继承Z类和实现X接口class D extends Z implements X{public void printX(){System.out.println("X ===>Hello~~~"); }public void printY(){System.out.println("Y ===>Hello~~~"); }public void printZ(){System.out.println("Z ===>Hello~~~"); }}public class Demo14{public static void main(String args[]){D d = new D();d.printX();d.printY();d.printZ();}}总结1、final关键字2、抽象类与接口的定义及基本使用。