Java2实用教程（第五版）/第六章例题

第六章例题

例子一

源代码：

package diliuzhang;

public interface Computable {

       int MAX=46;

       int f(int x);

}

package diliuzhang;

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;

       }

}

package diliuzhang;

public class Japan implements Computable{//Japan类实Computable接口

       int number;

       public int f(int x) {

              return MAX+x;//直接使用接口中的常量

       }

}

package diliuzhang;

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));

       }

}

运行结果：

例子二

源代码：

package diliuzhang;

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机");//接口回调

       }

}

运行结果：

例子三

源代码：

package diliuzhang;//抽象类MotorVehicles,说明刹车功能

abstract class MotorVehicles {

       abstract void brake();//定义抽象方法brake()，抽象类只能定义常量、抽象方法

}

package diliuzhang;//接口（定义收费功能）

interface MoneyFare {

       void charge();//接口中的方法，在类中必须重写

}

package diliuzhang;//接口（定义空调功能）

interface ControlTemperature {

       void controlAirTemperature();

}

package diliuzhang;//子类Bus

class Bus extends MotorVehicles implements MoneyFare{

       void brake() {//抽象类方法的引用，重写方法

              System.out.println("公共汽车使用毂式刹车技术");

       }

       public void charge() {//重写接口的方法，并且访问权限必须为public，接口必须要具体类实现才有意义，所以必须是public。

              System.out.println("公共汽车：一元/张，不计算公里数");

       }

}

package diliuzhang;//子类Taxi

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空调");

       }

}

package diliuzhang;//类Cinema

class Cinema implements MoneyFare,ControlTemperature{

       public void charge() {

              System.out.println("电影院：门票，十元/张");

       }

       public void controlAirTemperature() {

              System.out.println("电影院安装了空调");

       }

}

package diliuzhang;

public class Example6_3 {

       public static void main(String args[]) {

              Bus bus101=new Bus();     //创建对象：对象的声明、分配变量

              Taxi buleTaxi=new Taxi();

              Cinema redStarCinema=new Cinema();

              MoneyFare fare;           //接口回调，声明一个变量，此时fare为一个空接口，Example6_2中接口回调不是空接口

              ControlTemperature temperature;

              fare=bus101;              //将上述bus101对象的引用赋值给fare接口变量

              bus101.brake();            //类所声明的方法的调用

              //fare.brake();           //break是MotorVehicles的方法，而fare是接口变量，不能用接口变量去调用

              //bus101.charge();

              fare.charge();            //fare接口可以调用类实现的接口方法，即charge方法

              fare=buleTaxi;            //将上述buleTaxi对象的引用赋值给fare接口变量

              temperature=buleTaxi;     //将上述buleTAxi对象的引用赋值给temperature接口变量

              buleTaxi.brake();         //类所声明的方法的调用

              fare.charge();            //fare接口可以调用类实现的接口方法，即charge方法

              temperature.controlAirTemperature();//temperature接口可以调用类实现的接口方法，即controlAirTemperature方法

              fare=redStarCinema;       //将上述redStarCinema对象的引用赋值给fare接口变量将上述redStarCinema对象的引用赋值给fare接口变量

              temperature=redStarCinema;//将上述redStarCinema对象的引用赋值给temperature接口变量

              fare.charge();            //fare接口可以调用类实现的接口方法，即charge方法

              temperature.controlAirTemperature();//temperature接口可以调用类实现的接口方法，即controlAirTemperature方法

       }

}

运行结果：

例子四

源代码：

package diliuzhang;

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);

       }

}

运行结果：

例子五

源代码：

package diliuzhang;

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());

       }

}

运行结果：

例子六

源代码：

package diliuzhang;

public interface Advertisement {//接口

       public void showAdvertisement();

       public String getCropName();

}

package diliuzhang;

public class AdvertisementBoard {//负责创建广告牌

       public void show(Advertisement adver) {

              System.out.println(adver.getCropName()+"的广告词如下：");

              adver.showAdvertisement();//接口回调

       }

}

package diliuzhang;

public class WhiteCloudCrop implements Advertisement{//

       public void showAdvertisement() {

              System.out.println("@@@@@@@@@@@@@@@@@@@@");

              System.out.println("飞机中的战斗机，哎yes！\n");

              System.out.println("@@@@@@@@@@@@@@@@@@@@");

       }

       public String getCropName() {

              return "白云有限公司";

       }

}

package diliuzhang;

public class BlackLandCrop implements Advertisement{

       public void showAdvertisement() {

              System.out.println("**************");

              System.out.println("劳动是爹\n土地是妈\n");

              System.out.println("**************");

       }

       public String getCropName() {

              return "黑土集团";

       }

}

package diliuzhang;

public class Example6_6 {

       public static void main(String args[]) {

              AdvertisementBoard board=new AdvertisementBoard();

              board.show(new BlackLandCrop());

              board.show(new WhiteCloudCrop());

       }

}

运行结果：

总结：

1.为了克服Java单继承的缺点，Java使用了接口，一个类可以实现多个接口。使用关键字interface来定义一个接口。接口的定义和类的定义很相似，分为接口的声明和接口体。

接口声明：

–接口通过使用关键字interface来声明

–格式：interface 接口的名字

接口体：

接口体中包含常量定义和方法定义两部分。接口体中只进行方法的声明，不许提供方法的实现，所以，方法的定义没有方法体，且用分号“；”结尾。

2.接口的变量和方法的构成规则：

1)接口中的变量自动都是public、static、final。

2)接口中的方法默认为public abstract；接口也产生class文件。

3)接口中的方法不能被static和final修饰，因为要重写所有接口中的方法。

4)接口中没有构造函数，方法可以抛出异常。

3.实现接口

1)一个类通过使用关键字implements声明自己实现一个或多个接口。

  如：class A implements Printable,Addable

2)如果一个类实现了某个接口，那么这个类必须重写该接口的所有方法。

3)接口可以通过继承产生新的接口。

4)Java提供的接口都在相应的包中，通过import语句不仅可以引入包中的类，也可以引入包中的接口，

  例如:import java.io.*;

4.接口回调：

可以把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中，那么该接口变量就可以调用被类重写的接口方法。实际上，当接口变量调用被类重写的接口方法时，就是通知相应的对象调用这个方法。

5.理解接口：

1）接口可以抽象出重要的行为标准，该行为标准用抽象方法来表示。

2）可以把实现接口的类的对象的引用赋值给接口变量，该接口变量可以调用被该类实现的接口方法，即体现该类根据接口里的行为标准给出的具体行为。

注：接口的思想在于它可以要求某些类有相同名称的方法，但方法的具体内容（方法体的内容）可以不同，即要求这些类实现接口，以保证这些类一定有接口中所声明的方法（即所谓的方法绑定）。接口在要求一些类有相同名称的方法的同时，并不强迫这些类具有相同的父类。

6.接口与多态：

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

7.接口参数：

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

8.接口和abstract类的比较如下：

1)abstract类和接口都可以有abstract方法。

2)接口中只可以有常量,不能有变量；而abstract类中即可以有常量也可以有变量。

3)abstract类中也可以有非abstract方法,接口不可以。