Technologieaustausch

[Einführung in JAVA] Tag 15 – Schnittstelle

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

[Einführung in JAVA] Tag 15 – Schnittstelle

Artikelverzeichnis

Warum gibt es eine Schnittstelle?
Wie wir alle wissen, besteht die Vererbung darin, die gemeinsamen Abstraktionen in der Unterklasse in die übergeordnete Klasse zu extrahieren und zu erhaltenGemeinsamkeit des gesamten SystemsUm Code zu sparen, gibt es jedoch auch eine Situation: Die meisten Unterklassen haben eine gewisse Gemeinsamkeit, aber nur wenige Unterklassen verfügen nicht über diese Funktion. Wenn diese Gemeinsamkeit dann in die übergeordnete Klasse geschrieben wird, wird sie vererbt. Dies ist unzumutbar diese wenigen Unterkategorien.
Zum Beispiel: Katzen und Hunde können schwimmen, Kaninchen jedoch nicht. Wenn zu diesem Zeitpunkt die Methode „Schwimmen“ in der übergeordneten Klasse definiert ist, ist es für Kaninchen nicht sinnvoll, ihre eigenen Schwimmmethoden zu erben Es kann daher vorkommen, dass das Schreibformat und die Benennung der beiden Methoden inkonsistent sind. Daher müssen wir ein neues Konzept definieren, um die Schreibspezifikationen der „schwimmenden“ Methoden in diesen beiden Unterklassen einzuschränken.An dieser Stelle können wir ein „Schwimmen“ definierenSchnittstelleDefinieren Sie die abstrakte Methode swim () in der Schnittstelle und lassen Sie dann Katzen und Hunde eine Verbindung zu dieser Schnittstelle herstellen, um dies sicherzustellenCode-Vereinheitlichung。
Zusammenfassend lässt sich sagen, dass die Schnittstelle eine istRegelWenn wir Regeln für mehrere Klassen gleichzeitig definieren müssen, müssen wir sie verwendenSchnittstelle。

1. Schnittstelle ist eine Abstraktion von „Verhalten“

Die Schnittstelle stellt keine Art von Sache dar, sie repräsentiert sieeine Regel, sodass Schnittstellen als Parameter an Methoden übergeben werden können.
„Ob es sich um einen Lastwagen, ein Dreirad oder Arbeitskräfte handelt, solange es sich bewegen kann, wird es nützlich sein.“

搬家(车的对象);

  • 1
搬家(搬家公司);

  • 1
public interface 运输 {
	...
}

  • 1
  • 2
  • 3
public void 搬家(运输的接口 c) {
	...
}

  • 1
  • 2
  • 3

2. Definition und Verwendung von Schnittstellen

  • Schnittstellen werden mit dem Schlüsselwort interface definiert.
public interface 接口名 {}

  • 1
  • Schnittstellen können nicht instanziiert werden, was bedeutet, dass Schnittstellen nicht zum Erstellen von Objekten verwendet werden können.
  • Der Unterschied zwischen Schnittstelle und Klasse isterreichenBeziehungen werden durch das Schlüsselwort „implements“ dargestellt.
public class 类名 implements 接口名 {}

  • 1
  • Eine Unterklasse einer Schnittstelle (Implementierungsklasse) überschreibt entweder alle abstrakten Methoden in der Schnittstelle oder ist selbst eine abstrakte Klasse.
  • Die Implementierungsbeziehung zwischen Schnittstellen und Klassen kann seinEinzelimplementierung, kann auchMehrere Implementierungen：
public class 类名 implements 接口名1 , 接口名2 {}

  • 1
  • Eine Implementierungsklasse kann mehrere Schnittstellen implementieren und gleichzeitig eine Klasse erben.
public class 类名 extends 父类 implements 接口名1 , 接口名2 {}

  • 1

üben:Schreiben Sie Standard-Javabean-Klassen mit Schnittstellen und abstrakten Klassen.

 青蛙		属性：名字，年龄		行为：吃虫子，蛙泳
 狗			属性：名字，年龄		行为：吃骨头，狗刨
 兔子		属性：名字，年龄		行为：吃胡萝卜

  • 1
  • 2
  • 3

Schreiben Sie zuerst die übergeordnete Klasse. Da die drei Unterklassen unterschiedliche Dinge essen, können Sie eat() als abstrakte Methode definieren:

package oopInterface;

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public abstract void eat();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

Schreibschnittstelle Schwimmen:

package oopInterface;

public interface Swim {
    public abstract void swim();
}

  • 1
  • 2
  • 3
  • 4
  • 5

Achten Sie beim Schreiben einer Froschklasse darauf, die übergeordnete Klasse zu erben, die abstrakte Methode der übergeordneten Klasse neu zu schreiben und die Schwimmschnittstelle zu implementieren:

package oopInterface;

public class Frog extends Animal implements Swim {
    public Frog() {
        super();
    }

    public Frog(String name, int age) {
        super(name, age);
    }

    @Override
    public void swim() {
        System.out.println("青蛙在蛙泳。");
    }

    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子。");
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

Achten Sie beim Schreiben einer Hundeklasse darauf, die übergeordnete Klasse zu erben und die abstrakte Methode der übergeordneten Klasse neu zu schreiben, um die Schwimmschnittstelle zu implementieren:

package oopInterface;

public class Dog extends Animal implements Swim {

    public Dog(){
        super();
    }

    public Dog(String name, int age) {
        super(name,age);
    }
    @Override
    public void swim() {
        System.out.println("狗在狗刨。");
    }

    @Override
    public void eat() {
        System.out.println("狗在吃骨头。");
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

Beachten Sie beim Schreiben einer Kaninchenklasse, dass Sie nur die übergeordnete Klasse erben und die abstrakte Methode überschreiben müssen und die Schwimmschnittstelle nicht implementieren müssen (Sie können nicht schwimmen):

package oopInterface;

public class Rabbit extends Animal {

    public Rabbit() {
    }

    public Rabbit(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("兔子在吃胡萝卜。");
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

Schreiben Sie Testklassen.

package oopInterface;

public class Test {
    public static void main(String[] args) {
        Frog f = new Frog("小绿",23);
        f.eat();
        f.swim();
        System.out.println(f.getName() + ", " + f.getAge());
        Dog d = new Dog("大D", 24);
        d.eat();
        d.swim();
        System.out.println(d.getName() + ", " + d.getAge());
        Rabbit r = new Rabbit("兔子", 30);
        r.eat();
        System.out.println(r.getName() + ", " + r.getAge());
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

3. Eigenschaften der Mitglieder in der Schnittstelle

  • Mitgliedsvariablen: Mitgliedsvariablen in der Schnittstelle können nur seinKonstante, öffentliches statisches Finale wird standardmäßig verwendet (auch wenn Sie es nicht schreiben, wird es automatisch auf diese Weise berücksichtigt).
  • Konstruktor: SchnittstelleNEINKonstruktionsmethode.
  • Mitgliedsmethoden: Vor JDK7 konnten sie nur abstrakte Methoden sein.StandardDer Modifikator ist eine öffentliche Zusammenfassung; nach JDK8 können Methoden mit Methodenkörpern in Schnittstellen definiert werden; nach JDK9 können private Methoden in Schnittstellen definiert werden.

4. Die Beziehung zwischen Schnittstellen und Klassen

  • Die Beziehung zwischen Klassen: Vererbungsbeziehung – nur Einzelvererbung, keine Mehrfachvererbung, aber mehrstufige Vererbung ist möglich.
  • Die Beziehung zwischen Klassen und Schnittstellen: Implementierungsbeziehung – sie kann einzeln oder in mehreren Implementierungen implementiert werden, und Sie können auch mehrere Schnittstellen implementieren, während Sie eine Klasse erben.
  • Die Beziehung zwischen Schnittstellen: Vererbungsbeziehung – es kann eine Einzelvererbung oder eine Mehrfachvererbung sein.

Beachten:
1. Wenn eine Klasse eine Schnittstelle implementiert, muss sie entweder alle abstrakten Methoden in der Schnittstelle implementieren oder die Klasse selbst ist ebenfalls eine abstrakte Klasse.
2. Eine Klasse kann mehrere Schnittstellen implementieren, wenn sie mehrere Schnittstellen implementiertalleAlle in der Schnittstelle zu implementierenden abstrakten Methoden werden implementiert.
3. Schnittstellen können von mehreren Schnittstellen geerbt werden. Wenn eine Unterschnittstelle mehrere Schnittstellen erbt und dann von einer Implementierungsklasse implementiert wird, muss die Implementierungsklasse die Unterschnittstelle und alle ihre übergeordneten Schnittstellen kombinieren.alleAlle abstrakten Methoden sind implementiert.

üben:Schreiben Sie Standard-Javabean-Klassen mit Schnittstellen und abstrakten Klassen.

乒乓球运动员：姓名，年龄，学打乒乓球，说英语
篮球运动员：姓名，年龄，学打篮球
乒乓球教练：姓名，年龄，教打乒乓球，说英语
篮球教练：姓名，年龄，教打篮球

  • 1
  • 2
  • 3
  • 4
//Person类
package oopInterExp;

//因为直接创建顶层父类人的对象是没有意义的
//所以将其写为抽象类
public abstract class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
//Sporter类继承Person
package oopInterExp;

public abstract class Sporter extends Person {

    public Sporter(String name, int age) {
        super(name, age);
    }

    public Sporter() {
    }

    public abstract void learn();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
//Coach类继承Person
package oopInterExp;

public abstract class Coach extends Person {

    public Coach() {
    }

    public Coach(String name, int age) {
        super(name, age);
    }

    public abstract void teach();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
//SpeakEnglish接口
package oopInterExp;

public interface SpeakEnglishInter {
    public abstract void speakEnglish();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
//PingPongSporter继承Sporter，实现SpeakEnglish
package oopInterExp;

public class PingPongSporter extends Sporter implements SpeakEnglishInter {

    public PingPongSporter(String name, int age) {
        super(name, age);
    }

    public PingPongSporter() {
    }

    @Override
    public void learn() {
        System.out.println("学习乒乓球。");
    }

    @Override
    public void speakEnglish() {
        System.out.println("乒乓球运动员在说英语。");
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
//PingPongCoach继承Coach，实现SpeakEnglish
package oopInterExp;

public class PingPongCoach extends Coach implements SpeakEnglishInter {
    public PingPongCoach() {
    }

    public PingPongCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("教乒乓球。");
    }

    @Override
    public void speakEnglish() {
        System.out.println("乒乓球教练在说英语。");
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
//BasketballSporter继承Sporter
package oopInterExp;

public class BasketballSporter extends Sporter {

    public BasketballSporter(String name, int age) {
        super(name, age);
    }

    public BasketballSporter() {
    }

    public void learn() {
        System.out.println("学篮球。");
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
//BasketballCoach继承Coach
package oopInterExp;

public class BasketballCoach extends Coach {

    public BasketballCoach() {
    }

    public BasketballCoach(String name, int age) {
        super(name, age);
    }

    public void teach() {
        System.out.println("教篮球。");
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

5. Neue Methoden in der Schnittstelle

5.1 Neue Methoden in der JDK8-Startschnittstelle

Vor JDK7 konnten in Schnittstellen nur abstrakte Methoden definiert werden.
Die neue Funktion von JDK8 ist: Methoden mit Methodenkörpern können in der Schnittstelle definiert werden (können definiert werden).StandardMethode bzwstatischMethode).
Das neue Feature von JDK9 ist: Es kann in der Schnittstelle definiert werdenPrivatMethode.

5.1.1 Standardmethoden in Schnittstellen

Methoden mit Methodenkörpern werden in der Schnittstelle definiert, hauptsächlich fürSchnittstellen-UpgradeDa die Schnittstelle nicht unveränderlich sein kann, müssen zum Aktualisieren neue Methoden hinzugefügt werden. Wenn es sich bei diesen Methoden um abstrakte Methoden handelt, müssen diese Methoden zu diesem Zeitpunkt gleichzeitig in der Implementierungsklasse implementiert werden, was sehr problematisch ist nicht einfach zu synchronisieren; wenn das Upgrade eine Methode mit einem Methodenkörper verwendet, muss die Implementierungsklasse nicht zusätzlich geändert werden. Wenn eine Änderung erforderlich ist, kann sie auch durch Umschreiben geändert werden.

  • Um Standardmethoden in der Schnittstelle zu definieren, müssen Sie Schlüsselwörter verwenden Standard Körperpflege.
  • Format: öffentlicher Standard-Rückgabewerttyp, Methodenname (Parameterliste) { }
  • Beispiel: public default void show() { }
  • Standardmethoden sind keine abstrakten Methoden und müssen nicht überschrieben werden. Wenn es jedoch neu geschrieben wird, muss das Standardschlüsselwort beim Neuschreiben entfernt werden.
  • public kann weggelassen werden, default kann jedoch nicht weggelassen werden.
  • Wenn mehrere Schnittstellen implementiert sind und es in mehreren Schnittstellen Standardmethoden mit demselben Namen gibt, muss die Unterklasse die Methode überschreiben (ein Nichtüberschreiben führt zu Konflikten).

Schnittstelle Inter1:

package oopInterface5;

public interface Inter1 {
    public abstract void method();
    public default void default_method() {
        System.out.println("Inter1接口中的默认方法");
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

Schnittstelle Inter2:

package oopInterface5;

public interface Inter2 {
    public default void default_method() {
        System.out.println("Inter2接口中的默认方法");
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

Die beiden Standardmethoden haben den gleichen Namen. Wenn die Implementierungsklasse diese beiden Schnittstellen gleichzeitig implementiert, muss diese Standardmethode neu geschrieben werden!

package oopInterface5;

public class InterImpl implements Inter1, Inter2 {

    @Override
    public void method() {
        System.out.println("抽象方法的实现");
    }

    @Override
    public void default_method() {
        System.out.println("重写接口中的默认方法");
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

Testklasse:

package oopInterface5;

public class Test {
    public static void main(String[] args) {
            InterImpl ii = new InterImpl();
            ii.method();				//抽象方法的实现
            ii.default_method();		//重写接口中的默认方法
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
5.1.2 Statische Methoden in Schnittstellen

Mit JDK8 und höher können statische Methoden in Schnittstellen definiert werden, die mit statischen Methoden geändert werden müssen.
in der Schnittstellestatische MethodeDas Definitionsformat ist:

  • öffentlicher statischer Rückgabewerttyp Methodenname (Parameterliste) { }
  • Beispiel: public static void show() { }

Was Sie bei statischen Methoden in Schnittstellen beachten sollten:

  • Statische Methoden können nur bestanden werdenSchnittstellennameWird aufgerufen und kann nicht über den Namen der Implementierungsklasse oder den Objektnamen aufgerufen werden.
  • public kann weggelassen werden, static kann nicht weggelassen werden.

Schreiben Sie eine Schnittstelle:

package oopInterface6;

public interface Inter {
    public abstract void method();

    public static void static_method() {
        System.out.println("接口中的静态方法");
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

Schreiben Sie eine Implementierungsklasse. Es gibt auch eine statische Methode in der Klasse mit demselben Namen wie die Methode in der Schnittstelle, diese wird jedoch nicht überschrieben, da statische Methoden nicht überschrieben werden können:

package oopInterface6;

public class InteImpl implements Inter {
    @Override
    public void method() {
        System.out.println("重写接口中的抽象方法");
    }

    //这不叫重写
    public static void static_method() {
        System.out.println("我不是重写的Inter接口中的静态方法");
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

Tatsächlich handelt es sich jedoch um unterschiedliche Methoden.

package oopInterface6;

public class Test {
    public static void main(String[] args) {
        InteImpl ii = new InteImpl();
        ii.method();						  //重写接口中的抽象方法
        Inter.static_method();               //调用接口中的静态方法
        InteImpl.static_method();           //调用实现类中的一个同名的静态方法
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

5.2 Neue Methoden in der JDK9-Startschnittstelle

5.2.1 Definieren Sie private Methoden in der Schnittstelle
  • Format 1: privater Rückgabewerttyp Methodenname (Parameterliste) { }
  • Beispiel 1: private void show() { }
  • Verwendung: Die Standardmethode bereitstellen.
package oopInterface7;

public interface InterA {
    public default void show1() {
        System.out.println("show1开始执行");
        show3();
    }

    public default void show2() {
        System.out.println("show2开始执行");
        show3();
    }

    //普通的私有方法，给默认方法服务的
    private void show3() {
        System.out.println("记录程序在运行过程中的各种细节，这里有100行代码。");
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • Format 2: privater statischer Rückgabewerttyp Methodenname (Parameterliste) { }
  • Beispiel 2: private static void method() { }
  • Verwendung: Statische Methoden bereitstellen.
package oopInterface7;

public interface InterB {
    public static void show1() {
        System.out.println("show1开始执行");
        show3();
    }

    public static void show2() {
        System.out.println("show2开始执行");
        show3();
    }

    //普通的私有方法，给静态方法服务的
    private static void show3() {
        System.out.println("记录程序在运行过程中的各种细节，这里有100行代码。");
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

6. Anwendung der Schnittstelle

1. Die Schnittstelle stellt Regeln dar und ist eine Abstraktion des Verhaltens. Wenn Sie möchten, dass eine Klasse ein Verhalten hat, lassen Sie die Klasse einfach die entsprechende Schnittstelle implementieren.
2. Wenn der Parameter einer Methode eine Schnittstelle ist, kann die Schnittstelle übergeben werdenAlle Objekte der ImplementierungsklasseDieser Ansatz wird als Schnittstellenpolymorphismus bezeichnet.

7. Adapter-Designmuster

  • Design Pattern ist eine Reihe klassifizierter und katalogisierter Code-Design-Erfahrungen, die wiederholt verwendet werden und den meisten Menschen bekannt sind. Der Zweck der Verwendung von Entwurfsmustern besteht darin, Code wiederzuverwenden, den Code für andere verständlicher zu machen, die Zuverlässigkeit des Codes und die Wiederverwendbarkeit des Programms sicherzustellen.

Adapter können verwendet werden, um Code zu vereinfachen und die Unannehmlichkeiten zu vermeiden, die entstehen, wenn die Schnittstelle zu viele abstrakte Methoden enthält und wir nur einen Teil davon verwenden müssen.
Die Schreibschritte sind im Allgemeinen:
1. Schreiben Sie die Zwischenklasse XXXAdapter, um die entsprechende Schnittstelle zu implementieren.
2. Implementieren Sie leere Implementierungen abstrakter Methoden in der Schnittstelle.
3. Lassen Sie die reale Implementierungsklasse die Zwischenklasse erben und schreiben Sie die erforderlichen Methoden neu.
4. Um zu verhindern, dass andere Klassen Objekte der Adapterklasse erstellen, wird die Zwischenadapterklasse mit Abstract dekoriert.

Schnittstelle:

package AdapterDesignPattern;

public interface Inter {
    public abstract void method1();
    public abstract void method2();
    public abstract void method3();
    public abstract void method4();
    public abstract void method5();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

Adapterklasse:

package AdapterDesignPattern;

public abstract class InterAdapter implements Inter {
    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }

    @Override
    public void method3() {

    }

    @Override
    public void method4() {

    }

    @Override
    public void method5() {

    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

Implementierungsklasse:

package AdapterDesignPattern;

public class InterImpl extends InterAdapter {
    //我需要用到哪个方法，就重写哪个方法就可以了
    @Override
    public void method5() {
        System.out.println("只要用第五个方法");
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

Persönliches Profil

Er widmet sich seit mehr als 30 Jahren der Technologieforschung und beherrscht verschiedene Sprachen wie Java, Linux, Javascript, PHP, CSS usw. Er hat viele Beiträge im Open-Source-Bereich geleistet, Entwicklerdokumentationsstation, um einige Themen in der Technologieentwicklung als zukünftige Referenz zu teilen

meine Kontaktdaten

Post