java開發三年，Java中接口的使用你得知道，否則你憑什麼漲薪

時間  2020-07-23
標籤 java 開發 三年 3年 接口 使用 知道 否則 憑什麼 欄目 Java 简体版
原文   原文鏈接

接口概述:

接口是Java語言中的一種引用類型，是方法的"集合"，因此接口的內部主要就是定義方法，包含常量,抽象方法（JDK 7及之前），額外增長默認方法和靜態方法（JDK 8）,額外增長私有方法(jdk9)。java

接口的定義，它與定義類方式類似，可是使用 interface 關鍵字。它也會被編譯成.class文件，但必定要明確它並非類，而是另一種引用數據類型。面試

public class 類名.java–>.classide

public interface 接口名.java–>.class測試

接口的使用，它不能建立對象，可是能夠被實現（implements ，相似於被繼承）。一個實現接口的類（能夠看作是接口的子類），須要實現接口中全部的抽象方法，建立該類對象，就能夠調用方法了，不然它必須是一個抽象類。code

定義格式

public interface 接口名稱 {
    // 常量
    // 抽象方法
    // 默認方法(jdk8)
    // 靜態方法(jdk8)
    // 私有方法(jdk9)
}

案例

public interface IA {
    // 常量 默認修飾符 public static final  這三個修飾符能夠省略
    public static final int NUM1 = 10;
    int NUM2 = 20;

    // 抽象方法 默認修飾符 public abstract 這2個修飾符能夠省略
    public abstract void method1();
    void method2();

    // 默認方法 默認修飾符 public default public修飾符能夠省略,default不能夠省略
    public default void method3(){
        System.out.println("默認方法 method3");
    }

    default void method4(){
        System.out.println("默認方法 method4");
    }

    // 靜態方法: public static修飾  static修飾符不能夠省略 public能夠省略
    public static void method5(){
        System.out.println("靜態方法 method5");
    }

     // 私有靜態方法 使用private static修飾  不能夠省略
     private static void method6(){
        System.out.println("私有靜態方法 method6");
    }

    // 私有非靜態方法 使用private修飾
    private  void method7(){
        System.out.println("私有靜態方法 method7");
    }
}

public class Test {
    public static void main(String[] args) {

        System.out.println(IA.NUM1);// 10
    }

    // 類中的默認方法,使用默認權限修飾符(空)
    void method(){

    }
}

接口中成員的訪問特色

接口中成員訪問特色概述

接口中成員的訪問特色:
                接口中的常量: 主要是供接口直接使用
                接口中的抽象方法: 供實現類重寫的
                接口中的默認方法: 供實現類繼承的(實現類中能夠直接調用,實現類對象也能夠直接調用)
                接口中的靜態方法: 只供接口直接調用,實現類繼承不了
                接口中的私有方法: 只能在接口中直接調用,實現類繼承不了

案例演示

public interface IA {
    //  接口中的常量: 主要是供接口直接使用
    public static final int NUM = 10;

    // 接口中的抽象方法: 供實現類重寫的
    public abstract void method1();

    // 接口中的默認方法: 供實現類繼承使用(實現類中能夠直接調用,實現類對象也能夠直接調用)
    public default void method2(){
        System.out.println("默認方法method2");
        method4();
        method5();
    }

    // 接口中的靜態方法: 只供接口直接調用,實現類繼承不了
    public static void method3(){
        System.out.println("靜態方法method3");
        method5();
    }

    // 接口中的私有方法: 只能在接口中直接調用,實現類繼承不了
    private void method4(){// 只能在接口的默認方法中調用
        // 方法體
        method5();
    }

    private static void method5(){//
        // 方法體
    }
}

實現類:

public class ImpA implements IA{

   /* @Override
    public void method2() {

    }*/

    @Override
    public void method1() {
        System.out.println("重寫接口中的method1抽象方法");
    }
}

測試類:

public class Test {
    public static void main(String[] args) {

        System.out.println(IA.NUM);// 10

        // 建立實現類對象,訪問NUM常量
        ImpA ia = new ImpA();
        System.out.println(ia.NUM);// 10

        // 調用method2方法
        ia.method2();

        // 經過接口名調用接口中的靜態方法
        IA.method3();
        //ia.method3();// 編譯報錯,
    }
}

多實現時的幾種衝突狀況

公有靜態常量的衝突: 多個父接口中,相同的常量不能被繼承 - 公有抽象方法的衝突: 實現類必須重寫一次
公有默認方法的衝突: 實現類必須重寫
公有靜態方法的衝突: 無影響,由於靜態方法實現類不能繼承
私有方法的衝突: 無影響,由於私有方法只能在本接口中直接訪問,實現類不能繼承
實現類重寫接口中的默認方法,不須要加default對象

公有靜態常量的衝突

實現類不繼承衝突的變量繼承

interface IA{
    public static final int a = 10;
    public static final int b= 20;
}
interface IB{
    public static final int a = 30;
}
class Zi implements IA,IB{
    //只繼承了b，沒有繼承a，由於a衝突了
}

public class Demo {
    public static void main(String[] args) {
        Zi z = new Zi();
     //   System.out.println(z.a);//編譯錯誤
        System.out.println(z.b);
    }
}

公有抽象方法的衝突

實現類只須要重寫一個接口

interface IA{
    public void show();
}
interface IB{
    public void show();
}
class Zi implements IA,IB{
    @Override
    public void show() {//子類只須要重寫一個show()便可
        System.out.println("子類的show()...");
    }
}
public class Demo {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

公有默認方法的衝突

實現類必須重寫一次最終版本文檔

interface IA{
    public default void show(){
        System.out.println("IA");
    }
}
interface IB{
    public default void show(){
        System.out.println("IB");
    }
}
class Zi implements IA,IB{
    @Override
    public void show() {//必須重寫一次的show()
        System.out.println("Zi的show()....");
    }
}
public class Demo {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

公有靜態方法的衝突

靜態方法是直接屬於接口的,不能被繼承,因此不存在衝突it

interface IA{
    public static  void show(){
        System.out.println("IA");
    }
}
interface IB{
    public static void show(){
        System.out.println("IB");
    }
}
class Zi implements IA,IB{

}
public class Demo {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();//編譯錯誤，show()不能被繼承。
    }
}

私有方法的衝突

私有方法只能在本接口中直接使用,不存在衝突

接口和接口的關係

接口能夠「繼承」自另外一個「接口」，並且能夠「多繼承」

interface IA{}
interface IB{}
interface IC extends IA,IB{//是「繼承」，並且能夠「多繼承」
}

接口繼承接口的衝突狀況

公有靜態常量的衝突: 不能被繼承,使用不了
公有抽象方法的衝突: 只繼承一個
公有默認方法的衝突: 必須重寫一次
公有靜態方法和私有方法的衝突 : 無影響,由於不能被子接口繼承

公有靜態常量的衝突

interface IA{
    public static final int a = 10;
    public static final int b = 30;
}
interface IB{
    public static final int a = 20;
}
interface IC extends IA,IB{//沒有繼承a
}
//測試：
main(){
    System.out.println(IC.a);//錯誤的
}

公有抽象方法衝突

interface IA{
    public void show();
}
interface IB{
    public void show();
}
interface IC extends IA,IB{//IC只繼承了一個show()
}
class Zi implements IC{
    //重寫一次show()
    public void show(){
    }
}

公有默認方法的衝突

interface IA{
    public default void d1(){
    }
}
interface IB{
    public default void d1(){
    }
}
interface IC extends IA,IB{//必須重寫一次d1()
    public default  void d1(){
    }
}

公有靜態方法和私有方法

不衝突,由於靜態方法是直接屬於接口的,只能使用接口直接訪問,而私有方法只能在接口中訪問,也沒有衝突
實現類繼承父類又實現接口時的衝突

定義格式

public class 實現類名 extends 父類名 implements 接口名1,接口名2,...{           }

實現類繼承父類又實現接口時的衝突:

公有靜態常量的衝突–>沒有繼承
公有抽象方法的衝突—>重寫
公有默認方法的衝突—>優先父類
公有靜態方法---->優先父類
私有方法的衝突—> 沒有衝突

父類和接口的公有靜態常量的衝突

class Fu{
    public static final int a = 10;
}
interface IA{
    public static final int a = 20;
}
class Zi extends Fu implements IA{//沒有繼承a變量
}
public class Demo {
    public static void main(String[] args) {
        System.out.println(Zi.a);//編譯錯誤
    }
}

父類和接口的抽象方法衝突

abstract class Fu{
    public abstract void show();
}
interface IA{
    public void show();
}
class Zi extends Fu implements IA{// 必須重寫

}
//測試：
main(){
    Zi z = new Zi();
    z.show();//a
}

父類和接口的公有默認方法的衝突

class Fu{
    public void show(){
        System.out.println("a");
    }
}
interface IA{
    public default void show(){
        System.out.println("b");
    }
}
class Zi extends Fu implements IA{
}
//測試：
main(){
    Zi z = new Zi();
    z.show();//a
}

父類和接口的公有靜態方法

class Fu{
    public static void show(){
        System.out.println("fu...");
    }
}
interface IA{
    public static void show(){
        System.out.println("IA...");
    }
}
class Zi extends Fu implements IA{//只繼承了"父類"的靜態方法，沒有繼承接口的靜態方法

}
public class Demo {
    public static void main(String[] args) {
        Zi.show();//fu…
    }
}

父類和接口的私有方法

不存在衝突

最後

你們看完有什麼不懂的能夠在下方留言討論，也能夠關注我私信問我，我看到後都會回答的。也歡迎你們關注個人公衆號：前程有光，金三銀四跳槽面試季，整理了1000多道將近500多頁pdf文檔的Java面試題資料，文章都會在裏面更新，整理的資料也會放在裏面。謝謝你的觀看，以爲文章對你有幫助的話記得關注我點個贊支持一下！

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程