Java接口

前言

接下来我们来学习一下接口的知识，会涉及到多态和抽象类的知识，若大家想了解一下多态的知识可参考我的上一篇博客 —— Javau学习笔记 – 多态和抽象类。

---

接口的概念

官方的概念：Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

对以上概念我的理解是：
接口里只能定义抽象方法，这些方法定义了一个规范，可以被不同的类用重写来实现，且只有实现了接口才可以被使用，被实现的接口具有着不同的行为和功能，可以被不同的类使用。

---

接口的语法

1.使用关键字interface来定义接口

interface Base{
    
}

定义了一个Base接口
也可在创建Java类时，定义一个接口

一般来说，接口以形容词命名，此处只是为了方便解说。

---

2.接口不能被实例化

上面定义了Base的接口，接下来我们来实例化这个接口，验证结论
代码如下

interface Base{
    
}
public class Interface {
    public static void main(String[] args) {

        Base base = new Base();     //此处会报错
    }
}

---

3.接口中的成员变量默认是public static final

也就是即使不写，也会默认为public static final类
既然是final类，也就说明接口内的成员变量不可改变，那么就得初始化成员变量

interface Base{

    String name = "zero";
    int age = 18;
}

---

4.接口中的方法默认是public abstract

既然是abstract修饰的方法，那就是抽象方法，不能具体化方法内容

interface Base{

    void func();     //抽象方法func
}

由于默认是public abstract方法，所以即使不写也会是默认的

---

5.从JDK8开始，由default修饰的方法在接口内可以被具体实现

interface Base{

    default public void func1(){
        System.out.println("basebase");
    }
}

---

6.接口中不能有构造方法

这是由于接口中的成员变量被final修饰，已经不能改变了，接口内的方法也要重写，所以也不怎么需要构造方法

---

7.接口中可以有static修饰的方法

interface Base{

    public static void func3(){
        System.out.println("Base");
    }
}
public class Interface {
    public static void main(String[] args) {

        Base.func3();
    }
}

由于是static修饰，所以可以直接由类名调用

---

8.接口需要被类实现，需要用到关键字implements

interface Base{

    void func();

}
class A implements Base{  //类A实现接口Base

    @Override
    public void func() {            //重写接口中的func方法
        System.out.println("basebase");
    }
}

普通类实现接口，必须重写接口内的抽象方法，当然也必须满足重写的规则
若是抽象类实现接口，则可不用重写，但当普通类继承抽象类时，普通类内还是要重写抽象方法的。

interface Base{  //接口Base

    void func();   
}
abstract class A implements Base{
          //不重写也没有报错
}
class B extends A{   
      //不重写会报错
      
    @Override
    public void func() {
        //具体化方法
    }
}

可以快捷键实现接口
光标在class处+ALT +回车

出现此界面后再按回车
会出现以下画面

出现此画面后再按回车，IDEA会帮我们写好重写的框架

class A implements Base{

    @Override
    public void func() {
        
    }

    @Override
    public void func1() {

    }
}

---

接口的运用

接下来，以代码为媒介，为我们实现几个例子，来具体讲解运用

例1 实现USB接口

以实现一个简单的USB接入电脑为例

首先，实现一个USB接口

public interface USB {
    
    void openDevice();
    
    void closeDevice();
    
}

其次，创建一个键盘类，在键盘类中实现USB接口

public class KeyBoard implements USB {  

    @Override
    public void openDevice() {         //重写

        System.out.println("打开键盘");
    }
    public void keyBoard(){         //键盘特有的方法

        System.out.println("敲击键盘");
    }
    @Override
    public void closeDevice() {      //重写

        System.out.println("关闭键盘");
    }
}

再创建个鼠标类，来实现USB接口

public class Mouse implements USB{
    @Override
    public void openDevice() {         //重写
        
        System.out.println("链接鼠标");
    }
    public void click(){             //鼠标特有的方法
        
        System.out.println("点击鼠标");
    }
    @Override
    public void closeDevice() {      //重写
        
        System.out.println("断开鼠标");
    }
}

接下来，创建个电脑类来接受键盘和鼠标的USB

public class Computer {

    public static void open(){
        System.out.println("打开电脑");
    }

    public static void close(){
        System.out.println("关闭电脑");
    }

    public void useDevice(USB usb){
        Computer.open();
        usb.openDevice();
        
        if(usb instanceof KeyBoard){  //如果usb实例化了键盘
        
            ((KeyBoard) usb).keyBoard();
            //强转，因为usb调用不了键盘特有的方法
            
        } else if (usb instanceof Mouse) {
            ((Mouse) usb).click();
            //同理，强转
        }
        
        usb.closeDevice();
        Computer.close();
    }
}

最后，创建一个test类测试电脑接入键盘和鼠标的情况

public class Test {

    public static void main(String[] args) {
        Computer computer = new Computer();
        KeyBoard keyBoard = new KeyBoard();
        Mouse mouse = new Mouse();
        
        computer.useDevice(keyBoard);
        //键盘USB接入电脑
        
        System.out.println("----------------"); //分隔符
        
        computer.useDevice(mouse);
        //鼠标USB接入电脑
    }
}

//输出
打开电脑
打开键盘
敲击键盘
关闭键盘
关闭电脑
----------------
打开电脑
链接鼠标
点击鼠标
断开鼠标
关闭电脑

---

列1 小结

根据上面的例子，我们已经简单了解了接口的用法
可知，在生活中有USB接口的不只是键盘和鼠标类，可不管是什么类，只要实现了接口，就都可以使用接口。
同时也可以看出，接口虽然不能被实例化，但是可以实例化实现接口的类，也可以实现多态，实现重写，和继承很像

列2 小动物们

既然接口和继承那么像，那为什么会有接口的存在呢？
存在即有理由，让代码带我们去解释吧！

假设我们要定义一个动物抽象类，那么动物通有的是名字，年龄和吃东西的行为。
可在行为上，有些动物会只会跑，有些动物又只会游泳，有些动物两者都会，而一个类只能继承一个类，这时就需要用到接口

abstract class Animal{
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public abstract void eat();
}
interface running{
    void run();
}
interface swimming{
    void swim();
}
interface flying{
    void fly();
}
以上是抽象类Animal和接口的实现
---------------------------------------------------------

class Duck extends Animal implements running,swimming,flying{ 
                          //可见，一个类可以实现多个接口

    public Duck(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(name + "正在进食");
    }

    @Override
    public void run() {
        System.out.println(name + "正在跑步");
    }

    @Override
    public void swim() {
        System.out.println(name + "正在游泳");

    }
    
    @Override
    public void fly() {
        System.out.println(name + "正在飞");
    }
}
--------------------------------------------------------
public class Test {

    public static void main(String[] args) {
        Duck duck = new Duck("唐老鸭",10);
       
    }
}

继承只能有一个，但是接口可以有多个，所以接口极大程度上弥补了一个类不能多继承的问题

也许会有人疑问，会跑的不只有动物呀？
没错，机器人也会跑，但他不是动物，这时继承就限制了发挥，但接口可以由不同的类实现

interface running{
    void run();
}
class Robot implements running{

    @Override
    public void run() {
        System.out.println("机器人在跑");
    }
}
public class Test {

    public static void main(String[] args) {
        Robot robot = new Robot();
        robot.run();
        
    }
}

列2 小结

由上述可得
1.一个类可以实现多个接口，所以接口弥补了继承不能被多个类继承的缺陷
2.接口可以由不同的类实现，使得代码更灵活
3.一个类可以继承一个普通类
一个类可以继承一个抽象类
一个类可以继承普通类/抽象类，同时继承多个接口

结语

以上就是Java接口的基础知识啦
博主还处于学习状态，希望家人们能多指导指导