目錄
接口介紹
類：內部封裝了成員變量、構造方法和成員方法
接口：是Java語言中一種引用類型，是方法的集合
注意：
- 接口是沒有靜態代碼塊或者構造方法的。
- 一個類的直接父類是唯一的，但是一個類可以同時實現多個接口。
- 接口不能創建對象，只能用接口的實現類創建對象
- 接口中的抽象方法在接口實現類中全部實現
- 如果實現類所實現的多個接口當中，存在重複的抽象方法，那麼只需要覆蓋重寫一次即可。
- 如果實現類沒有覆蓋重寫所有接口當中的所有抽象方法，那麼實現類就必須是一個抽象類。
- 如果實現類在實現的多個接口當中，存在重複的默認方法，那麼實現類一定要對沖突的默認方法進行覆蓋重寫。
- 一個類如果繼承父類當中的方法，和接口當中的默認方法產生了衝突，優先用父類當中的方法。
定義接口格式
public interface 接口名稱 {
// 抽象方法
// 默認方法
// 靜態方法
// 私有方法
}
不同版本的接口
如果是Java 7，那麼接口中可以包含的內容有：
1. 常量
2. 抽象方法
如果是Java 8，還可以額外包含有：
3. 默認方法
4. 靜態方法
如果是Java 9，還可以額外包含有：
5. 私有方法
列：創建不同版本中新增接口
java 7中新增抽象方法
public interface InterFaceName {
public abstract void method();
}
java 8中新增默認方法和靜態方法
public interface InterFaceName {
public default void method() {//默認方法
// 執行語句
}
public static void method2() {//靜態方法
// 執行語句 }
}
}
java 9中新增私有方法
public interface InterFaceName{
private void method(){
//執行語句
}
}
接口中的常量
接口當中也可以定義“成員變量”，但是必須使用public static final三個關鍵字進行修飾。一旦使用，值不可以改變
格式：
public static final 數據類型 常量名稱 = 數據值;
注意事項：
1. 接口當中的常量，可以省略public static final，注意：不寫也照樣是這樣。
2. 接口當中的常量，必須進行賦值；不能不賦值。
3. 接口中常量的名稱，使用完全大寫的字母，用下劃線進行分隔。（推薦命名規則）
列：接口中的常量練習
public interface MyInterfaceConst {
// 這其實就是一個常量，一旦賦值，不可以修改
public static final int NUM_OF_MY_CLASS = 12;
}
測試
public static void main(String[] args) {
// 訪問接口當中的常量
System.out.println(MyInterfaceConst.NUM_OF_MY_CLASS);
}
接口中的默認方法
1. 接口的默認方法，可以通過接口實現類對象，直接調用。
2. 接口的默認方法，也可以被接口實現類進行覆蓋重寫。
列：默認方法與抽象方法練習
創建接口
public interface MyInterfaceDefault {
// 抽象方法
public abstract void methodAbs();
// 抽象方法
// public abstract void methodAbs2();
// 默認方法
public default void methodDefault() {
System.out.println("這是新添加的默認方法");
}
}
接口實現類
接口中的抽象方法必須全部實現，默認方法可以不實現
MyInterfaceDefaultA與MyInterfaceDefaultB
public class MyInterfaceDefaultA implements MyInterfaceDefault {
@Override
public void methodAbs() {
System.out.println("我實現了接口中的抽象方法");
}
}
public class MyInterfaceDefaultB implements MyInterfaceDefault {
@Override
public void methodAbs() {
System.out.println("實現了抽象方法，BBB");
}
@Override
public void methodDefault() {
System.out.println("實現類B覆蓋重寫了接口的默認方法");
}
}
測試
當對象使用接口的默認方法時，如果實現類中沒有默認方法，會向上找默認方法
public static void main(String[] args) {
// 創建了實現類對象
MyInterfaceDefaultA a = new MyInterfaceDefaultA();
a.methodAbs(); // 調用抽象方法，實際運行的是右側實現類。
a.methodDefault(); // 調用默認方法，如果實現類當中沒有，會向上找接口
System.out.println("==========");
MyInterfaceDefaultB b = new MyInterfaceDefaultB();
b.methodAbs();//b類抽象方法
b.methodDefault(); // 實現類B覆蓋重寫了接口的默認方法
}
結果：
接口中的靜態方法
從Java 8開始，接口當中允許定義靜態方法。
注意事項：不能通過接口實現類的對象來調用接口當中的靜態方法。正確用法：通過接口名稱，直接調用其中的靜態方法。
格式：
public static 返回值類型 方法名稱(參數列表) {
方法體
}
列：實現接口中的靜態方法
創建接口
public interface MyInterfaceStatic {
public static void methodStatic() {
System.out.println("這是接口的靜態方法！");
}
}
創建接口實現類
public class MyInterfaceStaticImpl implements MyInterfaceStatic {
}
測試
public static void main(String[] args) {
// 創建了實現類對象
MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();
// 錯誤寫法！
// impl.methodStatic();
MyInterfaceStatic.methodStatic();// 直接通過接口名稱調用靜態方法
}
結果：
接口中的私有方法
從Java 9開始，接口當中允許定義私有方法。
普通私有方法格式：解決多個默認方法之間重複代碼問題
private 返回值類型 方法名稱(參數列表) {
方法體
}
靜態私有方法：解決多個靜態方法之間重複代碼問題
private static 返回值類型 方法名稱(參數列表) {
方法體
}
列:接口中普通私有方法的使用
接口
public interface MyInterfacePrivateA {
//默認方法
public default void methodDefault1() {
System.out.println("默認方法1");
methodCommon();
}
public default void methodDefault2() {
System.out.println("默認方法2");
methodCommon();
}
//普通私有方法
private void methodCommon() {
System.out.println("AAA");
System.out.println("BBB");
System.out.println("CCC");
}
}
接口實現類
public class MyInterfacePrivateAImpl implements MyInterfacePrivateA {
public void methodAnother() {
// 直接訪問到了接口中的普通私有方法，這樣是錯誤的！
// methodCommon();
}
}
列：接口中靜態私有方法的使用
接口
public interface MyInterfacePrivateB {
//接口中靜態方法
public static void methodStatic1() {
System.out.println("靜態方法1");
methodStaticCommon();
}
public static void methodStatic2() {
System.out.println("靜態方法2");
methodStaticCommon();
}
//接口中靜態私有方法
private static void methodStaticCommon() {
System.out.println("AAA");
System.out.println("BBB");
System.out.println("CCC");
}
}
測試
public static void main(String[] args) {
MyInterfacePrivateB.methodStatic1();
MyInterfacePrivateB.methodStatic2();
// 錯誤寫法！
// MyInterfacePrivateB.methodStaticCommon();
}
結果
接口與接口之間的繼承
類與類之間是單繼承，接口與接口之間是多繼承
列：接口與接口之間多繼承的練習
父類接口
public interface MyInterfaceA {
public abstract void methodA();
public abstract void methodCommon();
public default void methodDefault() {
System.out.println("AAA");
}
}
父類接口
public interface MyInterfaceB {
public abstract void methodB();
public abstract void methodCommon();
public default void methodDefault() {
System.out.println("BBB");
}
}
子類接口
子類接口繼承兩個父類接口，當父類接口中的默認方法重複時，子類接口必須重寫此重複的方法
public interface MyInterface extends MyInterfaceA, MyInterfaceB {
public abstract void method();
//子類接口重寫了父類接口中重複的方法
@Override
public default void methodDefault() {
}
}
接口實現類
如果實現類所實現的多個接口當中，存在重複的抽象方法，那麼必須覆蓋重寫一次即可
public class MyInterfaceImpl implements MyInterface {
//子類接口抽象方法
@Override
public void method() {
}
//父類A接口抽象方法
@Override
public void methodA() {
}
//父類B接口抽象方法
@Override
public void methodB() {
}
// 父類A與父類B接口的重複的抽象方法
//如果實現類所實現的多個接口當中，存在重複的抽象方法，那麼必須覆蓋重寫一次即可
@Override
public void methodCommon() {
}
}