Abstrakte Java-Klassen und -Schnittstellen

Java Abstract Class

Unsere übergeordnete Klasse hat einige Methoden festgelegt. Der Hauptzweck ihrer Festlegung besteht darin, die Unterklasse die übergeordnete Klasse erben zu lassen, um diese Methoden zu überschreiben, um unterschiedliche Ergebnisse anzuzeigen. Mit anderen Worten, die spezifische Implementierung der Methode der übergeordneten Klasse ist uns egal. Sie wird sowieso von der Methode der untergeordneten Klasse überschrieben. Dann können wir die übergeordnete Klasse so abstrakt machen, dass sie nur über die Methodendeklaration verfügt kein Methodenkörper. Wir nennen diese Methode eine abstrakte Methode, und die Klasse, die die abstrakte Methode enthält, wird als abstrakte Klasse bezeichnet.

Eigenschaften abstrakter Klassen

Solange eine abstrakte Klasse eine oder mehrere abstrakte Methoden enthält, handelt es sich um eine abstrakte Klasse. Wenn es jedoch keine abstrakte Methode gibt, dann hat diese abstrakte Klasse keine Bedeutung. Abstrakte Methoden sind Methoden mit dem folgenden Format:

[öffentlicher] abstrakter Rückgabetyp-Methodenname (Parameterliste);
Abstrakte Methoden haben keinen Methodenkörper, daher wird nach dem Schreiben des Methodennamens „;“ Am Ende wird der Methodenkörper der abstrakten Methode mit „abstrakt“ versehen, was darauf hinweist, dass es sich um eine abstrakte Methode handelt. Der Zugriffsmodifikator kann nur öffentlich oder geschützt sein oder die Standardzugriffsberechtigung, aber nicht privat sein , weil es überhaupt nicht vererbt werden kann
Ebenso ist das Format einer abstrakten Klasse wie folgt:

[public] abstract class 类名{
    [public] abstract 返回类型 方法名(参数列表);
}

Die abstrakte Klasse wird durch Hinzufügen von „abstract“ am Anfang geändert, was darauf hinweist, dass es sich um eine abstrakte Klasse handelt . Der Zugriffsmodifikator kann nur öffentlich oder geschützt sein oder die Standardzugriffsberechtigung, die nicht verwendet werden kann. Der Grund für privat ist derselbe wie oben.
Die Bedeutung der Erstellung abstrakter Klassen besteht darin, die Methodendeklaration von der Methodenimplementierung zu trennen und so Polymorphismus zu erreichen. Dann weist es die folgenden Merkmale auf:

Abstrakte Klassen können nicht instanziiert werden, was bedeutet, dass ein Objekt einer abstrakten Klasse nicht direkt erstellt werden kann, aber eine abstrakte Klasse kann einen Konstruktor haben. Wenn es sich um einen parametrisierten Konstruktor handelt Die Unterklasse muss es explizit aufrufen.
Abstrakte Klassen sollen vererbt werden und Methoden müssen überschrieben werden. Wenn eine Unterklasse eine abstrakte übergeordnete Klasse erbt, muss sie die abstrakte Methode der übergeordneten Klasse überschreiben. Wenn sie nicht überschrieben wird, muss die Unterklasse ebenfalls definiert werden als abstrakte Klasse.
Abstract kann nicht zusammen mit privaten statischen und finalen Modifikatoren zum Ändern von Methoden verwendet werden.

Hier erklären wir den dritten Punkt: Abstract kann nicht mit Private verwendet werden, da auf die von Private geänderten Methoden und Klassen außerhalb der Klasse nicht zugegriffen werden kann. Es besteht keine Möglichkeit einer Vererbung. Abstract kann nicht zusammen mit Static verwendet werden, da die Funktion von Abstract darin besteht, Polymorphismus zu erreichen, und das Erreichen von Polymorphismus auf Vererbung und Überschreiben beruht. Obwohl statisch geänderte Methoden von Unterklassen geerbt werden können, kann dies nicht als überschrieben angesehen werden, wenn wir die geerbte Methode ändern. Stattdessen wird die Methode der übergeordneten Klasse ausgeblendet und nur der Name der übergeordneten Klasse und der Methodenname können verwendet werden zeigt, dass der Aufruf keinen Polymorphismus erreicht. Aus einer anderen Perspektive werden statische Methoden zur Kompilierungszeit bestimmt und eine späte Bindung kann nicht erreicht werden, sodass keine Möglichkeit besteht, Methodenaufrufe zur Laufzeit zu bestimmen. Daher kann die statisch modifizierte Methode vererbt werden, sie kann jedoch keinen Polymorphismus erreichen und kann natürlich nicht mit abstrakten Methoden verwendet werden.
Der Grund, warum Abstract nicht mit Final verwendet werden kann, ist der gleiche wie oben. Die durch Final geänderte Methode kann nicht vererbt werden und ist natürlich nicht polymorph, sodass Abstract nicht mit Final verwendet werden kann.

Beispiel einer abstrakten Klasse

Lassen Sie uns das obige polymorphe Beispiel weiter modifizieren und abstrahieren. Wir ändern den Animal-Code so, dass er so aussieht.

public abstract class Animal {    
  abstract void run();
}

Der Code unserer Hunde- und Katzenkurse muss nicht geändert werden.

public class Dog extends Animal{
    @Override
    public void run() {
        System.out.println("狗在奔跑");
    }
}public class Cat extends Animal{
    @Override
    public void run() {
        System.out.println("猫在奔跑");
    }
}

Die Codes anderer Print-Klassen und Testklassen bleiben ebenfalls unverändert. Der Code lautet wie folgt:

public class Print {    
    public void print(Animal animal) {
        animal.run();
    }
}
public class Test {    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();        
        new Print().print(dog);        
        new Print().print(cat);
    }
}

Wir können sehen, dass die abstrakte Klasse und die vorherige gewöhnliche Klasse identisch sind An anderen Stellen gibt es grundsätzlich keine Änderungen, aber die Methode wird abstrakter und die Bedeutung klarer.

Abstrakte Zusammenfassung

Es ist sehr sinnvoll, abstrakte Klassen und abstrakte Methoden zu erstellen. Dadurch können wir die Bedeutung der Klasse beim Entwerfen der Klasse klarer machen Um es allgemeiner zu gestalten: Deklarieren Sie eine Reihe von Methoden, um dem Benutzer mitzuteilen, wie er sie verwenden soll.

Java-Schnittstelle

Die Schnittstelle kann als Protokoll und Anforderung betrachtet werden. Wir erben sie, um zu wissen, was wir tun können, und wie wir es tun, hängt von uns ab. KFC ist zum Beispiel eine Schnittstelle. Wenn wir es uns ansehen, können wir erkennen, dass wir Hamburger, Brathähnchen und Cola kaufen können, aber der spezifische Geschmack und der Service werden je nach Geschäft unterschiedlich aussehen. Das ist die Bedeutung der Schnittstelle . Wir können hier also auch sehen, dass die Methoden in der Schnittstelle ebenfalls abstrakt sein sollten.

Eigenschaften von Schnittstellen

Die Art und Weise, Schnittstellen in Java zu schreiben, ist wie folgt:

[public] interface InterfaceName {
         成员变量
         方法声明
}

Schnittstellen unterscheiden sich von Klassen. Sie werden nicht durch Klassen, sondern durch modifiziert Bei bestimmten Schnittstellenschlüsselwörtern ist der Zugriffsmodifikator mit der Klasse konsistent und kann öffentlich oder standardmäßig sein. Es gibt nur zwei Arten von Inhalten: abstrakte Methoden und Mitgliedsvariablen. Mitgliedsvariablen werden standardmäßig als öffentliches statisches Finale hinzugefügt. Dies bedeutet, dass Mitgliedsvariablen als im Besitz befindliche Variablen eingestuft werden und über die größten Zugriffsrechte verfügen, aber nicht vererbt oder geändert werden können. Dies zeigt auch, dass die Schnittstelle auf diese Weise vereinbart wird, da sie nicht instanziiert werden kann. Die Mitgliedsvariablen der Schnittstelle dürfen nicht leer sein und ihnen müssen bei der Definition Werte zugewiesen werden. Schnittstellenmethoden werden standardmäßig zu abstrakten Methoden hinzugefügt. Wie bei abstrakten Methoden können nur Methodendeklarationen geschrieben werden.
Anders als wir Extends verwenden, um eine Klasse zu erben, verwenden wir Implements, um die Implementierung dieser Schnittstelle darzustellen.

class ClassName implements Interface1{
}

Als besondere Existenz verfügt die Schnittstelle über einige einzigartige Funktionen.

一个类是可以实现多个接口的，这在一定程度上实现了Java的多继承。 
接口是不能被实例化，不同于抽象类，接口的内部只能由成员变量和抽象方法，是不可以存在静态变量块，以及构造器的。 
我们是可以声明一个接口类型的变量，但是只能引用一个实现了这个接口的类。 
同抽象方法，实现了接口的类必须实现接口的所有方法，否则就会变成抽象类。 
接口举例

看过抽象的例子，我们可能想，我们把Animal从抽象换成接口，不就实现了一个接口的例子嘛，其他地方基本也不用去改动。但这显然是错的。我们并不能去说Animal是一个接口，我们上面说了，接口是一种协议，规定我们能做什么，而不是一个事物的抽象。从这里我们也能看出接口和抽象的不同，抽象更多的是一种重构而产生的东西，我们先有dog,cat类，然后才会把他们共性的东西提取出来，放到一个更通用，更抽象的父类Animal中，而我们发现Animal不需要管run方法是怎么实现的，所以我们将run方法设定为抽象的方法，从而将Animal类设为抽象类，等待去=继承者来实现run。这是一种从下而上的设计思想。但是接口不是，接口一开始就是设定好的，我们根据设定好的接口从上往下去写。接口先规定好了有什么方法，然后我们再去具体实现他。这是一种从上而下的设计思想。 
所以，我们不能将Animal设为接口，但是我们可以将Print设为接口，他规定我们有一个print()方法，代码如下：

public interface Print {    
  void print(Object obj);
}

那我们就可以写一个新的类去实现这个Print接口。代码如下：

public class SimplePrint implements Print{
    @Override
    public void print(Object obj) {
        ((Animal)obj).run();
    }
}

除了Test类以外，其他地方都不需要改变。我们Test类代码如下：

public class Test {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();        
        Print print = new SimplePrint();        
        print.print(dog);        
        print.print(cat);
    }
}

接口总结

接口和抽象虽然都是通过抽象的方法来提供我们实现多态的方式，但是他们却是两个不同的设计思想。这里关于接口的讲解比较简单，关于接口自身的继承，接口内部包含其他接口，以及利用接口来实现回调等等留在以后的文章专门来说。这里主要是通过对比来了解抽象和接口。