1. Schnittstelle

1.1 Überblick über Schnittstellen

Eine Schnittstelle ist eine Sammlung von Funktionen. Sie kann auch als Datentyp betrachtet werden, und sie ist abstrakter als eine abstrakte Klasse.Klasse 。

Eine Schnittstelle beschreibt nur die Methoden, die sie haben sollte, ohne konkrete Implementierung. Die konkrete Implementierung erfolgt durch die Implementierungsklasse der Schnittstelle (äquivalent zu einer Unterklasse der Schnittstelle). Dies trennt die Definition der Funktionalität von ihrer Implementierung und optimiert das Programmdesign.

1.2 Format & Verwendung von Schnittstellen

1.2.1 Format einer Schnittstelle

Anders als beim Definieren einer Klasse,classbesteht der Unterschied darin, dass Sie beim Definieren einer Schnittstelle dasinterfaceSchlüsselwort verwenden müssen.

Die Datei, in der die Schnittstelle definiert wird, ist immer noch eine.javaDatei. Obwohl die Deklaration dasinterfaceSchlüsselwort verwendet, erzeugt sie nach der Kompilierung immer noch eine.classDatei. Dadurch können wir eine Schnittstelle als eine spezielle Klasse betrachten, die nur Merkmalsdeklarationen enthält.

Definitionsformat:
public interface 接口名 {
    抽象方法1;
    抽象方法2;
    抽象方法3;
}

1.2.2 Verwendung von Schnittstellen

Alle Methoden in einer Schnittstelle sind abstrakte Methoden. `new` direkt auf einer Schnittstelle zu verwenden, um Methoden aufzurufen, ist sinnlos, und Java erlaubt dies nicht.

Die Beziehung zwischen einer Klasse und einer Schnittstelle ist eine Implementierungsbeziehung, d. h., eine Klasse implementiert eine Schnittstelle. Der Vorgang der Implementierung ähnelt der Vererbung, aber das Schlüsselwort ist anders; die Implementierung verwendetimplements。

Nachdem andere Klassen (Implementierungsklassen) eine Schnittstelle implementiert haben, ist es gleichbedeutend mit der Deklaration:"Ich sollte die Funktionalität dieser Schnittstelle haben."Die Implementierungsklasse muss weiterhin die Methoden überschreiben, um die spezifische Funktionalität zu implementieren.

Format:

class 类 implements 接口 {
    重写接口中方法
}

Nachdem eine Klasse eine Schnittstelle implementiert hat, erbt die Klasse die abstrakten Methoden von der Schnittstelle. An diesem Punkt muss die Klasse diese abstrakten Methoden überschreiben, um die konkrete Logik zu vervollständigen.

1.2.3 Beispielcode 1

Beispiel

/** Vererbung in Java ist Einfachvererbung; eine Unterklasse kann nur eine übergeordnete Klasse haben (ein Sohn kann nur einen leiblichen Vater haben). * Java bietet uns einen Mechanismus, um die Einschränkung der Einfachvererbung zu handhaben: Schnittstellen. * * Schnittstelle: Eine Schnittstelle ist eine Klasse, die noch abstrakter ist als eine abstrakte Klasse. Alle Methoden in einer Schnittstelle sind abstrakte Methoden. Die Beziehung zwischen einer Schnittstelle und einer Klasse ist die Implementierung, wobei implements verwendet wird. * interface * * Format: * interface InterfaceName { * * } **/ public class InterfaceDemo { public static void main(String[] args) { BillGates gates = new BillGates(); gates.code(); } } class Boss { public void manage() { System.out.println("Verwalte das Unternehmen"); } } class Programmer { public void code() { System.out.println("Code schreiben"); } } //Bill Gates class BillGates extends Programmer { }

1.3 Eigenschaften von Membern in einem Interface

  • 1. Variablen können in einem Interface definiert werden, aber sie müssen mit festen Modifikatoren modifiziert werden: `public static final`. Daher werden Variablen in einem Interface auch Konstanten genannt, und ihre Werte können nicht geändert werden. Wir werden das Schlüsselwort `final` später erklären.

  • 2. Methoden können in einem Interface definiert werden, und Methoden haben auch feste Modifikatoren: `public abstract`.

  • 3. Ein Interface kann keine Objekte erstellen.

  • 4. Eine Unterklasse muss alle abstrakten Methoden des Interfaces überschreiben, bevor sie instanziiert werden kann. Andernfalls ist die Unterklasse eine abstrakte Klasse.

1.3.1 Beispielcode 2

Beispiel

/** Eigenschaften von Interface-Membern: * Können nur abstrakte Methoden haben * Können nur Konstanten haben * Methoden werden standardmäßig mit public & abstract modifiziert * Methoden können nur mit public & abstract modifiziert werden * Member-Variablen werden standardmäßig mit public static final modifiziert * * Vorschlag: Es wird empfohlen, die Standardmodifikatoren manuell hinzuzufügen. * * Hinweis: * Ein Interface kann keine Objekte erstellen (kann nicht instanziiert werden) * Die Beziehung zwischen einer Klasse und einem Interface ist die Implementierung. Eine Klasse, die ein Interface implementiert, muss alle seine Methoden implementieren.*/ public class InterfaceDemo2 { public static void main(String[] args) { //Animal a = new Animal(); //Animal.num; } } interface Animal { public static final int num = 10; public abstract void eat(); } class Cat implements Animal { public void eat() { } }

1.4 Beziehung zwischen Schnittstellen und Klassen

  • A: Zwischen Klassen: Vererbungsbeziehung. Eine Klasse kann direkt nur von einer Elternklasse erben, unterstützt aber mehrstufige Vererbung.
  • B: Zwischen Klassen und Schnittstellen: nur Implementierungsbeziehung. Eine Klasse kann mehrere Schnittstellen implementieren.
  • C: Zwischen Schnittstellen: nur Vererbungsbeziehung. Eine Schnittstelle kann mehrere Schnittstellen erben.

1.4.1 Beispielcode 3

Beispiel

/** * Klasse vs. Klasse: Vererbungsbeziehung, Einfachvererbung, mehrstufige Vererbung * Klasse vs. Schnittstelle: Implementierungsbeziehung, Mehrfachimplementierung * Schnittstelle vs. Schnittstelle: Vererbungsbeziehung, Mehrfachvererbung*/ public class InterfaceDemo3 { public static void main(String[] args) { } } interface InterA extends InterB { public abstract void method(); } interface InterB { public abstract void function(); } interface InterC extends InterA { } class Demo implements InterC { @Override public void method() { // TODO Automatisch generierter Methoden-Stub } @Override public void function() { // TODO Automatisch generierter Methoden-Stub } }

1.5 Die Idee der Interfaces

Zuvor haben wir die Code-Darstellung von Interfaces kennengelernt. Jetzt lernen wir die Idee hinter Interfaces kennen und erklären sie anschließend anhand von Beispielen aus dem Alltag.

Zum Beispiel: Wir alle wissen, dass ein Computer viele Anschlüsse hat, und an diese Anschlüsse können entsprechende Geräte angeschlossen werden. Warum können diese Geräte angeschlossen werden? Der Hauptgrund ist, dass diese Geräte bei ihrer Herstellung den Nutzungsregeln des Anschlusses entsprachen; andernfalls könnten sie nicht an den Anschluss angeschlossen werden, geschweige denn verwendet werden. Es zeigt sich, dass uns die Existenz dieser Anschlüsse erlaubt, mehr Geräte zu verwenden.

Die Entstehung von Interfaces erleichtert die spätere Nutzung und Wartung. Eine Seite verwendet das Interface (wie einen Computer), und die andere Seite implementiert das Interface (Geräte, die an den Anschluss angeschlossen werden). Zum Beispiel verwendet ein Laptop diese Regel (Interface), und Computerperipheriegeräte implementieren diese Regel (Interface).

Interfaces werden im Collection-Framework häufig verwendet:

Collection 接口

    List 接口

       ArrayList 实现类

       LinkedList 实现类

    Set 接口

1.6 Vorteile von Interfaces

  • 1. Die Beziehung zwischen einer Klasse und einer Schnittstelle ist die Implementierung, und es handelt sich um Mehrfachimplementierung. Eine Klasse kann mehrere Schnittstellen implementieren. Die Beziehung zwischen Klassen ist die Vererbung. Vererbung in Java ist Einfachvererbung; eine Klasse kann nur eine Oberklasse haben. Damit wird die Einschränkung der Vererbung durchbrochen.
  • 2. Regeln für die Außenwelt bereitstellen (USB-Schnittstelle).
  • 3. Die Kopplung des Programms verringern (es ermöglicht modulare Entwicklung; sobald Regeln definiert sind, implementiert jede Person ihr eigenes Modul, was die Entwicklungseffizienz verbessert).

1.7 Unterschiede zwischen Schnittstellen und abstrakten Klassen

1. Gemeinsamkeit:Beide abstrahieren fortlaufend Methoden heraus, die abstrakt sind und keine konkrete Implementierung haben, und keine von beiden kann instanziiert werden (es können keine Objekte erstellt werden).

2. Unterschiede

1: Beziehung zu Klassen

(1) Die Beziehung zwischen einer Klasse und einer Schnittstelle ist die Implementierung, und es handelt sich um Mehrfachimplementierung; eine Klasse kann mehrere Schnittstellen implementieren. Die Beziehung zwischen einer Klasse und einer abstrakten Klasse ist die Vererbung. Vererbung in Java ist Einfachvererbung und mehrstufige Vererbung; eine Klasse kann nur eine Oberklasse erben, aber sie kann eine Großelternklasse haben.

(2) Unterschied 2: Member

a.成员变量
    抽象类可以有成员变量，也可以有常量
    接口只能有常量，默认修饰符public static final

b.成员方法
    抽象类可以有抽象方法，也可以有非抽象方法
    接口只能有抽象方法，默认修饰符 public abstract

c.构造方法
    抽象类有构造方法，为子类提供
    接口没有构造方法

1.8 Fallstudie: Sportler

1.8.1 Fallcode 4

Beispiel

/** Basketballspieler und Trainer Tischtennisspieler und Trainer Jetzt reisen Basketballspieler und Trainer für einen Besuch ins Ausland und müssen Englisch lernen. Bitte analysieren Sie mit dem Gelernten, was Klassen, was abstrakte Klassen und was Schnittstellen sind.*/ public class InterfaceTest { public static void main(String[] args) { //Basketballspieler-Objekt erstellen BasketBallPlayer bbp = new BasketBallPlayer(); bbp.name = "Yao Ming"; bbp.age = 35; bbp.gender = "Männlich"; bbp.sleep(); bbp.study(); bbp.speak(); System.out.println("-------------"); //Tischtennis-Trainer-Objekt erstellen PingpangCoach ppc = new PingpangCoach(); ppc.name = "Fatty Liu"; ppc.age = 40; ppc.gender = "Männlich"; ppc.sleep(); ppc.teach(); //ppc.speak(); } } class Person { String name;//Name int age;//Alter String gender;//Geschlecht //Konstruktor ohne Argumente public Person() {} //Parametrisierter Konstruktor public Person(String name,int age,String gender) { this.name = name; this.age = age; this.gender = gender; } //eat public void eat() { System.out.println("Essen"); } //sleep public void sleep() { System.out.println("Schlafen"); } } //Englisch sprechen lernen interface SpeakEnglish { public abstract void speak(); } //Athlete abstract class Player extends Person { //Learn public abstract void study(); } //Coach abstract class Coach extends Person { //Teach public abstract void teach(); } //Basketballspieler class BasketBallPlayer extends Player implements SpeakEnglish{ @Override public void study() { System.out.println("Dunk lernen"); } @Override public void speak() { System.out.println("Englisch sprechen"); } } //Tischtennisspieler class PingpangPlayer extends Player { @Override public void study() { System.out.println("Schmettern lernen"); } } //Basketballtrainer class BasketBallCoach extends Coach implements SpeakEnglish { @Override public void teach() { System.out.println("Dunking beibringen"); } @Override public void speak() { System.out.println("Englisch sprechen"); } } //Tischtennistrainer class PingpangCoach extends Coach { @Override public void teach() { System.out.println("Schmettern beibringen"); } }

2. Polymorphismus

2.1 Überblick über Polymorphismus

Polymorphismus ist das dritte Hauptmerkmal der objektorientierten Programmierung, nach Kapselung und Vererbung.

Reale Dinge weisen oft mehrere Formen auf. Zum Beispiel ist ein Student eine Art Person. Ein bestimmter Student, Zhang San, ist sowohl Student als auch Person und weist somit zwei Formen auf.

Java kann als objektorientierte Sprache ebenfalls mehrere Formen einer Sache beschreiben. Wenn beispielsweise die Klasse Student von der Klasse Person erbt, dann ist ein Student-Objekt sowohl ein Student als auch eine Person.

2.2 Definition und Verwendungsformat des Polymorphismus

Das Definitionsformat des Polymorphismus: Es ist tatsächlich so, dass eine Referenzvariable der Elternklasse auf ein Objekt der Kindklasse zeigt.

父类类型  变量名 = new 子类类型();
变量名.方法名();

A: Format für Polymorphismus mit gewöhnlichen Klassen

父类 变量名 = new 子类();

Zum Beispiel:

class Fu {}
class Zi extends Fu {}
//类的多态使用
Fu f = new Zi();

B: Format für Polymorphismus mit abstrakten Klassen

抽象类 变量名 = new 抽象类子类();

Zum Beispiel:

abstract class Fu {
    public abstract void method();
}
class Zi extends Fu {
    public void method(){
        System.out.println(“重写父类抽象方法”);
    }
}
//类的多态使用
Fu fu= new Zi();

C: Format für Polymorphismus mit Schnittstellen

接口 变量名 = new 接口实现类();

Zum Beispiel:

interface Fu {
    public abstract void method();
}
class Zi implements Fu {
    public void method(){
        System.out.println(“重写接口抽象方法”);
    }
}
//接口的多态使用
Fu fu = new Zi();

2.2.1 Beispielcode

Beispiel

/** Voraussetzungen für Polymorphismus: * Vererbungsbeziehung zwischen Kind- und Elternklassen * Methodenüberschreibung * Referenz der Elternklasse zeigt auf Objekt der Kindklasse * * Dynamische Bindung: Die zur Laufzeit aufgerufene Methode richtet sich nach ihrem konkreten Typ*/ public class PoymorphicDemo { public static void main(String[] args) { /*Cat c = new Cat(); c.eat();*/ //Referenz der Elternklasse Animal a //zeigt auf = //Objekt der Unterklasse new Cat() Animal a = new Cat(); a.eat(); } } class Animal { public void eat() { System.out.println("Eating"); } } class Cat extends Animal { public void eat() { System.out.println("Cat eats fish"); } }

2.3 Eigenschaften polymorpher Member

A: Polymorphe Membervariablen

Wenn eine Membervariable mit demselben Namen sowohl in der Eltern- als auch in der Kindklasse vorkommt und Polymorphie diese Variable aufruft:

  • Kompilierzeit: Es wird geprüft, ob die Klasse, zu der die Referenzvariable gehört, die aufgerufene Membervariable enthält. Wenn nicht, schlägt die Kompilierung fehl.
  • Laufzeit: Es wird ebenfalls die Membervariable der Klasse aufgerufen, zu der die Referenzvariable gehört.

Einfache Eselsbrücke: Sowohl Kompilierung als auch Laufzeit beziehen sich auf die linke Seite des Gleichheitszeichens. Kompilierung und Laufzeit schauen beide auf die linke Seite.

B: Polymorphe Membermethoden

  • Kompilierzeit: Es wird auf die Klasse verwiesen, zu der die Referenzvariable gehört; wenn die Klasse die aufgerufene Methode nicht enthält, schlägt die Kompilierung fehl.
  • Laufzeit: Verweist auf die Klasse, zu der das Objekt gehört, auf das die Referenzvariable zeigt, und führt die Member-Methode der Klasse aus, zu der das Objekt gehört.

Kurz gesagt: Die Kompilierung schaut nach links, die Laufzeit schaut nach rechts.

2.3.1 Fallbeispiel-Code Sechs

Beispiel

/** * Merkmale polymorpher Member: * Member-Variablen Kompilierung schaut nach links, Laufzeit schaut nach links * Member-Methoden Kompilierung schaut nach links, Laufzeit schaut nach rechts * Statische Methoden Kompilierung schaut nach links, Laufzeit schaut ebenfalls nach links * * * Zur Kompilierungszeit schauen alle nach links; zur Laufzeit schauen Member-Methoden nach rechts, während alle anderen (Member-Variablen und statische Methoden) nach links schauen **/ public class PoymorphicDemo2 { public static void main(String[] args) { Dad d = new Kid(); //System.out.println(d.num); //d.method(); d.function();//Eine Variable zum Aufrufen einer statischen Methode zu verwenden, ist tatsächlich gleichbedeutend damit, sie mit dem Klassennamen des Typs der Variablen aufzurufen. } } class Dad { int num = 20; public void method() { System.out.println("Ich bin die Methode der Elternklasse"); } public static void function() { System.out.println("Ich bin die statische Methode der Elternklasse"); } } class Kid extends Dad { int num = 10; public void method() { System.out.println("我是子类的方法"); } public static void function() { System.out.println("我是子类的静态方法"); } }

2.4 多态中的向上转型和向下转型

多态中的类型转换分为两种：向上转型和向下转型：

A：向上转型：当将子类对象赋值给父类引用时，就是向上转型。多态本身就是向上转型的过程。

使用格式：

父类类型  变量名 = new 子类类型();

Zum Beispiel:

Person p = new Student();

B：向下转型：已经向上转型的子类对象可以使用强制类型转换格式，将父类引用转换为子类引用。这个过程就是向下转型。如果直接创建父类对象，则不能向下转型。

使用格式：

Subclass type variable name = (Subclass type) Parent class type variable;

Zum Beispiel:

Student stu = (Student) p;  // 变量p 实际上指向 Student 对象

Beispiel

/** * 多态中的向上转型和向下转型： * * 引用类型之间的转换 * 向上转型 * 从小到大（子类型转换为父类型） * 向下转型 * 从大到小 * 基本数据类型的转换 * 自动类型转换 * 从小到大 * byte short char --- int --- long --- float --- double * 强制类型转换 * 从大到小 * * **/ public class PoymorphicDemo3 { public static void main(String[] args) { Animal2 a = new Dog();//Upcasting //a.eat(); Dog d = (Dog)a;//Downcasting d.swim(); } } class Animal2 { public void eat() { System.out.println("Eating"); } } class Dog extends Animal2 { public void eat() { System.out.println("Knochen nagen"); } public void swim() { System.out.println("Hundepaddeln"); } }

2.5 Vorteile und Nachteile der Polymorphie

Beispiel

/** * Vorteile und Nachteile der Polymorphie * Vorteile: Sie kann die Wartbarkeit verbessern (garantiert durch die Voraussetzungen der Polymorphie) und die Erweiterbarkeit des Codes verbessern Nachteile: Sie kann nicht direkt auf Mitglieder zugreifen, die für die Unterklasse spezifisch sind*/ public class PoymorphicDemo4 { public static void main(String[] args) { MiFactory factory = new MiFactory(); factory.createPhone(new MiNote()); factory.createPhone(new RedMi()); } } class MiFactory { /*public void createPhone(MiNote mi) { mi.call(); } public void createPhone(RedMi mi) { mi.call(); }*/ public void createPhone(Phone p) { p.call(); } } interface Phone { public void call(); } //Xiaomi Note class MiNote implements Phone{ public void call() { System.out.println("Xiaomi Note tätigt einen Anruf"); } } //Redmi class RedMi implements Phone { public void call() { System.out.println("Redmi tätigt einen Anruf"); } }

Originaladresse: https://www.cnblogs.com/yoke/p/7453864.html