Java编程基础——接口

接口概述

​ 接口是在Java编程语言中的一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

​ 在工作中，一方面，有时必须从几个类中派生出一个子类，继承他们所有的属性和方法。但是，Java不支持多重继承，这时，接口就派上了用场，有了接口，就可以得到多重继承的效果。

​ 另一方面，有时必须从几个类中抽取一些共同的行为特征，他们之间又不是纯粹的继承关系，仅仅是具有相同的行为特征而已，这时也可以使用接口来进行这种行为特征的抽取。

​ 总的来说，可以把接口理解成一种规范，即接口定义的是一组规则，其本质是契约、标准、规范，就像法律一样，制定好后大家都要遵守(如果某类要实现某接口，就必须实现接口中的抽象方法)。

接口的使用

1.接口使用interface来定义

2.Java中，接口和类是并列的两个结构

3.接口的定义：定义接口中的成员

3.1 JDK7及以前：只能定义全局常量和抽象方法

​ 全局常量：public static final *** （可以省略不写）

​ 抽象方法：public abstract *** （可以省略不写）

 interface Flyable{
    //全称定义全局常量
    public static final int MAX_SPEED = 7900;
    //省略之后仍是全局常量
    int MIN_SPEED = 1;
    //抽象方法
    public abstract void fly();
    //省略之后仍是抽象方法
   void stop();
}  

3.2 JDK8：除了定义全局常量和静态方法之外，还可以定义静态方法、默认方法。（下一部分）

4.接口中不能定义构造器，也就意味着接口是不可以实例化的。

5.Java开发中，接口是通过让类去实现（implements）来使用的,如果实现类覆盖了接口中的所有方法，则此实现类可以实例化，否则实现类为一个抽象类。当类既继承某个类又实现某个接口时，先写extends，后写implements。

 class Plane extends machine implements Flyable{
    
    //实现了接口中的抽象方法，可以实例化
    
    @Override
    public void fly(){
        System.out.println("飞机起飞");
    }
    
    @Override
    public void stop(){
        System.out.println("飞机降落");
    }
}  

6.Java类可以实现多个接口

 interface Attackable{
    void attack();
}
//不同的接口之间用逗号隔开
class Bullet implements FlyAble,Attackable{
    //实现所有接口中的所有抽象方法
    @Override
    public void fly(){
        System.out.println("让子弹飞");
    }
    
    @Override
    public void stop(){
        System.out.println("子弹打到人了");
    }
    
    @Override
    public void attack(){
        System.out.println("子弹有攻击性")
    }
}  

7.接口和接口之间可以多继承

 interface AA{
    
}
interface BB{
    
}
interface CC extends AA,BB{
    
}  

8.接口的具体使用（体现多态性）

9.接口实际上可以看做一种规范

 
public class USBTest {

    public static void main(String[] args) {
        Computer computer = new Computer();
        //多态性的体现，直接将实现类的对象传进去，该类实现了USB中的抽象方法
        computer.transferData(new Flash());
    }
}


class Computer{
//制定USB数据传输的规范，所以在具体的USB设备中需要对USB接口中的方法进行实现
    public void transferData(USB usb){
        usb.start();
        System.out.println("***********************************");
        usb.stop();
    }
}

class Flash implements USB{
//USB方法的实现
    @Override
    public void start() {
        System.out.println("Flash start");
    }

    @Override
    public void stop() {
        System.out.println("Flash stop");
    }
}
//USB接口的规范
interface USB{
    //定义一些常量，比如USB接口的长宽高。
    void start();
    void stop();
}  

JDK8中接口的新特性

​ 除了定义全局常量和静态方法之外，在JDK8中还可以定义静态方法、默认方法。

 public interface CompareA {

    //静态方法
    public static void method1(){
        System.out.println("CompareA:method1!");
    }

    //默认方法
    public default void method2(){
        System.out.println("CompareA:method2!");
    }

    default void method3(){
        System.out.println("CompareA:method3!");
    }
}  

在具体使用时为了演示，首先定义了两个接口和一个类作为父类。

 public interface CompareA {

    //静态方法
    public static void method1(){
        System.out.println("CompareA:method1!");
    }

    //默认方法
    public default void method2(){
        System.out.println("CompareA:method2!");
    }

    default void method3(){
        System.out.println("CompareA:method3!");
    }

    default void method4(){
        System.out.println("CompareA:method4!");
    }

    default void method5(){
        System.out.println("CompareA:method5!");
    }
}

public interface CompareB {

    default void method5(){
        System.out.println("CompareB:method5!");
    }
}

public class SuperClass {

     public void method4(){
        System.out.println("SuperClass:method4!");
    }
    
    public void method5(){
        System.out.println("SuperClass:method5!");
    }
}  

在真正使用时，有以下可能遇到的情况

 public class SubClassTest {
    public static void main(String[] args) {

        //接口中定义的静态方法只能通过接口来调用
        CompareA.method1();

        //接口中定义的默认方法可以通过实现类的对象来调用
        SubClass s = new SubClass();
        s.method2();

        //如果实现类中重写了接口中的默认方法，调用时仍然调用实现类中重写的方法
        s.method3();

        //如果子类（实现类）继承的父类和实现的接口中声明了同名同参数的方法默认，那
        //么子类在没有重写该方法的情况下，默认调用的是父类中的同名同参数方法（类优先原则）。
        s.method4();

        //如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类
        //没有重写此方法的情况下将会报错（接口冲突）。这就时就需要重写此方法。
        s.method5();


    }
}

class SubClass extends SuperClass implements CompareA,CompareB{

    public void method3() {
        System.out.println("SubClass:method3!");
    }

    @Override
    public void method5() {
        System.out.println("SubClass:method5!");
    }
//如果在子类（实现类）中想要调用父类的方法、接口中的默认方法，可以使用super关键字。
    public void myMethod(){
        //调用自己重写的方法
        method5();
        //调用父类中声明的方法
        super.method5();
        //调用接口中的默认方法
        CompareA.super.method5();
        CompareB.super.method5();
    }
}  

写这个的目的一方面是复习一下Java的相关知识，另外也相当于做个标记，如果之后有相关问题可以快速找到，这算是第一篇笔记，之后可能会陆续上传许多学习过程中的笔记，如果有问题可以直接评论，我会做相应修改的。

如果对我写的文章感兴趣，或者想获取架构进阶以及大厂面试资料的可以加入我的 [Java架构社区] 373786412 免费获取，并相互交流学习！