java接口与实现

code华华

已于 2022-12-02 01:15:02 修改

阅读量3.4k

点赞数 12

分类专栏： java 文章标签： java c# 开发语言

于 2022-10-29 08:44:07 首次发布

本文链接：https://blog.csdn.net/weixin_51976923/article/details/127582677

版权

java 专栏收录该内容

8 篇文章 2 订阅

订阅专栏

5. 接口与实现

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

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

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

5.1 接口

使用interface关键字类定义接口

接口：
1. 接口声明：interface 接口的名字
2. 接口体
  
  接口体包含常量声明和抽象方法
  
  接口体只有常量没有变量，只有抽象方法，没有普通方法。
  
  所有常量访问权限都是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);
}
```
可以省略成：
```
public interface Printable {
    int MAX = 100;
    void add();
    float sum(float x,float y);
}
```

5.2 实现接口

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

类实现接口

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

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

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

案例：
1. A类实现Printable接口和Addable接口
```
class A implements Printable,Addable{
  ···
}
```
1. Animal的Dog子类实现Eatble和Sleepable接口
```
class Dog extends Animal implements Eatble,Sleepable{
  ···
}
```

重写接口中的方法

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

由于接口中的方法是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));
    }
}

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

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

案例：

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

总结：

程序可以通过接口名访问接口中的常量。
一个类实现了某个接口，就可以直接在类体中使用该接口的常量。
定义接口时，在interface前加public修饰，就称该接口为public接口，可以被任何一个类实现。
定义接口时，在interface前不加public修饰，就称该接口为友好接口，只能被同一包中的类实现。
父类实现某接口，子类自然实现该接口，不必再用implements关键字声明实现该接口。
接口也可以被继承，通过extends关键字声明一个接口是另一个接口的子接口（由于父接口方法和常量都是public的，子接口继承父接口的全部方法和常量）

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

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

5.3 接口回调

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

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

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

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

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

假设ImpleCom是实现Com接口的一个类，用ImpleCom声明一个object对象，object即可调用ImpleCom类原有方法，也可以调用ImpleCom类实现的Com接口方法。
```
ImpleCom object = new ImpleCom();
```
内存模型：

在这里插入图片描述

使用接口回调：把object变量的应用赋值给com接口
```
com = object;
```
内存模型：

这时候发现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("联想小新"); // 接口回调
    }
}

5.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.5 接口与多态

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

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

案例：

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

有人用下面的几何公式来计算几何平均值：
$\sqrt {a\times 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);

    }
}

5.6 接口参数

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

案例：

package 接口与实现.接口参数;

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

5.7 abstract类与接口的比较

学到现在，我们发现，接口和抽象类非常相似，那么它两到底有什么区别呢？

区别：
- abstract类和接口都可以有abstract方法
- 接口中只可以有常量，不能有变量；abstract类即可以有常量，也可以有变量
- abstract类可以有非abstract方法，接口不可以。
使用场景：
- 如果某个问题需要使用继承才能更好的解决，例如，子类不仅要重写父类的abstract方法，也需要继承一些变量或继承一些重要的非abstract方法，就可以考虑使用abstract类。
- 如果某个问题不需要继承，知识需要若干类给出某些重要的abstract方法的实现细节，就可以考虑使用接口。

5.8 面向接口编程

之前我们学习了面向抽象编程，学了接口之后，我们来学习下面向接口编程。

接口只关心操作，不关心操作的具体实现细节，可以使我们把主要的精力放在程序的设计上，而不必拘泥于细节的实现。即通过接口声明若干个abstract方法，表明这些方法的重要性，方法体的内容细节由实现接口的类去完成。

使用接口程序设计的核心思想是去使用接口回调，即接口变量存放实现接口的类的实例的引用，从而接口变量就可以回调类实现的接口方法。

利用接口体现了开闭原则，对扩展开放，对修改关闭。

案例：设计一个广告牌，希望设计的广告牌可以展示不同公司的广告词。

interface Advertisement{
  // 展示广告词
    void showAdvertisement();
  // 公司名字
    String getCorpName();
}
// 各公司类实现广告接口
class WhiteCloudCorp implements Advertisement{
    public void showAdvertisement(){
        System.out.println("@@@@@@@@@@@@@@");
        System.out.println("飞机中的战斗机");
        System.out.println("@@@@@@@@@@@@@@");
    };
    public String getCorpName(){
        return "白云黑土公司";
    }

}
class BlackLandCorp implements Advertisement{
    public void showAdvertisement(){
        System.out.println("@@@@@@@@@@@@@@");
        System.out.println("劳动是爹\n土地是妈");
        System.out.println("@@@@@@@@@@@@@@");
    };
    public String getCorpName(){
        return "黑土集团";
    }

}

// 广告牌类
class AdvertisementBoard{
    void show(Advertisement adver){
        System.out.println(adver.getCorpName()+"的广告词如下：");
        adver.showAdvertisement();
    }
}


public class Example6_6 {
    public static void main(String[] args) {
        AdvertisementBoard board = new AdvertisementBoard();
        board.show(new BlackLandCorp());
        board.show(new WhiteCloudCorp());
    }
}