第6章 接口与实现

主要内容
基本内容：
 接口
 实现接口
 理解接口
 接口回调
 接口与多态
 接口参数
 面向接口编程
§6.1 接口
为了克服Java单继承的缺点，Java使用了接口，一个类可以实现多个接口。
使用关键字interface来定义一个接口。接口的定义和类的定义很相似，分为接口的声明和接口体。
接口声明
接口通过使用关键字interface来声明
格式：interface 接口的名字
接口体
接口体中包含常量定义和方法定义两部分。接口体中只进行方法的声明，不许提供方法的实现，所以，方法的定义没有方法体，且用分号“；”结尾。如：
接口的变量和方法的构成规则：
接口中的变量自动都是public、static，final，
接口中的方法默认为public abstract；接口也产生class文件。
接口中的方法不能被static和final修饰，因为要重写所有接口中的方法。
接口中没有构造函数，方法可以抛出异常。
§6.2 实现接口
一个类通过使用关键字implements声明自己实现一个或多个接口。
如：class A implements Printable,Addable
如果一个类实现了某个接口，那么这个类必须重写该接口的所有方法。
接口可以通过继承产生新的接口。
Java提供的接口都在相应的包中，通过import语句不仅可以引入包中的类，也可以引入包中的接口，
例如:import java.io.*;
例子1
Computable.java

public interface Computable {
int MAX = 46;
int f(int x);
}

China.java

public class China implements Computable { //China类实现Computable接口
int number;
public int f(int x) { //不要忘记public关键字
int sum = 0;
for(int i=1;i<=x;i++) {
sum = sum+i;
}
return sum;
}
}

Japan.java

public class Japan implements Computable { //Japan类实现Computable接口
int number;
public int f(int x) {
return MAX+x; //直接使用接口中的常量
}
}

Example6_1.java

public class Example6_1 {
public static void main(String args[]) {
China zhang;
Japan henlu;
zhang = new China();
henlu = new Japan();
zhang.number = 32+Computable.MAX; //用接口名访问接口的常量
henlu.number = 14+Computable.MAX;
System.out.println(“zhang的学号”+zhang.number+",zhang求和结果"+zhang. f(100));
System.out.println(“henlu的学号”+henlu.number+",henlu求和结果"+henlu. f(100));
}
}

6.3 接口的UML图（了解）
表示接口的UML图和表示类的UML图类似，使用一个长方形描述一个接口的主要构成，将长方形垂直地分为三层。
顶部第1层是名字层。
第2层是常量层。
第3层是方法层。

§6.4 接口回调（重点，难点）
接口回调是指：可以把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中，那么该接口变量就可以调用被类重写的接口方法。实际上，当接口变量调用被类重写的接口方法时，就是通知相应的对象调用这个方法。例子2
例子2
Example6_2.java

interface ShowMessage {
void 显示商标(String s);
}
class TV implements ShowMessage {
public void 显示商标(String s) {
System.out.println(s);
}
}
class PC implements ShowMessage {
public void 显示商标(String s) {
System.out.println(s);
}
}
public class Example6_2 {
public static void main(String args[]) {
ShowMessage sm; //声明接口变量
sm = new TV(); //接口变量中存放对象的引用
sm.显示商标(“长城牌电视机”); //接口回调
sm = new PC(); //接口变量中存放对象的引用
sm.显示商标(“联想奔月5008PC机”); //接口回调
}
}

§6.5 理解接口
接口的语法规则很容易记住，但真正理解接口更重要。
理解的关键点是：
（1）接口可以抽象出重要的行为标准，该行为标准用抽象方法来表示。
（2）可以把实现接口的类的对象的引用赋值给接口变量，该接口变量可以调用被该类实现的接口方法，即体现该类根据接口里的行为标准给出的具体行为。
例子3
Example6_3.java

abstract class MotorVehicles {
abstract void brake();
}
interface MoneyFare {
void charge();
}
interface ControlTemperature {
void controlAirTemperature();
}
class Bus extends MotorVehicles implements MoneyFare {
void brake() {
System.out.println(“公共汽车使用毂式刹车技术”);
}
public void charge() {
System.out.println(“公共汽车:一元/张,不计算公里数”);
}
}
class Taxi extends MotorVehicles implements MoneyFare,
ControlTemperature {
void brake() {
System.out.println(“出租车使用盘式刹车技术”);
}
public void charge() {
System.out.println(“出租车:2元/公里,起价3公里”);
}
public void controlAirTemperature() {
System.out.println(“出租车安装了Hair空调”);
}
}
class Cinema implements MoneyFare,ControlTemperature {
public void charge() {
System.out.println(“电影院:门票,十元/张”);
}
public void controlAirTemperature() {
System.out.println(“电影院安装了中央空调”);
}
}
public class Example6_3 {
public static void main(String args[]) {
Bus bus101 = new Bus();
Taxi buleTaxi = new Taxi();
Cinema redStarCinema = new Cinema();
MoneyFare fare;
ControlTemperature temperature;
fare = bus101;
bus101.brake();
fare.charge();
fare = buleTaxi;
temperature = buleTaxi;
buleTaxi.brake();
fare.charge();
temperature.controlAirTemperature();
fare = redStarCinema;
temperature = redStarCinema;
fare.charge();
temperature.controlAirTemperature();
}
}

§6.6 接口与多态
可以通过在接口中声明若干个abstract方法，表明这些方法的重要性，方法体的内容细节由实现接口的类去完成。使用接口进行程序设计的核心思想是使用接口回调，即接口变量存放实现该接口的类的对象的引用，从而接口变量就可以回调类实现的接口方法。
例子4
例子4
Example6_4.java

interface CompurerAverage {
public double average(double a,double b);
}
class A implements CompurerAverage {
public double average(double a,double b) {
double aver = 0;
aver = (a+b)/2;
return aver;
}
}
class B implements CompurerAverage {
public double average(double a,double b) {
double aver = 0;
aver = Math.sqrt(a*b);
return aver;
}
}
public class Example6_4 {
public static void main(String args[]) {
CompurerAverage computer;
double a = 11.23,b = 22.78;
computer = new A();
double result = computer.average(a,b);
System.out.printf("%5.2f和%5.2f的算术平均值:%5.2f\n",a,b,result);
computer = new B();
result = computer.average(a,b);
System.out.printf("%5.2f和%5.2f的几何平均值:%5.2f",a,b,result);
}
}

§6.7 接口参数
如果一个方法的参数是接口类型，我们就可以将任何实现该接口的类的实例的引用传递给该接口参数，那么接口参数就可以回调类实现的接口方法。
例子5
Example6_5.java

interface SpeakHello {
void speakHello();
}
class Chinese implements SpeakHello {
public void speakHello() {
System.out.println("中国人习惯问候语：你好,吃饭了吗? ");
}
}
class English implements SpeakHello {
public void speakHello() {
System.out.println("英国人习惯问候语:你好,天气不错 ");
}
}
class KindHello {
public void lookHello(SpeakHello hello) { //接口类型参数
hello.speakHello(); //接口回调
}
}
public class Example6_5 {
public static void main(String args[]) {
KindHello kindHello=new KindHello();
kindHello.lookHello(new Chinese());
kindHello.lookHello(new English());
}
}

§6.8 abstract类与接口的比较（简单介绍，建议学生自主学习）
接口和abstract类的比较如下：
abstract类和接口都可以有abstract方法。
接口中只可以有常量,不能有变量；而abstract类中即可以有常量也可以有变量。
abstract类中也可以有非abstract方法,接口不可以。
§6.9 面向接口编程
面向接口去设计程序，可以通过在接口中声明若干个abstract方法，表明这些方法的重要性，方法体的内容细节由实现接口的类去完成。
使用接口进行程序设计的核心思想是使用接口回调，即接口变量存放实现该接口的类的对象的引用，从而接口变量就可以回调类实现的接口方法。
§6.10 应用举例
设计一个广告牌，希望所设计的广告牌可以展示许多公司的广告词。

总结
接口的接口体中只可以有常量和abstract方法。
和类一样，接口也是Java中一种重要的引用型数据类型。
当接口变量中存放了实现接口的类的对象的引用后，接口变量就可以调用类实现的接口方法，这一过程被称为接口回调。
和子类体现多态类似，由接口产生的多态就是指不同的类在实现同一个接口时可能具有不同的实现方式。
在使用多态设计程序时，要熟练使用接口回调技术以及面向接口编程的思想，以便体现程序设计所提倡的“开-闭”原则。