接口与实现基础 DAY TWO

接口与实现

DAY TWO

目录

DAY ONE
第一节：接口
第二节：接口实现
DAY TWO
第三节：接口回调
第四节：接口与多态
第五节：接口参数
DAY THREE
第六节：面向接口编程

---

前言

自学Java总结的一些接口知识点。

---

第三节、接口回调

1.1接口细节说明：
程序可以用接口名访问接口中的常量，但是如果一个类实现了接口，那么 该类可以在类体中直接使用该接口中的常量。

定义接口时，如果在interface前面加上public关键字，这改接口是一个public接口，可以被任何一个类实现。如果没有public关键字，则改接口为友好接口，可以被同一包中的类实现。

如果父类实现了某个接口，那么子类也实现了改接口，子类不必使用implements再次声明实现改接口。

1.2接口回调：
接口属于引用型变量，接口变量中可以存放实现该接口的类的实例的引用，即存放对象的引用。例如，假如Animal是一个接口，那么用Animal声明一个变量：

Animal animal;

内存模型如下，此时的animal是一个空接口，因为animal变量中还没有存放实现这个接口的类的对象引用。
假设Dog类是实现Animal接口的类，用Dog创建名字为dog的对象，那么dog对象既可以调用类中原有的方法，也可以调用实现接口中的方法。

Dog dog = new Dog();

在Java中，接口回调的意思是吧实现某一接口的类创建的对象的引用赋值给该接口声明的接口变量，那么该接口变量就可以被类实现的接口方法。（简单来说接口回调就是接口变量调用类中重写的方法）
将上述dog对象的引用赋值给animal接口:

animal=dog;

那么内存模型如下所示：

接口回调非常类似于上转型对象调用子类重写的方法。

例子2：//运用了接口回调的方法

Animal.java
public interface Animal {
    void cry();
    public String getAnimalName();
}

Dog.java//实现接口的类
public class Dog implements Animal {
    @Override
    public void cry() {
        System.out.println("旺旺旺，我是小狗！");
        System.out.println("---------------------");
    }

    @Override
    public String getAnimalName() {
        return "小狗";
    }
}

Cat.java//实现接口的类
public class Cat implements Animal {
    @Override
    public void cry() {
        System.out.println("喵喵喵，我是小猫！");
    }

    @Override
    public String getAnimalName() {
        return "小猫";
    }
}

Example.java
public class Example {
    public static void main(String[] args) {
        Animal animal ;//声明接口变量
        animal=new  Dog();//接口变量中存放对象的引用
        System.out.println(animal.getAnimalName());//接口回调
        animal.cry();//接口回调
        animal=new Cat();
        System.out.println(animal.getAnimalName());
        animal.cry();
    }
}

运行结果

第四节、接口与多态

上节说到接口回调，就是指把实现接口的类的对象的引用赋值给接口变量后，该接口变量就可以回调类重写的方法。由接口产生的多态就是指不同的类在实现同一个接口时可能具有不同的实现方式，那么接口变量在回调时就有可能产生多种结果。

比如说在下列例子3中，有两个正数a、b，并且定义了一个加法类与一个减法类，分别实现了不同的功能。

例子3:

Mathematics.java
public interface Mathematics {//数学运算接口
    public int result(int a,int b);
}

Addition.java
public class Addition implements Mathematics{//定义一个加法类实现数学运算接口
    @Override
    public int result(int a, int b) {
        int sum;//定义一个和
        sum=a+b;
        return sum;
    }
}

Subtraction.java
public class Subtraction implements Mathematics{

    @Override
    public int result(int a, int b) {
        int Poor;//定义一个差
        if (a>b){
            Poor=a-b;
        }else {
            Poor=b-a;
        }
        return Poor;
    }
}


Test.java
public class Test {
    public static void main(String[] args) {
        Mathematics mathematics;
        int a=4;
        int b=9;
        mathematics=new Addition();
        int sum=mathematics.result(a,b);
        System.out.printf("%d与%d的和为:%d",a,b,sum);
        System.out.println();
        mathematics=new Subtraction();
        int Poor=mathematics.result(a,b);
        System.out.printf("%d与%d的差为:%d",a,b,Poor);
    }
}

运行结果：

第五节、接口参数

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

例子4：

SayLove.java
public interface SayLove {
    void sayLove();
}


China.java
public class China implements SayLove{

    @Override
    public void sayLove() {
        System.out.println("在中国说：我爱你");
    }
}

UK.java
public class UK implements SayLove{

    @Override
    public void sayLove() {
        System.out.println("在英国说：I love you");
    }
}

Love.java
public class Love {
    public  void  love(SayLove S){//接口类型参数
        S.sayLove();//接口回调
    }
}

Example.java
public class Example {
    public static void main(String[] args) {
        Love L=new Love();
        L.love(new China());
        L.love(new UK());
    }
}

运行结果

总结

以上就是今天要讲的内容，本文介绍了接口回调、接口的多态与接口参数。