干货来了 Java 接口的定义和实现

接口与实现

接口(interface)是java的另一种重要的数据类型

接口是java和c#所使用的数据类型，其他语言没有。

学习接口，首先掌握接口的语法，然后通过学习接口回调、接口与多态以及面向接口编程来深刻理解接口。

1、接口

使用interface关键字类定义接口

接口：

接口声明：interface 接口的名字

接口体

接口体包含常量声明和抽象方法

接口体只有常量没有变量，只有抽象方法，没有普通方法。

所有常量访问权限都是public，而且是static常量（可以省略public、static和final关键字）

所有方法访问权限都是public（允许省略public abstract修饰符）

案例：写一个Printable接口

public interface Printable {

    public static final int MAX = 100;

    public abstract void add();

    public abstract float sum(float x,float y);

}

1

2

3

可以省略成：

public interface Printable {

    int MAX = 100;

    void add();

    float sum(float x,float y);

}

1

2

3

2 实现接口

上面知道如何定义一个接口（interface),定义好之后，就应该去使用接口，也就是实现接口。

类实现接口

Java中，通过类来实现接口，才能使用接口中的方法。

类声明时使用implements关键字来声明实现一个或多个接口（多个用逗号隔开）。

语法：class 类名 implements 接口1，接口2

案例：

A类实现Printable接口和Addable接口

class A implements Printable,Addable{

  ···

}

1

2

3

Animal的Dog子类实现Eatble和Sleepable接口

class Dog extends Animal implements Eatble,Sleepable{

  ···

}

1

2

3

重写接口中的方法

非抽象类实现了某个接口，这个类必须重写接口中的所有方法。

由于接口中的方法是public abstract方法，所以重写的方法必须使用public修饰，不然的话就导致访问权限降低，访问权限可以提高但不能降低，和类的继承时访问权限规则一致。

一个源文件可以由接口和类组成。

案例：编写China类、Japan类和Computable接口，China和Japan类都实现了Computable接口。

interface Computable{

    int MAX = 46;

    int f(int x);

}

class China implements Computable{

    int number;

    public int f(int x){

        int sum = 0;

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

            sum+=i;

        }

        return sum;

    }

}

class Japan implements Computable{

    int number;

    public int f(int x){

        return MAX+x;

    }

}

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

    }

}

1

2

3

抽象类实现了某个接口，这个类非必需重写接口中的所有方法。

抽象类即可以重写接口中的方法，也可以直接拥有接口中的方法

案例：

interface Computable{

  final int MAX = 100;

  void speak(String s);

  int f(int x);

  float g(float x,float y);

}

abstract class A implements Computable{

  //只重写了f方法，speak和g方法没有重写直接拥有。

  public int f(int x){

      int sum = 0;

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

            sum+=i;

        }

        return sum;

  }

}

1

2

3

总结：

程序可以通过接口名访问接口中的常量。

一个类实现了某个接口，就可以直接在类体中使用该接口的常量。

定义接口时，在interface前加public修饰，就称该接口为public接口，可以被任何一个类实现。

定义接口时，在interface前不加public修饰，就称该接口为友好接口，只能被同一包中的类实现。

父类实现某接口，子类自然实现该接口，不必再用implements关键字声明实现该接口。

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

注意：java提供的接口都在相应的包中，import语句不仅可以引入包中的类，也可以引入包中的接口。

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

3 接口回调

和类一样，接口是java中一种重要的数据类型，用接口声明的变量称为接口变量。

接口属于引用型变量，接口变量可以存放实现该接口的类的实例对象的引用（引用其实就是c++中的地址）

接口回调：把实现某接口的类创建的对象的引用（地址）赋值给该接口声明的接口变量，那么接口变量就可以调用被类实现的接口方法（类似类中的上转型对象）

假设Com是一个接口，声明接口变量：

Com com; //com就是Com接口声明的一个接口变量，但此时com是一个空接口变量。

1

假设ImpleCom是实现Com接口的一个类，用ImpleCom声明一个object对象，object即可调用ImpleCom类原有方法，也可以调用ImpleCom类实现的Com接口方法。

ImpleCom object = new ImpleCom();

1

内存模型：

使用接口回调：把object变量的应用赋值给com接口

com = object;

1

内存模型：

这时候发现com存放了object的引用（地址）0x12ab9，多了一个箭头指向类实现的接口方法，表明com变量可以调用类实现的接口方法。（这就是接口回调）

注意：接口变量无法调用类中非接口方法。

案例：

interface ShowMessage{

    void showTrademark(String s);

}

class TV implements ShowMessage{

    public void showTrademark(String s){

        System.out.println(s);

    }

}

class PC implements ShowMessage{

    public void showTrademark(String s){

        System.out.println(s);

    }

}

public class Example6_2 {

    public static void main(String[] args) {

        ShowMessage sm; //声明接口变量

        sm=new TV(); // 接口变量中存放对象的引用

        sm.showTrademark("长城牌电视机"); // 接口回调

        sm=new PC(); // 接口变量中存放对象的引用

        sm.showTrademark("联想小新"); // 接口回调

    }

}

1

2

3

4 、理解接口

接口的语法规则很容易记住，但真正的理解接口更重要。

要理解接口，就要明白以下几点

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

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

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

案例：

机动车类是一个抽象类，假如出租车、卡车、拖拉机、摩托车和客车都是机动车类的子类。如果机动车抽象类具有“刹车”、“转向”这两个抽象方法是合理的，因为所说的出租车、卡车、拖拉机、摩托车和客车都具有这两功能。而如果机动车抽象类具有“收取费用”和“调节温度”这两个抽象方法是不合理的，因为所有子类都得重写这两个方法，但是拖拉机可能不需要“收取费用”和“调节温度”的功能。

所以这时候，问题来了。出租车类需要“收取费用”和“调节温度”，而拖拉机可能不需要“收取费用”和“调节温度”，这时候，机动车抽象类就不能具有“收取费用”和“调节温度”这两个抽象方法，可以具有“刹车”、“转向”这两个抽象方法。那么对于出租车类来说，如何去实现“收取费用”和“调节温度”这两个功能呢？难道再定义一个包含“收取费用”和“调节温度”这两个方法的功能抽象类？可是继承只能继承一个父类，不能继承多个。所以行不通。这时候就可以定义两个接口：“收取费用”和“调节温度”，一个类可以实现多个接口，所以可以让出租车类去实现这两个接口，而拖拉机类就不需要实现。

// 机动车类

abstract class MotorVehicles{

    abstract void brake();

  abstract void turn();

}

// 收取费用接口

interface MoneyFare{

    void charge();

}

// 调节温度接口

interface ControlTemperature{

    void controlAirTemperature();

}

// 出租车Taxi类继承机动车MotorVehicles类并实现收取费用MoneyFare接口和调节温度ControlTemperature接口

class Taxi extends MotorVehicles implements MoneyFare,ControlTemperature{

    void brake(){

        System.out.println("出租车刹车");

    }

  void turn(){

      System.out.println("出租车转向");

    }

    public void charge(){

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

    }

    public void controlAirTemperature(){

        System.out.println("出租车调节空调");

    }

}

// 拖拉机继承机动车MotorVehicles类

class Tractor extends MotorVehicles{

   void brake(){

        System.out.println("拖拉机刹车");

    }

   void turn(){

      System.out.println("拖拉机转向");

    }

}

public class Example6_3 {

    public static void main(String[] args) {

        Taxi taxi = new Taxi(); // 创建Taxi对象

        Tractor tractor = new Tractor(); // 创建Tractor对象

        MotorVehicles motor; //声明抽象父类变量

        MoneyFare fare; //声明MoneyFare接口变量

        ControlTemperature temperature; //声明ControlTemperature接口变量

        System.out.println("使用上转型对象调用出租车重写的brake和turn方法：");

        motor=taxi; //使用上转型对象调用出租车重写的brake和turn方法

        motor.brake();

        motor.turn();

        System.out.println("出租车类接口回调：");

        fare = taxi; //接口回调

        fare.charge();

        temperature = taxi; //接口回调

        temperature.controlAirTemperature();

        System.out.println("使用上转型对象调用拖拉机重写的brake和turn方法：");

        motor=tractor; //使用上转型对象调用拖拉机重写的brake和turn方法

        motor.brake();

        motor.turn();

    }

}

输出：

5、 接口与多态

类似类的多态，接口的多态在接口回调以及理解接口两小节我们都接触了。

所谓的接口的多态，就是当我们把实现接口的不同的类的引用赋值给接口变量后，接口变量在回调接口方法时，就可能具有多种形态。

案例：

对于正数a,b,有人用算数平均方式（a+b)/2计算算术平均值

有人用下面的几何公式来计算几何平均值：

a × b \sqrt {a\times b}

a×b

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\n",a,b,result);

6、 接口参数

如果一个方法的参数时接口类型，那么就可以将实现该接口的类的实例的应用传给该接口参数，该接口参数就可以回调类实现的方法了。（类似面向抽象编程，方法参数为抽象父类类型，然后传递子类的引用，这个参数就变为上转型对象参数，去调用重写的父类方法）

7. 接口的优势

接口具有很多的优势：
● 接口可以实现多继承，可以让一个类实现多个接口。
● 接口可以实现代码的解耦，可以将具体实现和接口分离。
● 接口可以实现代码的扩展性，可以在不修改接口的情况下扩展接口的实现。
● 接口可以实现代码的灵活性，可以在运行时动态地实现接口。

8. 注意事项

使用接口时，需要注意以下几点：
● 接口中声明的方法必须是公共的和抽象的。
● 实现接口时，必须实现接口中声明的所有方法。
● 接口可以被多个类实现。
● 在 Java 8 中，接口可以包含默认方法和静态方法的实现。

以上是 Java 中接口的定义和实现的介绍。接口是 Java 中非常重要的概念之一，它具有很多的特性和优势。通过接口，可以将不同的类实现同一个接口，从而实现不同的类之间的互换使用。接口是 Java 编程中实现多态的重要手段之一，也是提高代码的复用性和可维护性的重要手段之一。因此，在 Java 编程中，掌握接口的定义和实现是非常重要的哦。