1、基本概念

介面是Java中最重要的概念，介面可以理解為是一種特殊的類，裡面全部都是由全域性的公共常量和抽象方法組成。

換言之，如果一個類中完全是由全域性常量和抽象方法組成，那就可以定義為一個介面

介面定義格式：

interface 介面名 {
全域性常量;
抽象方法;
}

interface A {  // 定義介面A
	private static final String AUTOOR = "HLY";  // 全域性常量
	private abstract void print();		// 抽象方法
	private abstract String getInfo
 
();	// 抽象方法
}

對於介面來講，因為在一開始定義的時候就明確其組成是全域性常量和抽象方法，於是可以簡化如下：

interface A {  // 定義介面A
	String AUTOOR = "HLY";  // 全域性常量
	void print();		// 抽象方法
	String getInfo();	// 抽象方法
}

以上兩種定義完全一樣，沒有任何差別。

2、實現介面

與抽象類一樣，要實現介面必須使用子類，子類通過implement關鍵字實現介面
格式如下：

class 子類 implements 介面A,介面B,...{
	// 
} 

我們看一下具體例子

interface
 
 IA{   // 定義介面 IA
    String AUTHOR = "YHL";
    void print();
    String getInfo();

}

interface IB{   // 定義介面 IB
    void say();
}

class ChildX implements IA,IB{ // 子類實現介面IA,IB
    public void print(){ // 實現print方法
        System.out.println("作者：" + AUTHOR);
    }

    public String getInfo(){	// 實現getInfo方法
 

        return "HELLO";
    }

    public void say(){	// 實現say方法
        System.out.println("hello, " + AUTHOR);
    }
}
public class InterfaceDemo {
    public static void main(String[] args) {
        ChildX x = new ChildX();
        x.print();
        x.say();
    }
}

// 執行結果
作者：YHL
hello, YHL

2、繼承抽象類實現介面

一個子類可以同時繼承抽象類和實現介面
格式如下：

class 子類 extends 抽象類 implements 介面A,介面B...{
}

interface IA{   // 定義介面 IA
    String AUTHOR = "YHL";
    void print();
    String getInfo();

}

abstract class IB{   // 定義介面 IB
    public abstract void say();
}

class ChildX extends IB implements IA{
    public void print(){
        System.out.println("作者：" + AUTHOR);
    }

    public String getInfo(){
        return "HELLO";
    }

    public void say(){
        System.out.println("hello, " + AUTHOR);
    }
}
public class InterfaceDemo {
    public static void main(String[] args) {
        ChildX x = new ChildX();
        x.print();
        x.say();
    }
}

// 執行結果
作者：YHL
hello, YHL

在使用中，一個抽象類可以實現一個介面，那麼對於抽象類的子類則必須實現介面和抽象類定義的所有抽象方法。

interface IA{   // 定義介面 IA
    String AUTHOR = "YHL";
    void print();
    String getInfo();

}

abstract class IB implements IA{   // 抽象類 IB 實現介面IA
    public abstract void say();
}

class ChildX extends IB{	// ChildX類繼承 IB類，並實現所有抽象方法
    public void print(){
        System.out.println("作者：" + AUTHOR);
    }

    public String getInfo(){
        return "HELLO";
    }

    public void say(){
        System.out.println("hello, " + AUTHOR);
    }
}
public class InterfaceDemo {
    public static void main(String[] args) {
        ChildX x = new ChildX();
        x.print();
        x.say();
    }
}

// 執行結果
作者：YHL
hello, YHL

3、介面的繼承

一個介面不能繼承抽象類，但是可以利用extends關鍵字繼承多個介面，實現介面的多繼承。
格式：

interface 子介面 extends 父介面A,父介面B,...{
}

interface A { // 介面A 
	String AUTHOR = "YHL";  // 全域性常量
	void printA();	// 抽象方法printA
}

interface B {
	void printB();
}

interface C extends A,B{  // 介面C繼承介面A、B
	void printC()
}

class X implements C{
	public void printA(){
		System.out.println("Hello, printA")
	}
	
	public void printB(){
		System.out.println("Hello, printB")
	}
	
	public void printC(){
		System.out.println("Hello, printC")
	}
}

public class Demo{
	public static void main(String args[]){
		X x = new X();
		x.printA();
		x.printB();
		x.printC();
	}
}

一個介面可以繼承多個介面，一個抽象類可以實現一個介面，但是一個介面不能繼承一個抽象類。