Detaillierte Erläuterung von Schnittstellen und abstrakten Klassen in Java

In diesem Artikel werden hauptsächlich relevante Informationen für ein tieferes Verständnis von Java-Schnittstellen und abstrakten Klassen vorgestellt. Ich hoffe, dass jeder, der die Verwendung von Anwendungsschnittstellen und abstrakten Klassen versteht, darauf verweisen kann

Tiefgehendes Verständnis der Schnittstellen und abstrakten Klassen von Java

Für die objektorientierte Programmierung ist Abstraktion eines der Hauptmerkmale. In Java kann die OOP-Abstraktion in zwei Formen verkörpert werden: Schnittstellen und abstrakte Klassen. Die beiden haben zu viele Ähnlichkeiten und zu viele Unterschiede. Viele Leute denken, dass sie beim ersten Lernen austauschbar verwendet werden können, aber das ist in der Realität nicht der Fall. Heute lernen wir etwas über Schnittstellen und abstrakte Klassen in Java.

1. Abstrakte Klassen

Bevor wir abstrakte Klassen verstehen, wollen wir zunächst abstrakte Methoden verstehen. Eine abstrakte Methode ist eine besondere Art von Methode: Sie hat nur eine Deklaration, aber keine konkrete Implementierung. Das Deklarationsformat einer abstrakten Methode ist:

abstract void fun();

Abstrakte Methoden müssen mit dem Schlüsselwort abstract geändert werden. Wenn eine Klasse abstrakte Methoden enthält, wird die Klasse als abstrakte Klasse bezeichnet. Abstrakte Klassen müssen vor der Klasse mit dem Schlüsselwort abstract geändert werden. Da abstrakte Klassen Methoden enthalten, die keine konkrete Implementierung haben, können mit abstrakten Klassen keine Objekte erstellt werden.

Das Folgende sollte beachtet werden: Im Buch „JAVA Programming Thoughts“ wird eine abstrakte Klasse als „Klasse mit abstrakten Methoden“ definiert. Später wurde jedoch festgestellt, dass, wenn eine Klasse keine abstrakten Methoden enthält, Es ist nur mit abstrakten Elementen dekoriert. Es ist auch eine abstrakte Klasse. Mit anderen Worten: Abstrakte Klassen müssen nicht unbedingt abstrakte Methoden enthalten. Ich persönlich halte das für eine knifflige Frage, denn wenn eine abstrakte Klasse keine abstrakten Methoden enthält, warum sollte sie dann als abstrakte Klasse entworfen werden? Erinnern wir uns zunächst einmal an dieses Konzept, ohne auf das Warum einzugehen.

[public] abstract class ClassName {
  abstract void fun();
}

Hier ist ersichtlich, dass abstrakte Klassen zur Vererbung vorhanden sind. Wenn Sie eine abstrakte Klasse definieren, sie aber nicht erben, haben Sie diese erstellt abstrakte Klasse umsonst, weil man damit nichts anfangen kann. Wenn für eine übergeordnete Klasse eine ihrer Methoden bei der Implementierung in der übergeordneten Klasse keinen Sinn ergibt und je nach den tatsächlichen Anforderungen der Unterklasse anders implementiert werden muss, kann diese Methode zu diesem Zeitpunkt als abstrakte Methode deklariert werden. die Klasse auch Es wird eine abstrakte Klasse.

Eine Klasse, die abstrakte Methoden enthält, wird als abstrakte Klasse bezeichnet. Dies bedeutet jedoch nicht, dass abstrakte Klassen wie gewöhnliche Klassen auch Mitgliedsvariablen und gewöhnliche Mitgliedsmethoden haben können. Beachten Sie, dass es drei Hauptunterschiede zwischen abstrakten Klassen und gewöhnlichen Klassen gibt:

1) Die abstrakte Methode muss öffentlich oder geschützt sein (denn wenn sie privat ist, kann sie nicht von Unterklassen geerbt werden und Unterklassen können die Methode nicht implementieren). ). In Provinzfällen ist die Vorgabe öffentlich.

2) Abstrakte Klassen können nicht zum Erstellen von Objekten verwendet werden

3) Wenn eine Klasse von einer abstrakten Klasse erbt, muss die Unterklasse die abstrakte Methode der übergeordneten Klasse implementieren Klasse. Wenn die Unterklasse die abstrakte Methode der übergeordneten Klasse nicht implementiert, muss die Unterklasse auch als abstrakte Klasse definiert werden.

In anderen Aspekten gibt es keinen Unterschied zwischen abstrakten Klassen und gewöhnlichen Klassen.

2. Schnittstelle

Schnittstelle wird im Englischen als Schnittstelle bezeichnet. Im Software-Engineering bezieht sich Schnittstelle im Allgemeinen auf Methoden oder Funktionen, die von anderen aufgerufen werden. Von hier aus können wir die ursprüngliche Absicht des Java-Sprachdesigners erkennen, nämlich die Abstraktion des Verhaltens. In Java sieht die Form der Definition einer Schnittstelle wie folgt aus:

[public] interface InterfaceName {

}

Schnittstellen können Variablen und Methoden enthalten. Bitte beachten Sie jedoch, dass die Variablen in der Schnittstelle implizit als öffentliche statische Endvariablen bezeichnet werden (und sie können nur öffentliche statische Endvariablen sein. Wenn Sie sie mit „Private“ ändern, wird ein Kompilierungsfehler gemeldet), während die Methoden implizit als öffentliche Zusammenfassung bezeichnet werden Methoden können nur öffentliche abstrakte Methoden sein (Änderungen mit anderen Schlüsselwörtern wie private, protected, static, final usw. führen zu einem Kompilierungsfehler), und nicht alle Methoden in der Schnittstelle können bestimmte Implementierungen haben Sagen wir, die Methoden in der Schnittstelle müssen alle abstrakte Methoden sein. Von hier aus können Sie den Unterschied zwischen Schnittstellen und abstrakten Klassen vage erkennen. Schnittstellen sind ein äußerst abstrakter Typ und Variablen werden im Allgemeinen nicht in Schnittstellen definiert.

Damit eine Klasse einem bestimmten Satz von Schnittstellen folgt, müssen Sie das Schlüsselwort „implements“ verwenden. Das spezifische Format lautet wie folgt:

class ClassName implements Interface1,Interface2,[....]{
}

Wie Sie sehen können, ermöglicht es einer Klasse, mehreren spezifischen Schnittstellen zu folgen. Wenn eine nicht abstrakte Klasse einer Schnittstelle entspricht, muss sie alle Methoden in der Schnittstelle implementieren. Für eine abstrakte Klasse, die einer Schnittstelle folgt, ist es nicht erforderlich, die abstrakten Methoden in der Schnittstelle zu implementieren.

3. Der Unterschied zwischen abstrakten Klassen und Schnittstellen

1. Unterschiede auf Syntaxebene

1) Abstrakte Klassen können Member bereitstellen Methoden Implementierungsdetails, und in Schnittstellen können nur öffentliche abstrakte Methoden vorhanden sein;
2) Mitgliedsvariablen in abstrakten Klassen können von verschiedenen Typen sein, während Mitgliedsvariablen in Schnittstellen nur vom öffentlichen statischen Endtyp sein können
3) Schnittstellen kann keine statischen Codeblöcke und statischen Methoden enthalten, während abstrakte Klassen statische Codeblöcke und statische Methoden enthalten können.
4) Eine Klasse kann nur eine abstrakte Klasse erben, aber eine Klasse kann mehrere Schnittstellen implementieren.

2. Unterschiede auf Designebene

1）抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。举个简单的例子，飞机和鸟是不同类的事物，但是它们都有一个共性，就是都会飞。那么在设计的时候，可以将飞机设计为一个类Airplane，将鸟设计为一个类Bird，但是不能将 飞行 这个特性也设计为类，因此它只是一个行为特性，并不是对一类事物的抽象描述。此时可以将 飞行 设计为一个接口Fly，包含方法fly( )，然后Airplane和Bird分别根据自己的需要实现Fly这个接口。然后至于有不同种类的飞机，比如战斗机、民用飞机等直接继承Airplane即可，对于鸟也是类似的，不同种类的鸟直接继承Bird类即可。从这里可以看出，继承是一个 “是不是”的关系，而 接口 实现则是 “有没有”的关系。如果一个类继承了某个抽象类，则子类必定是抽象类的种类，而接口实现则是有没有、具备不具备的关系，比如鸟是否能飞（或者是否具备飞行这个特点），能飞行则可以实现这个接口，不能飞行就不实现这个接口。

2）设计层面不同，抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范，它是一种辐射式设计。什么是模板式设计？最简单例子，大家都用过ppt里面的模板，如果用模板A设计了ppt B和ppt C，ppt B和ppt C公共的部分就是模板A了，如果它们的公共部分需要改动，则只需要改动模板A就可以了，不需要重新对ppt B和ppt C进行改动。而辐射式设计，比如某个电梯都装了某种报警器，一旦要更新报警器，就必须全部更新。也就是说对于抽象类，如果需要添加新的方法，可以直接在抽象类中添加具体的实现，子类可以不进行变更；而对于接口则不行，如果接口进行了变更，则所有实现这个接口的类都必须进行相应的改动。

下面看一个网上流传最广泛的例子：门和警报的例子：门都有open( )和close( )两个动作，此时我们可以定义通过抽象类和接口来定义这个抽象概念：

abstract class Door {
  public abstract void open();
  public abstract void close();
}

或者：

interface Door {
  public abstract void open();
  public abstract void close();
}

但是现在如果我们需要门具有报警alarm( )的功能，那么该如何实现？下面提供两种思路：

1）将这三个功能都放在抽象类里面，但是这样一来所有继承于这个抽象类的子类都具备了报警功能，但是有的门并不一定具备报警功能；

2）将这三个功能都放在接口里面，需要用到报警功能的类就需要实现这个接口中的open( )和close( )，也许这个类根本就不具备open( )和close( )这两个功能，比如火灾报警器。

从这里可以看出， Door的open() 、close()和alarm()根本就属于两个不同范畴内的行为，open()和close()属于门本身固有的行为特性，而alarm()属于延伸的附加行为。因此最好的解决办法是单独将报警设计为一个接口，包含alarm()行为,Door设计为单独的一个抽象类，包含open和close两种行为。再设计一个报警门继承Door类和实现Alarm接口。

interface Alram {
  void alarm();
}

abstract class Door {
  void open();
  void close();
}
/**
 * Java学习交流QQ群：589809992 我们一起学Java！
 */
class AlarmDoor extends Door implements Alarm {
  void oepn() {
   //....
  }
  void close() {
   //....
  }
  void alarm() {
   //....
  }
}

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung von Schnittstellen und abstrakten Klassen in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!