So implementieren Sie ein Update der Java-Schnittstellenzusammensetzung

1.1 Aktualisierte Übersicht über die Schnittstellenzusammensetzung

• Zusammensetzung der Schnittstelle

• Konstante: public static finalpublic static final

• 抽象方法：public abstract

• 默认方法(Java 8)

• 静态方法(Java 8)

• 私有方法(Java 9)

1.2 接口中默认方法（JDK8）

我们都知道，一个类实现一个接口，就要重写这个接口中的所有抽象方法。但现在接口中新增了一个方法，实现这个接口的类不想重写这个方法怎么办？这时就可以使用接口中默认方法，它不强制被重写，而且还可以提供方法体。

• 接口中默认方法的定义格式：

• 格式：public default 返回值类型 方法名(参数列表){}

• 范例：public default void show(){}

• 接口中默认方法的注意事项：

• 默认方法不是抽象方法，所以不强制被重写。但是可以被重写,重写的时候去掉default关键字

• public可以省略，default不能省略：default void show(){}

1.3 接口中静态方法（JDK8）

• 接口中静态方法的定义格式:

• 格式：public static 返回值类型 方法名(参数列表){}

• 范例：public static void show(){}

• 接口中静态方法的注意事项：

• 静态方法只能通过接口名调用, 不能通过实现类名或者对象名调用

• public可以省略， static不能省略：static void show(){}

• 接口

package test;

public interface Inter {
    void show();

    default void method() {
        System.out.println("默认方法");
    }

//    public static void test(){
//        System.out.println("静态方法");
//    }

    static void test(){
        System.out.println("静态方法");
    }
}

• 实现类

package test;

public class InterImpl implements Inter{
    @Override
    public void show() {
        System.out.println("show方法");
    }
}

• 测试类

package test;

public class Demo {
    public static void main(String[] args) {
        Inter i = new InterImpl();
        i.show(); //show方法
        i.method(); //
//        i.test(); //报错

        Inter.test(); //静态方法,接口名调用静态方法
    }
}

1.4 接口中私有方法（JDK9）

Java 9 中新增了带方法体的私有方法，这其实在 Java 8 中就埋下了伏笔：Java 8 允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段实现代码抽取成一个共性方法，而这个共性方法是不需要让别人使用的，因此用私有给隐藏起来，这就是 Java 9 增加私有方法的必然性 。

• 接口中私有方法的定义格式：

• 格式1（非静态）：private 返回值类型 方法名(参数列表){}

• 范例1：private void show() {}

• 格式2（静态）：private static 返回值类型 方法名(参数列表){}

• 范例2：private static void method() {}

Abstract-Methode: public abstract

• Standardmethode (Java 8)

• Statische Methode (Java 8)

• Private Methode (Java 9)

1.2 Standardmethode in der Schnittstelle (JDK8)🎜🎜Wir alle wissen, dass eine Klasse implementiert Für eine Schnittstelle müssen alle abstrakten Methoden in dieser Schnittstelle neu geschrieben werden. Aber jetzt gibt es eine neue Methode in der Schnittstelle. Was soll ich tun, wenn die Klasse, die diese Schnittstelle implementiert, diese Methode nicht überschreiben möchte? Zu diesem Zeitpunkt können Sie die Standardmethode in der Schnittstelle verwenden, die nicht überschrieben werden muss, und auch einen Methodenkörper bereitstellen. 🎜🎜🎜🎜Definitionsformat der Standardmethode in der Schnittstelle: 🎜🎜🎜🎜🎜Format: Name der öffentlichen Standardrückgabewerttypmethode (Parameterliste){}🎜🎜🎜🎜Beispiel: public default void show(){}🎜🎜🎜🎜🎜Hinweise zu Standardmethoden in Schnittstellen:🎜🎜🎜🎜🎜Die Standardmethode ist keine abstrakte Methode und muss daher nicht überschrieben werden. Es kann jedoch umgeschrieben werden. Entfernen Sie beim Umschreiben das Standardschlüsselwort 🎜🎜🎜🎜public kann weggelassen werden, aber default kann nicht weggelassen werden: default void show(){}🎜🎜🎜🎜🎜1.3 Statische Methoden in Schnittstellen (JDK8) 🎜🎜🎜🎜Definitionsformat statischer Methoden in Schnittstellen: 🎜🎜🎜🎜🎜Format: öffentlicher statischer Rückgabewerttyp-Methodenname (Parameterliste){}🎜🎜🎜🎜Beispiel: public static void show(){}🎜🎜🎜🎜🎜Hinweise zu statischen Methoden in Schnittstellen: 🎜🎜🎜🎜🎜Statische Methoden können nur über 🎜Schnittstellennamen🎜 aufgerufen werden, nicht über Implementierungsklassennamen oder Objektnamen Aufruf 🎜🎜🎜🎜public kann weggelassen werden, static kann nicht weggelassen werden: static void show(){}🎜🎜🎜🎜🎜interface🎜🎜🎜

package test;

public interface Inter {
    default void show1() {
        System.out.println("show1开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
//        show();
        method();
        System.out.println("show1结束");
    }


    static void method1() {
        System.out.println("method1开始执行");
//        System.out.println("初级工程师");
//        System.out.println("中级工程师");
//        System.out.println("高级工程师");
        method();
        System.out.println("method1结束");
    }

    private void show(){
        System.out.println("初级工程师");
        System.out.println("中级工程师");
        System.out.println("高级工程师");
    }

    private static void method(){
        System.out.println("初级工程师");
        System.out.println("中级工程师");
        System.out.println("高级工程师");
    }
}

🎜🎜🎜Implementierungsklasse🎜🎜🎜rrreee 🎜🎜🎜Testklasse🎜🎜🎜rrreee🎜1.4 Private Methoden in Schnittstellen (JDK9)🎜🎜In Java 9 wurden neue private Methoden mit Methodenkörpern hinzugefügt, die tatsächlich den Grundstein für Java 8 legten: Java 8 ermöglicht die Definition von Methoden mit Methoden in Schnittstellen Die Standard- und statischen Methoden des Körpers. Dies kann zu einem Problem führen: Wenn zwei Standardmethoden oder statische Methoden dieselbe Codeimplementierung enthalten, muss das Programm in Betracht ziehen, diesen Implementierungscode in eine gemeinsame Methode zu extrahieren, und diese gemeinsame Methode muss nicht von anderen verwendet werden, sodass sie ausgeblendet ist durch private. Dies ist die Notwendigkeit, private Methoden in Java 9 hinzuzufügen. 🎜🎜🎜🎜🎜Definitionsformat privater Methoden in Schnittstellen 🎜: 🎜🎜🎜🎜🎜🎜Format 1 (nicht statisch) 🎜: Privater Rückgabewerttyp-Methodenname (Parameterliste) {}🎜🎜 🎜 🎜Beispiel 1: private void show() {}🎜🎜🎜🎜🎜Format 2 (statisch)🎜: privater statischer Rückgabewerttyp-Methodenname (Parameterliste){} 🎜🎜🎜🎜Beispiel 2: private static void method() {}🎜🎜🎜🎜🎜🎜Hinweise zu privaten Methoden in Schnittstellen🎜: 🎜🎜🎜🎜🎜Standardmethoden können private statische Methoden aufrufen Nicht statische Methoden🎜🎜🎜🎜Statische Methoden können nur private statische Methoden aufrufen🎜🎜🎜🎜rrreee

Das obige ist der detaillierte Inhalt vonSo implementieren Sie ein Update der Java-Schnittstellenzusammensetzung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!