Java中的接口是怎么实现的

接口

使用关键字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为接口类

如果一个非抽象类实现了某个接口，那么必须重写这个接口中的所有方法。需要注意的是，由于接口中的方法一定是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包中的类，同时也引入了该包中的接口。