Abstrakte Funktionen von Java – vertieftes Verständnis abstrakter Klassen und Schnittstellen

Wichtige Punkte:

• Abstraktklasse

• Schnittstelle

• Der Unterschied zwischen abstrakter Klasse und Schnittstelle

Abstrakt

FürObjektorientierteProgrammierung ist Abstraktion eines der vier Hauptmerkmale. In Java kann die OOP-Abstraktion in zwei Formen widergespiegelt werden: Schnittstelle und abstrakte Klasse. Schnittstellen und abstrakte Klassen bieten uns eine strukturiertere Möglichkeit, Schnittstellen von Implementierungen zu trennen.

---

2. Abstrakte Klasse

1). Konzeptionelle Basis

Wir alle wissen, dass im objektorientierten Bereich alles ein ist Objekt. Gleichzeitig werden alle Objekte durch Klassen beschrieben, aber nicht alle Klassen können Objekte beschreiben (object = State + Behavior). Wenn eine Klasse nicht über genügend Informationen verfügt, um ein bestimmtes Objekt zu beschreiben, können wir eine solche Klasse als abstrakte Klasse festlegen. Abstrakte Klassen können nur durch öffentliche und Standardmodifikatoren geändert werden.

Bevor wir abstrakte Klassen verstehen, lernen wir zunächst etwas über abstrakte Methoden . Abstrakte Methode ist eine besondere Methode: Sie verfügt nur über eine Deklaration, aber keine spezifische Implementierung. Das Deklarationsformat abstrakter Methoden ist:

abstract void func();

Abstrakte Methoden müssen mit dem Schlüsselwort abstract geändert werden. Wenn eine Klasse eine abstrakte Methode enthält, wird sie als abstrakte Klasse bezeichnet. Die abstrakte Klasse muss mit dem abstrakten Schlüsselwort vor der Klasse geändert werden (es ist wichtig zu beachten, dass eine abstrakte Klasse keine enthalten muss abstrakte Methode, d. h. alle Methoden sind spezifische Methoden). Da die abstrakte Klasse Methoden enthält, die nicht konkret implementiert sind, können Sie die abstrakte Klasse nicht zum Erstellen eines Objekts verwenden.

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

Wie Sie hier sehen können, existiert die abstrakte Klasse für die Vererbung, wenn Sie eine abstrakte Klasse definieren Sie erben es nicht, dann haben Sie diese abstrakte Klasse umsonst erstellt, weil Sie damit nichts tun können. Wenn bei einer übergeordneten 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 als deklariert werden abstrakte Methode. Zu diesem Zeitpunkt wird diese Klasse zu einer abstrakten Klasse.

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

• Abstrakte Methoden können nicht privat sein, andernfalls können sie nicht in Unterklassen unterteilt werden Vererbt, Unterklassen können diese Methode nicht implementieren, daher macht es keinen Sinn, dies zu tun.

• Abstrakte Klassen können nicht zum Erstellen von Objekten verwendet werden.

• Wenn eine Klasse von einer abstrakten Klasse erbt, muss die Unterklasse die abstrakte Methode der übergeordneten Klasse implementieren. 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). Essenz

• Der einzige Unterschied zwischen abstrakter Klasse und konkreter Klassenunterschied: Eine Klasse, die abstrakte Methoden enthält, muss eine abstrakte Klasse sein

• Die grundlegende Funktion einer abstrakten Klasse besteht darin, zu erben, Daher kann die Abstraktion einer abstrakten Klasse nicht durch private Methoden geändert werden.

• Abstrakte Klassen haben nur einen abstrakteren Faktor als konkrete Klassen: Abstraktion auf Verhaltensebene (kann abstrakte Methoden umfassen) ;

---

3. Konzeptionelle Basis

　　接口(interface)，在软件工程中，接口泛指供别人调用的方法或者函数。从这里，我们可以体会到Java语言设计者的初衷，它是对行为的抽象。接口只能被public和默认修饰符修饰。 在Java中，定义一个接口的形式如下：

public interface InterfaceName {}

　　接口中可以含有 变量和方法。但是要注意，接口中的 变量 会被隐式地指定为 public static final变量（并且只能是public static final变量，而且 public static final 可省，即默认就是public static final 的） ，而 方法 会被隐式地指定为 public abstract方法且只能是 public abstract 方法（public abstract  可省，即默认就是 public abstract 的），并且接口中所有的方法不能有具体的实现，也就是说，接口中的方法必须都是抽象方法。从这里可以隐约看出接口和抽象类的区别，接口是一种极度抽象的类型，它比抽象类更加“抽象”。

　　要让一个类遵循某组特地的接口需要使用 implements 关键字，具体格式如下：

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

}

　　可以看出，允许一个类遵循多个特定的接口。如果一个非抽象类遵循了某个接口，就必须实现该接口中的所有方法。对于遵循某个接口的抽象类，可以不实现该接口中的抽象方法。

2).本质

• 接口是一种行为契约，是对行为的抽象；

---

四. 接口与抽象类的区别

1.语法层面上的区别

　　1）抽象类可以提供成员方法的实现细节，而接口中只能存在 public abstract (可省) 方法；

　　2）抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final (可省) 类型的；

　　3）接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；

　　4）一个类只能继承一个抽象类，而一个类却可以实现多个接口。

　　　　　　　　　

---

2.设计层面上的区别

　　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();
}

class AlarmDoor extends Door implements Alarm {    void oepn() {      //....
    }    void close() {      //....
    }    void alarm() {      //....
    }
}

---

3、小结

• 抽象类是对一种事物的抽象，接口是对行为的抽象；

• 抽象类是一种模板，接口是一种契约；

• 抽象类的抽象程度介于普通类和接口之间。

Das obige ist der detaillierte Inhalt vonAbstrakte Funktionen von Java – vertieftes Verständnis abstrakter Klassen und Schnittstellen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!