同的情况也发生在数据成员身上，因数据成员必须赋初值，且此值不能再被更改，所 以声明数据成员的关键字 final 也可省略。事实上只要记得：（1）、接口里的“抽象方 法”只要做声明即可，而不用定义其处理的方式；（2）、数据成员必须赋初值，这样 就可以了。
在 java 中接口是用于实现多继承的一种机制，也是 java 设计中最重要的一个环节， 每一个由接口实现的类必须在类内部复写接口中的抽象方法，且可自由地使用接口中 的常量。
既然接口里只有抽象方法，它只要声明而不用定义处理方式，于是自然可以联想 到接口也没有办法像一般类一样，再用它来创建对象。利用接口打造新的类的过程， 称之为接口的实现（implementation）。 格式 6-6 为接口实现的语法：
【 格式 6-6 接口的实现】
class 类名称 implements 接口 A,接口 B 制 { ? }
// 接口的实现，体现多继承的一种机下面的范例修改自范例 TestAbstractDemo1.java：
范例：TestInterfaceDemo1.java
01 interface Person 02 { 03 04 05 06 07 08 }
String name = \张三\ int age = 25 ;
String occupation = \学生\ // 声明一抽象方法 talk() public abstract String talk() ;
09 // Student 类继承自 Person 类 10 class Student implements Person 11 { 12 // 复写 talk()方法
13 14 15 16 17 18 19 20 21 22 23 24 25 26
public String talk() {
return \学生——>姓名：\，年龄：\，职业： \！\ }
}
class TestInterfaceDemo1 {
public static void main(String[] args) {
Student s = new Student() ; System.out.println(s.talk()) ; } }
输出结果： 学生——>姓名：张三，年龄：25，职业：学生！
程序说明：
1、 程序 1~8 行，声明一 Person 接口，并在里面声明了三个常量：name、age、occupation， 并分
别赋值。
2、 程序 10~18 行声明一 Student 类，此类实现 Person 接口，并复写 Person 中的 talk()
方法。
3、 程序第 23 行实例化一 Student 的对象 s，并在第 24 行调用 talk()方法，打印信息。
有些读者可能会觉得这样做与抽象类并没有什么不同，在这里需要再次提醒读者 的是，接口是 java 实现多继承的一种机制，一个类只能继承一个父类，但如果需要一 个类继承多个抽象方法的话，就明显无法实现，所以就出现了接口的概念。一个类只 可以继承一个父类，但却可以实现多个接口。
接口与一般类一样，均可通过扩展的技术来派生出新的接口。原来的接口称为基 本接口或父接口，派生出的接口称为派生接口或子接口。通过这种机制，派生接口不 仅可以保留父接口的成员，同时也可加入新的成员以满足实际的需要。
同样的，接口的扩展（或继承）也是通过关键字 extends 来实现的。有趣的是， 一个接口可以继承多个接口，这点与类的继承有所不同。格式 6-7 是接口扩展的语法：
【 格式 6-7 接口的扩展】
interface 子接口名称 extends 父接口 1，父接口 2，… { … …
} 范例：TestInterfaceDemo2.java
01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17
interface A {
int i = 10 ;
public void sayI() ; }
interface E {
int x = 40 ;
public void sayE() ; }
// B 同时继承了 A、E 两个接口 interface B extends A,E {
int j = 20 ;
public void sayJ() ; }
18 // C 继承实现 B 接口，也就意味着要实现 A、B、E 三个接口的抽象方法 19 class C implements B 20 { 21 public void sayI() 22 { 23 System.out.println(\24 } 25 public void sayJ()
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42
{
System.out.println(\}
public void sayE() {
System.out.println(\}
}
class TestInterfaceDemo2 {
public static void main(String[] args) {
C c = new C() ; c.sayI() ; c.sayJ() ; } }
输出结果：
i = 10 j = 20
程序说明：
1、 程序 1~5 行声明一接口 A，并声明一常量 i 和一抽象方法 sayI()。 2、 程序 6~10 行声明一接口 E，并声明一常量 x 和一抽象方法 sayE()。
3、 程序 12~16 行声明一接口 B，此接口同时继承 A、E 接口，同时声明一常量 j 和 一
抽象方法 sayJ()。
4、 程序 19~33 行声明一类 C，此类实现了 B 接口，所以此类中要复写接口 A、B、E
中的全部抽象方法。
从此程序中读者可以发现与类的继承不同的是，一个接口可以同时继承多个接 口，也就是同时继承了多个接口的抽象方法与常量。
6.6 对象多态性
在前面已经将面向对象的封装性、继承性详细地解释给读者了，下面就来看一下 面向对象中最后一个，也是最重要的一个特性——多态性。
那什么叫多态性呢？读者应该还清楚在之前曾解释过重载的概念，重载的最终效 果就是调用同一个方法名称，却可以根据传入参数的不同而得到不同的处理结果，这 其实就是多态性的一种体现。
下面用一道范例为读者简单介绍一下多态多态的概念，请看下面的范例：
范例：TestJavaDemo1.java
01 class Person 02 { 03 public void fun1() 04 { 05 System.out.println(\06 } 07 public void fun2() 08 { 09 System.out.println(\10 } 11 } 12
13 // Student 类扩展自 Person 类，也就继承了 Person 类中的 fun1()、fun2()方法 14 class Student extends Person 15 { 16 // 在这里复写了 Person 类中的 fun1()方法 17 18 19 20 21 22 23
public void fun1() {
System.out.println(\}
public void fun3() {
System.out.println(\