接口

使用关键字interface 来定义一个接口，和类的定义方法很相似分为接口声明和接口体。

interface  Printable {

    final int MAX = 100;

    void add();

    float sum(float x, float y);

}

接口体中包含常量的声明（没有变量）和抽象方法两部分。而且接口体中所有常量都是publicf 访问权限，而且是 static 常量（允许省略 public 、 final 、 static 修饰符），所有抽象方法一定是 pupblic 访问权限（允许省略 public 、 abstract 等修饰符）。

interface Printable {

    final int MAX = 100; //public static final int MAX=100;

    void add();      //public abstract void add();

    float sum(float x, float y);

}

实现接口

java 中接口由类实现以便使用接口的方法。一个类需要在类声明中使用关键字 implements 声明该类实现一个或多个接口。如果实现多个接口，使用逗号隔开如：

class A implements B,C  //B,C 为接口类

如果一个非抽象类实现了某个接口，那么必须重写外汇返佣http://www.kaifx.cn/这个接口中的所有方法。需要注意的是，由于接口中的方法一定是public abstract 方法，所以类在重写接口方法时不仅要去掉 abstract 修饰符、给出方法体，而且访问权限一定要明显的用 public 来修饰（否则降低了访问权限，这是不允许的）

如果一个类声明实现一个接口，但没有重写接口中的方法，那么这个类必定是抽象类。也就是说抽象类既可以重写接口中的方法，也可以重写接口中的方法。

java 提供的接口都在相应的包中，通过 import 语句不仅可以引用包中的类，也可引入包中的接口，例如：

import java.io.*;

不仅引入了Java.io 包中的类，同时也引入了该包中的接口。

接口基础代码：

import java.awt.*;

import java.io.*;

public class Test {

    public static void main(String[] args) {

        Bus bus101 = new Bus();

        Taxi blueTaxi = new Taxi();

        Cinema redStarCinema = new Cinema();

        MoneyFare fare;

        ControlTemperature temperature;

        fare = bus101;

        bus101.brake();

        fare.charge();

        fare = blueTaxi;

        temperature = blueTaxi;

        blueTaxi.brake();

        fare.charge();

        temperature.controlAirTemperature();

        fare = redStarCinema;

        temperature = redStarCinema;

        fare.charge();

        temperature.controlAirTemperature();

    }

}

abstract class MotorVehicle {

    abstract void brake();

}

interface MoneyFare {

    void charge();

}

interface ControlTemperature {

    void controlAirTemperature();

}

class Bus extends MotorVehicle implements MoneyFare {

    void brake() {

System.out.println(" 公共汽车使用 x 刹车 ");

    }

    public void charge() {

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

    }

}

class Taxi extends MotorVehicle implements MoneyFare, ControlTemperature {

    void brake() {

System.out.println(" 出租车使用盘式刹车技术 ");

    }

    public void charge() {

System.out.println(" 出租车： 2 元 / 公里，起价三公里 ");

    }

    public void controlAirTemperature() {

System.out.println(" 出租车安装了 Hair 空调 ");

    }

}

class Cinema implements MoneyFare, ControlTemperature {

    public void charge() {

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

    }

    public void controlAirTemperature() {

System.out.print(" 电影院安装了中央空调 ");

    }

}

接口参数

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

import java.awt.*;

import java.io.*;

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 Test {

    public static void main(String[] args) {

        KindHello kindHello = new KindHello();

        kindHello.lookHello(new Chinese());

        kindHello.lookHello(new English());

    }

}

1. 接口的定义及简单理解

接口（ Interface ）：确定了对特定对象所能发出的请求，或者对象接收消息的方式。

将“做什么”与“怎么做”分离；

接口中只声明方法（“做什么”，抽象方法）但不定义方法体（“怎么做”）；

接口只规定了类的基本形式，不涉及任何实现细节，实现一个接口的类具有接口规定的行为；

接口可看作使用类的“客户”代码与提供服务的类之间的契约或协议。

2. 接口定义 = 接口声明 + 接口体

2.1 接口声明

[public] interface 接口名 [extends 父接口列表 ] { 接口体 }

public / default ：任意类均可使用 / 与该接口在同一个包中的类可使用

一个接口可以有多个父接口，子接口继承父接口的所有常量和方法

2.2 接口体

接口体= 常量定义 + 方法定义

常量默认具有public, final, static 属性

 类型 常量名 = 常量值 ;

方法默认具有public, abstract 属性

 返回类型 方法名 ([ 参数列表 ]);

1. 常量不能为空白 final 的

2. 父接口中的常量可被子接口中的同名常量隐藏，父接口中的方法可被子接口中的方法重写

3. 接口中成员不能使用的修饰符： transient, volatile, synchronized, private, protected

3. 接口的使用——用类实现接口

1. 类声明中的 implements 关键字

2. 类可以使用接口定义的常量

3. 类必须实现接口定义的所有方法

4. 一个类可以实现多个接口，例：

interface  I1{ … }

interface  I2{ … }

class  Sup { … }

class C extends Sup implements I1,I2 { … }

5.Java 的类继承只支持单继承（子类从单个父类继承），不支持多重继承（子类从多个父类继承）

---extends 后的类名只能有一个

--- 类的继承关系形成树型层次结构

--- 接口的继承支持多重继承

6. 类可以通过实现多个接口达到多重继承的效果

7. 在进行单个父类与多个接口合并时，只有单个父类具有实现细节，从而避免代码冲突

8. 通过继承扩展接口

--- 直接向接口中扩展方法可能带来问题：所有实现原来接口的类将因为接口的改变而不能正常工作

--- 不能向 interface 定义中随意增加方法，需要通过继承扩展接口，例如：

public interface StockWatcher {

 final String sunTicker = "SUNW";

 final String oracleTicker = "ORCL";

 void valueChanged(String tickerSymbol, double newValue);

 void currentValue(String tickerSymbol, double newValue);

}

public interface StockTracker extends StockWatcher {

    void currentValue(String tickerSymbol, double newValue);

}

类实现接口

在Java 语言中，接口由类来实现以便使用接口中的方法。 一个类需要类声明中使用关键字 implements 声明该类实现个或多个接口。 如果实现多个接口，用逗号隔开接口名，例如 A 类实现 Pintable 和 Addable 接口。

classA implements Printable,Addable

再如，Animal 的 Dog 子类实现 Eatable 和 Sleepable 接口。

classDog extends Aninal implements Eatable,Sleepable

 重写接口中的方法

如果一个非抽象类实现了某个接口，那么这个类必须重写这个接口中的所有方法。需要注意的是，由于接口中的方法定是public abstract 方法，所以类在重写接口方法时不仅要去掉 abstract 修饰符、给出方法体，而且方法的访问权限一定要明显地用 public 来修饰 ( 否则就降低了访问权限，这是不允许的 ). 实现接口的非抽象类实现了该接口中的方法，即给出了方法的具体行为功能。用户也可以自定义接口，一个 Java 源文件可以由类和接口组成。

下面的例子1 中包含 China 类、 Japan 类和 Compuable 接口，而且 China 类和 Japan 类都实现了 Computable 接口。

Computable.java

public interface Computable{

int MAX=46;

int f(int x);

}

China.java

class China implements Computable{ //China 类实现 Computable 接口

int number;

public int f(int x){       // 不要忘记 publie 关键宇

int sum=0;

for(int i=0;i<=x;i++){

sum=sum+i;

}

return  sum;

}

}

Japan.java

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

}

}

如果一个类声明实现一个接口，但没有重写接口中的所有方法，那么这个类必须是抽象类，也就是说，抽象类既可以重写接口中的方法，也可以直接拥有接口中的方法，例如:

interface Computable {

    final int MAX = 100;

    vo1d speak(String s);

    int f(int x);

    float g(float x,float y);

}

abstract classA implements Computable{

    public int f(int x){

        int sum 0:

        for(int i=1;i<=x;i++) {

            sum=sum+i;

        }

    return sum;

    }

}

接口的细节说明

程序可以用接口名方问接口中的常量，但是如果个类实现了接口，那么该类可以直接在类体中使用该接口中的常量。

定义接口时，如果关键字interface 前面加上 public 关键字，就称这样的接口是一个 public 接口。 public 接口可以被任何一个类实现。如果一个接口不加 public 修饰，就称作友好接口，友好接口可以被与该接口在同一包中的类实现。

如果父类实现了某个接口，那么子类也就自然实现了该接口，子类不必再显式地使用关键字implements 声明实现这个接口，

接口也可以被继承，即可以通过关键字extends 声明个接口是另个接口的 子接口。由于接口中的方法和常量都是 public 的，子接口将继承父接口中的全部方法和常量。

注: Java 提供的接口都在相应的包中，通过 import 语向不仅可以引入包中的类，也可以引入包中的接口，例如 :

 importJava.io.*;

不仅引入了java.io 包中的类，同时也引入了该包中的接口。