04 接口与实现

• • 基本内容
  • • Interface.java
  • 接口回调
  • • BackInterface.java
    • Vehicle.java
  • 接口参数
  • abstract类 VS 接口
  • • Hello.java

• 用关键字interface定义，接口包含常量（没有变量） 和抽象方法。
• 所有常量都是public、static的，允许省略public、final、static修饰符。
• 所有抽象方法都是public的，允许省略public abstract修饰符。
• 类实现接口，一个类可以实现多个接口，需用逗号隔开多个接口。
• 如果一个非抽象类实现了该接口，那么必须重写接口中的所有方法，去掉abstract，但保留public（否则是降低了权限）。
• 如果抽象类实现了该接口，不必重写所有方法，也可直接拥有接口中的方法。
• 如果interface前面有public修饰，则public接口可被任何一个类实现。否则，就是友好接口，能被一个包内实现。
• 接口和类一样，也是一种数据类型，接口属于引用型变量

package com;

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=1;i<=x;i++){
            sum+=i;
        }
        return sum;
    }
}

class Japan implements Computable{
    int number;
    public int f(int x){
        return MAX+x;
    }
}

public class Interface {
    public static void main(String[] args) {
        China chinese;
        Japan japanese;
        chinese = new China();
        japanese = new Japan();
        chinese.number = 32+Computable.MAX;  //static常量，可用接口名调用
        japanese.number = 14 + Computable.MAX;
        System.out.println("chinese的学号"+chinese.number+",chinese 求和结果"+chinese.f(100));
        System.out.println("japanese的学号"+japanese.number+",japanese 求和结果"+japanese.f(100));
    }
}

运行结果：

chinese的学号78,chinese 求和结果5050
japanese的学号60,japanese 求和结果146

• C语言指针回调：一个变量的地址存在一个指针变量中，那么指针变量就可操作该变量中存放的数。
• 接口不能new对象，但能声明对象。
• 接口回调：把实现接口的类创建的对象，的引用赋值给接口声明的接口变量。
• 接口回调类似于上转型对象调用子类重写的方法，接口回调无法调用类中其他的非接口方法。

package com.LearnInterface;

interface ShowMessage{
    void showMessage(String s);
}

class TV implements ShowMessage{
    public void showMessage(String s){
        System.out.println(s);
    }
}

class PC implements ShowMessage{
    public void showMessage(String s){
        System.out.println(s);
    }
}


public class BackInterface {
    public static void main(String[] args) {
        ShowMessage sm;  //声明接口变量
        sm = new TV();   //接口回调 
        sm.showMessage("华为智慧电视");
        sm = new PC();
        sm.showMessage("华硕天选2");
    }
}

华为智慧电视
华硕天选2

package com.LearnInterface;

abstract class MotorVehicles{
    abstract void brake();
}

interface MoneyFare{
    void charge();
}

interface ControlTemperature{
    void controlTemperature();
}

class Bus extends MotorVehicles implements MoneyFare{  //该类不仅实现了抽象类，还实现了接口
    void brake(){
        System.out.println("公交车使用鼓式刹车技术");
    }
    public void charge(){
        System.out.println("上车2元");
    }
}

class Taxi extends MotorVehicles implements MoneyFare,ControlTemperature{  //这更是实现了2个接口
    void brake(){
        System.out.println("出租车使用的是盘式刹车技术");
    }
    public void charge(){
        System.out.println("出租车：2元/公里，起步价3公里");
    }
    public void controlTemperature(){
        System.out.println("出租车装了空调");
    }
}

class Cinema implements MoneyFare,ControlTemperature{
    public void charge(){
        System.out.println("电影院：门票，30元/张");
    }
    public void controlTemperature(){
        System.out.println("电影院装了中央空调");
    }
}

public class Vehicle {
    public static void main(String[] args) {
        Bus bus = new Bus();
        Taxi taxi = new Taxi();
        Cinema cinema = new Cinema();
        MoneyFare fare;
        ControlTemperature temperature;
        fare = bus;     //接口回调
        bus.brake();    //子类对象调用重写的方法
        fare.charge();  //接口对象回调子类重写的方法

        fare = taxi;
        temperature = taxi;
        taxi.brake();
        fare.charge();
        temperature.controlTemperature();

        fare = cinema;
        temperature = cinema;
        fare.charge();
        temperature.controlTemperature();
    }
}

运行结果：

公交车使用鼓式刹车技术
上车2元
出租车使用的是盘式刹车技术
出租车：2元/公里，起步价3公里
出租车装了空调
电影院：门票，30元/张
电影院装了中央空调

• 给一个方法的参数传值，可设置为double类型，这样可以向该参数传递byte, int ,long, float, double类型的数据。
• 类似的，如果一个方法的参数是接口类型，就可以将任何实现该接口的 类的实例的引用传递给该参数，此时接口参数就可以回调类实现的接口方法。

• abstract类和接口都可以有abstract方法
• 接口不能有非abstract方法
• 接口中只能有常量，abstract类中还可以有变量
• 如果需要继承一些变量或非abstract方法，可考虑用abstract类
• 如果不需要继承，只是需要若干类给出某些重要的abstract方法的实现细节，可考虑用接口。

package com.LearnInterface;

interface SpeakHello{
    void speakHello();
}

class Chinese implements SpeakHello{
    public void speakHello(){
        System.out.println("中国人习惯问候语：你好，吃饭了吗？");
    }
}

class British implements SpeakHello{
    public void speakHello(){
        System.out.println("英国人习惯问候语：你好，天气不错");
    }
}

class KindHello{
    //通过lookHello的方法（函数）来表达说Hello这一动作，至于怎么说的，由接口下的实现类实现，一般接口中会有多个方法
    public void lookHello(SpeakHello hello){    //接口类型参数
        hello.speakHello();                     //接口回调
    }
}

public class Hello {
    public static void main(String[] args) {
        KindHello kindHello = new KindHello();
        kindHello.lookHello(new Chinese());  //虽然方法的参数是接口类型，但是传的是接口的实现类的对象
        kindHello.lookHello(new British());
    }
}

运行结果：

公交车使用鼓式刹车技术
上车2元
出租车使用的是盘式刹车技术
出租车：2元/公里，起步价3公里
出租车装了空调
电影院：门票，30元/张
电影院装了中央空调