1. 概述
Java語言不支持一個類有多個直接的父類(多繼承),但可以實現（implements）多個接口，間接的實現多繼承，但是一個接口可以繼承多個接口。
接口是Java語言中一種引用類型，是方法的集合，如果說類的內部封裝了成員變量、構造方法和成員方法，那麼，接口的內部主要就是封裝了方法，包含抽象方法（JDK7），默認方法和靜態方法（JDK8），私有方法（JDK9）。
接口的使用，它不能創建對象，但是可以被實現（ implements ，類似於被繼承）。一個實現接口的類（可以看做是接口的子類），需要實現接口中所有的抽象方法，創建該類對象，就可以調用方法了，否則它必須是一個抽象
類。
2. 接口定義格式
接口的定義，它與定義類方式相似，但是使用 interface 關鍵字。它也會被編譯成.class文件，但一定要明確它並不是類，而是另外一種引用數據類型。
// 定義格式
public interface 接口名稱 {
// 抽象方法
// 默認方法
// 靜態方法
// 私有方法
}抽象方法：使用abstract關鍵字修飾，可以省略，沒有方法體，該方法供子類實現使用。
// 定義格式
public interface 接口名稱 {
public abstract void method();
}默認方法：使用 default 修飾，不可省略，供子類調用或者子類重寫。
靜態方法：使用 static 修飾，供接口直接調用。(也就是說不需要定義對象，直接調用類的)
public interface InterFaceName {
public default void method() {
// 執行語句
}
public static void method2() {
// 執行語句
}
}私有方法：使用 private 修飾，供接口中的默認方法或者靜態方法調用。
public interface InterFaceName {
private void method() {
// 執行語句
}
}3. 接口的實現
類與接口的關係爲實現關係，即類實現接口，該類可以稱爲接口的實現類，也可以稱爲接口的子類。實現的動作類似繼承，格式相仿，只是關鍵字不同，實現使用 implements 關鍵字。
非抽象子類實現接口：
- 必須重寫接口中所有抽象方法。
- 繼承了接口的默認方法，即可以直接調用，也可以重寫。
3.1抽象方法的使用
1.定義接口：
public interface LiveAble {
// 定義抽象方法
public abstract void eat();
public abstract void sleep();
}2.定義實現類：
public class Animal implements LiveAble {
@Override
public void eat() {
System.out.println("吃東西");
}
@Override
public void sleep() {
System.out.println("晚上睡");
}
}3.定義測試類
public class InterfaceDemo {
public static void main(String[] args) {
// 創建子類對象
Animal a = new Animal();
// 調用實現後的方法
a.eat();
a.sleep();
}
}
輸出結果：
吃東西
晚上睡3.2 默認方法的使用
可以繼承，可以重寫，二選一，但是隻能通過實現類的對象來調用。
繼承默認方法
定義接口：
public interface LiveAble {
public default void fly(){
System.out.println("天上飛");
}
}定義實現類：
public class Animal implements LiveAble {
// 繼承，什麼都不用寫，直接調用
}定義測試類：
public class InterfaceDemo {
public static void main(String[] args) {
// 創建子類對象
Animal a = new Animal();
// 調用默認方法
a.fly();
}
}
輸出結果：
天上飛重寫默認方法
定義接口：
public interface LiveAble {
public default void fly(){
System.out.println("天上飛");
}
}定義實現類：
public class Animal implements LiveAble {
@Override
public void fly() {
System.out.println("自由自在地飛");
}
}定義測試類：
public class InterfaceDemo {
public static void main(String[] args) {
// 創建子類對象
Animal a = new Animal();
// 調用重寫方法
a.fly();
}
}
輸出結果：
自由自在的飛3.3 靜態方法的使用
靜態與.class 文件相關，只能使用接口名調用，不可以通過實現類的類名或者實現類的對象調用。
定義接口：
public interface LiveAble {
public static void run(){
System.out.println("跑起來~~~");
}
}定義實現類：
public class Animal implements LiveAble {
// 無法重寫靜態方法
}定義測試類：
public class InterfaceDemo {
public static void main(String[] args) {
// Animal.run(); // 【錯誤】無法繼承方法,也無法調用
LiveAble.run(); //
}
}
輸出結果：
跑起來~~~3.3 私有方法的使用
私有方法：只有默認方法可以調用。
私有靜態方法：默認方法和靜態方法可以調用。
如果一個接口中有多個默認方法，並且方法中有重複的內容，那麼可以抽取出來，封裝到私有方法中，供默認方法去調用。
定義接口：
public interface LiveAble {
default void func(){
func1();
func2();
}
private void func1(){
System.out.println("跑起來~~~");
}
private void func2(){
System.out.println("跑起來~~~");
}
}4. 接口的多實現
在繼承體系中，一個類只能繼承一個父類。而對於接口而言，一個類是可以實現多個接口的，這叫做接口的多實現。並且，一個類能繼承一個父類，同時實現多個接口。
4.1 抽象方法
接口中有多個抽象方法時，實現類必須重寫所有抽象方法。如果抽象方法有重名的，只需要重寫一次。
定義多個接口：
interface A {
public abstract void showA();
public abstract void show();
}
interface B {
public abstract void showB();
public abstract void show();
}定義實現類：
public class C implements A,B{
@Override
public void showA() {
System.out.println("showA");
}
@Override
public void showB() {
System.out.println("showB");
}
@Override
public void show() {
System.out.println("show");
}
}4.2 默認方法
接口中有多個默認方法時，實現類都可繼承使用。如果默認方法有重名的，必須重寫一次。
定義多個接口：
interface A {
public default void methodA(){}
public default void method(){}
}
interface B {
public default void methodB(){}
public default void method(){}
}定義實現類：
public class C implements A,B{
@Override
public void method() {
System.out.println("method");
}
}4.3 靜態方法
接口中，存在同名的靜態方法並不會衝突，原因是隻能通過各自接口名訪問靜態方法。
