【Java课堂】接口详解

🎈目录🎈

1、接口的概念

2、语法规则

实现接口几条规范🔑

3、接口的使用

4、实现多个接口

5、接口间的继承

---

1、接口的概念

        接口顾名思义，就是我们身边常用的行为规范。而接口在我们身边比比皆是，就比如电脑上的USB接口。USB接口插入U盘、鼠标、键盘....所有符合USB协议的设备，它把我们能用到的设备插头都统一起来，使得我们不用买大量的转换器，方便我们使用。

总结来说：接口就是公共的行为规范，大家在实现时，只要符合规范标准，就可以通用。

在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

2、语法规则

接口的定义格式与定义类的格式基本相同，将class关键字换成interface即可定义接口

interface 接口名称{
    //成员变量  必须要初始化
    public static final int a = 10;
    int b = 10;
 
    //抽象方法
    public abstract void method1();
    void method2();
    
    //接口的默认方法
    default void func()1{
        ...
    }
    //接口静态成员方法
    static void func2(){
        ...
    }
}

实现接口有几条规范需要我们注意

1. 接口当中的成员变量，默认都是 public static final 修饰的
2. 接口当中的成员方法，默认都是抽象方法，public abstract 修饰的
3. 接口当中的普通成员方法，是不能有具体的实现的
4. 接口当中的普通成员方法，如果要有具体实现，必须加上default修饰【从JDK8开始，才有】
5. 接口当中可以有静态的成员方法
6. 接口中不管是静态的方法还是default方法，都是public修饰的

书写接口规范

1. 创建接口时，接口的命名一般以大写字母 I 开头。
2. 接口命名一般使用“形容词”词性的单词。
3. 阿里编码规范中约定，接口中的方法和属性不要加任何修饰符号，保持代码的简洁性。

3、接口的使用

         接口跟抽象类一样不能直接实例化，必须要有一个“实现类”来“实现”该接口，实现接口中的所有抽象方法。而类和接口的关系是使用 implements 来关联的

public class 类名称 implements 接口名称{
// ...
}

注意：子类和父类之间是extends 继承关系，类和接口之间是 implements 实现关系

        当类实现了接口，那么该类就必须实现接口中所有的抽象方法，否则编译器会报错

在IDEA中，有快捷键实现接口中的抽象方法。

首先把鼠标触碰implements，按下Alt+Shift+Enter 或点击 Implement methods 就会出现所有要实现抽象方法，点击OK即可完成

 此外，接口也可以应用具体实现类。【向上转型】

interface  IShape{
    void draw();
}
 
class Rect implements IShape{
    @Override
    public void draw() {
        System.out.println("画一个正方形");
    }
}
 
class Flower implements IShape{
    @Override
    public void draw() {
        System.out.println("画一朵花");
    }
}
 
public class test {
    public static void drawMap(IShape iShape){
        iShape.draw();
    }
    public static void main(String[] args) {
        drawMap(new Rect());
        drawMap(new Flower());
 
        IShape iShape = new Flower();//向上转型
    }
}

 

4、接口的特性

1.接口类型是一种引用类型，但是不能直接new接口的对象

 2.接口中的每一个方法都是 public 的抽象方法，即接口中普通侧成员方法会被隐式指定为 public abstract，且只能是 public abstract，其他修饰符都会报错。

 3.接口中的方法一般不能在接口中实现，基本上都在实现接口的类来实现（在接口中default 修饰的方法可以具体实现）

4.重写接口方法时，所加访问权限必须要大于重写方法的访问权限

        如下，draw() 方法默认是public修饰。Rect类要重写draw方法，就必须要加public，否则会报错

 5.接口中可以含有变量，但是会被隐式指定为 public static final 变量

interface  IShape{
    double kind = 2.0;//默认被：public static final 修饰
    void draw();//默认public
}
public class test {
    public static void main(String[] args) {
        System.out.println(IShape.kind);//可以通过接口名访问
        
       //IShape.brand = 2.0;//无法为最终变量brand 分配值
 
    }
}

 6.接口中不能有静态代码块和构造方法

 7.接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class

4、实现多个接口

在Java中，一个类只能继承一个父类，不支持多继承，而一个类却可以实现多个接口

接下来我一动物为例来进行讲解，首先先创建一个动物类【抽象类】，类中有成员变量和构造方法

abstract class Animal{
    public String name;
 
    public Animal(String name) {
        this.name = name;
    }
}

同时创建一个 鱼 类和一个鸟类，并继承Animal类

class Fish extends Animal{
    public Fish(String name) {
        super(name);
    }
}
 
class Bird extends Animal{
    public Bird(String name) {
        super(name);
    }
}

 现在我们来思考一下，鱼和鸟都有什么行为、特性？

鱼能吃饭、能游泳

鸟能吃饭、能飞

他们共同的共性是吃饭，不同的特性是游泳和飞

特性分析出来了，那我们该如何实现呢？

我们能不能在Animal类中写 eating、swimming、flying这三个方法，并让子类重写方法？

这样虽然能让Fish类和Bird类获各自的行为，但是鱼也获得了‘上天’【flying】的能下，鸟也获得了‘下海’【swimming】的能力，所以这样想法不行。

 那假设我另创建一个游泳类，在类中实现游泳方法，并让Fish继承，大家想想这样可以吗？答案肯定也是不行的。

 Java中只能单继承，所以这时我们要用接口来实现这一功能

所以我们可以直接定义三个接口，分别为ISwimming、IFlying、IEating。分比让Fish类和Bird类实现，下面以Fish类实现接口为例

此时我们可以定义三个方法来方便我们调用swmming、flying、eating等

这些方法分别用相应的接口接收参数，并在main函数中调用 

 结果如下

 此时如果 bird 能充当 swim 方法的参数吗？很明显不能。因为Bird类没有实现ISwimming接口。但是bird 和 fish 都能调用 eating 方法，这是因为 Fish 和 Bird 类都实现了IEating接口

interface ISwimming{
    void swimming();
}
 
interface IFlying{
    void flying();
}
 
interface IEating{
    void eating();
}
abstract class Animal{
    public String name;
 
    public Animal(String name) {
        this.name = name;
    }
}
 
class Fish extends Animal implements ISwimming,IEating{
    public Fish(String name) {
        super(name);
    }
 
    @Override
    public void swimming() {
        System.out.println(name+"正在游泳");
    }
 
    @Override
    public void eating() {
        System.out.println(name+"正在吃鱼食");
    }
}
 
class Bird extends Animal implements IFlying,IEating{
    public Bird(String name) {
        super(name);
    }
 
    @Override
    public void flying() {
        System.out.println(name+"正在飞");
    }
 
    @Override
    public void eating() {
        System.out.println(name+"正在此鸟粮");
    }
}
 
public class Test {
 
    public static void swim(ISwimming iSwimming){
        iSwimming.swimming();
    }
 
    public static  void fly(IFlying iFlying){
        iFlying.flying();
    }
 
    public static void eat(IEating iEating){
        iEating.eating();
    }
    public static void main(String[] args) {
        Fish fish = new Fish("小鱼");
        swim(fish);
        eat(fish);
        Bird bird = new Bird("小鸟");
        fly(bird);
        eat(bird);
    }
}

 上面代码展示了Java 面向对象编程中最常见的用法：一个类继承一个父类，同时实现多个接口。

继承表达的含义时 is-a 含义，而接口表达的含义时 具有xxxx特性

• 鱼是一种动物，能吃，能游泳
• 鸟也是一种动物，能吃，能飞

 这样设计什么好处呢？可以我们 👨‍💻程序员👩‍💻 时时刻刻记着多态的好处，忘记类型。有了接口之后，类的使用中就不必关注具体类型，而只关注某个类是否具有某种能力。

5、接口间的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。

接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字.

interface IRunning {
    void run();
} 
 
interface ISwimming {
    void swim();
}
 
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
}
 
class Frog implements IAmphibious {
    ...
}

通过接口继承创建一个新的接口 IAmphibious 表示 "两栖的". 此时实现接口创建的 Frog 类, 就继续要实现 run 方法, 也需要实现 swim 方法。

接口间的继承相等于把多个接口合并在一起。