碼上歡樂
相關內容    簡體    繁體

接口(interface)

本文轉載自   查看原文   2021-12-02 14:55   95    java

接口【不允許出現普通的成員方法，沒有構造方法】

概述

  • 接口，是java語言中的一種引用類型，是【方法的集合】，如果說類的內部封裝了成員變量，構造方法和成員方法，那么接口的內部主要就是【封裝了方法】，包含了抽象方法【JDK1.7及以前】，默認方法和靜態的方法【JDK.18】，私有方法【JDK1.9】
  • 接口的定義和類很相似，不在使用class關鍵字進行聲明，而是用interface關鍵字進行聲明
    定義格式
    public interface 接口名稱{
	//接口內容
	//抽象方法為主
}
//接口就是多個類的公共規范。接口也是一種引用數據類型。如，類，數組，接口。
//備注：源文件還是.java，編譯之后生成的字節碼文件還是.class   .java~~~~.class
//JDK1.7那么接口中包含的內容
  //1.靜態常量 public static final
  //2.抽象方法 public abstract 
//JDK1.8
  //3.默認方法 default 返回值類型 method(){}  
  //4.靜態方法 public 返回值類型 method(){}
//JDK1.9
  //5.私有方法 private 返回值類型 moethod(){}

接口的使用步驟

  1. 接口是不能直接使用的，必須有一個“實現類”(普通類)來“實現”該接口。
    使用格式
    public class 實現類名稱 implements 接口名稱{
  //類的成員信息
}
  2. 接口的實現類必須重寫（實現）接口中的所有方法。
    實現：去掉abstract關鍵字，分號換成大括號。
  3. 創建實現類的對象，進行使用。

tips
注意事項
如果實現類當中沒有重寫接口當中的所有的抽象方法，那么這個實現類自己必須是一個抽象類

接口中的方法

  1. 抽象方法：使用abstract關鍵字修飾，沒有方法體內容，該方法內容主要是供子類使用的

    public interface InterfaceName{
	public abstract void method(){
		//public abstract 可以省略不寫
	}
}

  2. 默認方法和靜態方法
    默認方法：使用default關鍵字修飾的方法，不可省略，供子類調用或者子類重寫。
    靜態方法：使用static關鍵字修飾的方法，共接口直接調用。

  3. 含有的私有方法和私有靜態的方法
    私有方法：使用private關鍵字，提供接口中的默認方法或者靜態方法調用。

    public interface InterfaceName{
	private void moethod(){
		//方法體內容
	}
}

基本的實現

  • 實現的概述
    類於接口的關系，為實現關系。即類實現接口，該類可以稱為接口的實現類，也可以稱為接口的子類。實現的動作類似於繼承，格式相仿，只是關鍵字不同，實現使用【implements】關鍵字

  • 非抽象類實現接口：

    1. 必須重寫接口當中的所有的抽象方法
    2. 繼承了接口當中的默認方法，即可以直接調用，也可以重寫。
    //格式
public class 實現類 implements 接口名稱{
	//重寫接口當中的所有的抽象方法
	//重寫接口當中的默認方法【可選】
}

  • 抽象方法的使用
    必須全部實現

    //定義一個接口
public interface Biological{//生物
	//定義一個吃東西的功能
	public abstract void eat();
	//定義一個休息的功能
	public abstract void sleep();
}
//定義一個實現類
public class Animal implements Biological{
	//重寫接口中的方法
	@Override
	public void eat(){
		Systen.out.println("吃東西");
	}
	@Override
	public void sleep(){
		Systen.out.println("睡覺");
	}
}
public class Text{
	public static void main(String[] args){
		Animal a=new Animal();
		a.eat();//吃東西
		a.sleep();//睡覺
	}
}

  • 默認方法的使用
    可以繼承，可以重寫，二選一，但是只能通過實現類的對象來調用

    1. 繼承默認方法
    //定義接口類 
public interface Biological{//生物
	public default void fly(){
		System.out.println("天上飛");
	}
}
//定義實現類
public class Animal implements Biological{
	//繼承 什么也不寫，直接調用
}
public class Text{
	public static void main(String[] args){
		//創建子類對象
		Animal a=new Animal();
		//調用默認方法
		a.fly();//天上飛
	}
}
    1. 重寫默認的方法
    //定義接口類 
public interface Biological{//生物
	public default void fly(){
		System.out.println("天上飛");
	}
}
//定義實現類
public class Animal implements Biological{
	@Oberride
	public void fly(){
		System.out.println("自由自在的飛");
	}
}
public class Text{
	public static void main(String[] args){
		//創建子類對象
		Animal a=new Animal();
		//使用子類的方法
		a.fly();//自由自在的飛
	}
}

  • 靜態方法的使用
    靜態的一般都是和類.class文件相關，【只能】使用【接口名】來調用，不可以通過實現類的類名或者實現類的對象來調用

    //定義接口類 
public interface Biological{//生物
	public static void run(){
		System.out.println("跑跑");
	}
}
//定義實現類
public class Animal implements Biological{
	//無法重寫靜態方法
}
public class Text{
	public static void main(String[] args){
		//Animal.run();//錯誤的操作，無法繼承，也無法調用        
		Biological.run();//跑跑
	}
}

  • 私有方法的使用
    私有方法：只有默認方法可以調用
    私有的靜態方法：默認方法和靜態方法都可以調用
    如果一個接口中有多個默認方法，並且方法中有重復的內容，那么可以抽取出來，封裝到私有方法中，供默認方法去調用。從設計的角度考慮，私有的方法是對默認的方法和靜態的方法的一種輔助，

    //定義接口類 
public interface Biological{//生物     
	private static void run(){         
		System.out.println("跑起來，跑起來");     
	} 
	public default void funMethod(){
		run();
	}
}

接口的多實現

  • 在繼承體系中，一個類只能直接繼承一個父類，而對於接口來說，一個類可以實現多個接口，這叫接口的【多實現】。並且，一個類能直接繼承一個父類同時還可以實現多個接口。一個接口可以繼承多個接口。

    public class Zi extends Fu implements 接口1,接口2，...{
	//重寫接口中的所有抽象方法
	//重寫接口中的默認的方法【可選】
	//抽象方法重名
}

  • 抽象方法
    接口中，有多個抽象方法，實現類必須重寫所有的抽象方法，如果抽象方法有重名的，只需要重寫一次即可

    //定義多個接口
public interface Animal{
	public abstract void eat();
	public abstract void run();
} 
public interface Human{
	pubic abstract void eat();
	pubic abstract void run();
}
//定義實現類
public class People implements Animal,Human{
	@Override
	public void eat(){
		System.out.println("吃東西！");
	}
	@Override
	public void run(){
		System.out.println("健身！");
	}
}

  • 默認方法
    接口中，有多個默認方法是，實現類都可繼承使用，如果默認方法有重名的，【必須重寫一次】

    public interface A{
	public default void methodA{}
	public default void method{}
}
public interface B{
	public default void methodB{}
	public default void method{}
}
//定義實現類
public class C implements A,B{
	@Override
	public void method(){
		System.out.println("method的方法被調用");
	} 
}

  • 靜態方法
    接口中，如果存在同名的靜態方法並不會沖突，原因是只能通過各自的接口名訪問靜態方法。

  • 優先級的問題
    當一個類，即繼承了一個父類，又同時實現了多個接口，父類中的成員與接口當中的默認方法重名，【子類就近選擇執行父類的成員方法】。

    //定義接口
public interface A{
	public default void methodA(){
		System.out.println("AAAAA");
	}
}
//定義父類
public class D{
	public void methodA{
		System.out.println("DDDDD");
	}
}
//定義子類
public class E extends D implements A{
	//為重寫methodA();方法
}
//測試類
public class Text{
	public static void main(String[] args){
		E e=new E();
		e.methodA();//DDDDD
	}
}

  • 接口的多繼承
    一個接口能繼承另一個或者多個接口，這和類之間的繼承向比較相似。接口的繼承使用extends關鍵字，子接口繼承接口的方法，如果父接口中的默認方法有重名方法，那么子接口需要重寫一次。

    public interface A{
	public default void method(){
		System.out.println("AAAAA");
	}
}
public interface B{
	public default void method(){
		System.out.println("BBBBB");
	}
}
//定義接口繼承接口
public interface C extends A,B{
	@Oberride
	public default void method(){
		Systemj.out.println();
	}
}
//子接口重寫默認方法，【default關鍵字保留】。

  • 其他成員變量的特點

    1. 接口中，無法定義成員變量，但是可以定義常量，因為值不可變，默認使用public static final 修飾的
    2. 接口中，沒有構造方法，不能創建對象
    3. 接口當中，沒有靜態代碼塊

  • 接口的好處

    1. 定義規則
    2. 減低低耦合。【高內聚，低耦合】
    3. 擴展原有的類的功能


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 接口（interface） 接口（interface） 接口（interface） Interface接口 接口(interface) 接口（interface） 接口(interface) TypeScript 中的interface接口 typescript 接口 interface 接口（interface）那點事
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM