Artikelverzeichnis
Vorwort
Abstrakte Klassen und Schnittstellen sind eigentlich eine Art Abstraktion. Was sind also die Gemeinsamkeiten und Unterschiede zwischen ihnen?
Welche Bedeutung haben abstrakte Klassen, die Schnittstellen implementieren?
1. Vergleich von abstrakter Klasse und Schnittstelle
- Jeder ist mit der Schnittstelle vertraut. Es handelt sich tatsächlich um eine Spezifikation, die die Eingabeparameter und Antiparameter der Methode angibt. Es handelt sich um eine Abstraktion. Das Schlüsselwort lautet Schnittstelle.
- Eine abstrakte Klasse ist eine mit Abstract modifizierte Klasse, die abstrakte Methoden enthalten kann oder nicht und über gewöhnliche Methoden verfügen kann
- Im Allgemeinen sind die Methoden in der Schnittstelle abstrakt und haben keinen Methodenkörper, aber nach Java8 wird die Standardmethode hinzugefügt (Sie werden nach dem Unterricht mehr darüber erfahren), wodurch die Schnittstelle einen Methodenkörper haben kann, also hier tatsächlich die Standardeinstellung ist erweitert Die Funktion der Schnittstelle ist der abstrakten Klasse nicht unterlegen;
- Für die Implementierung werden Schnittstellen verwendet. Bei der Implementierung einer Schnittstelle müssen Unterklassen alle Methoden in der Schnittstelle implementieren
- Abstrakte Klassen werden zur Vererbung verwendet. Abstrakte Methoden in abstrakten Klassen können selektiv in Unterklassen implementiert werden. Dies ist die Flexibilität abstrakter Klassen.
- Wenn ich dann eine abstrakte Klasse verwende, um eine Schnittstelle zu implementieren, kann ich einige Methoden in der abstrakten Klasse implementieren und einige Methoden nicht implementieren, sondern sie weiterhin in Unterklassen der abstrakten Klasse implementieren. Dann habe ich dies zwar implementiert Methode, aber es ist immer noch eine abstrakte Methode (Sie dachten, ich hätte sie implementiert, aber das habe ich nicht getan)
Blogger, die nur ohne Code erklären, sind gleichbedeutend mit Hooligans und geben dann den Code-Link ein
2. Beispiele zur Veranschaulichung von drei Situationen
1. Schnittstellenimplementierungsklasse
Nutzungsszenario: Ich habe zwei Zahlungsmethoden, WeChat/Alipay. Um die externe Logik zu vereinheitlichen, habe ich eine Schnittstelle für die externe Offenlegung erstellt, die für einheitliche Anrufe praktisch ist
Schnittstelle
public interface PayService {
/**
* 获取支付具体实现
*
* @return
*/
String getType();
/**
* 具体支付方法
*
* @param order
* @param money
* @return
*/
String toPay(String order, Integer money);
}
### 实现类
```java
@Service
public class AliPayServiceImpl implements PayService {
/**
* 获取支付具体实现
*
* @return
*/
@Override
public String getType() {
return "Ali";
}
/**
* 具体支付方法
*
* @param order
* @param money
* @return
*/
@Override
public String toPay(String order, Integer money) {
System.out.println("阿里支付用支付宝,优惠一元");
return "Ali支付 订单号: " + order + " 金额: " + (money - 1);
}
}
// =======================================================
@Service
public class WxPayServiceImpl implements PayService {
/**
* 获取支付具体实现
*
* @return
*/
@Override
public String getType() {
return "Wx";
}
/**
* 具体支付方法
*
* @param order
* @param money
* @return
*/
@Override
public String toPay(String order, Integer money) {
System.out.println("微信支付,原价支付");
return "Wx支付 订单号: " + order + " 金额: " + money;
}
}
2. Implementierungsklasse einer abstrakten Klasse
Verwendungsszenario: Es ist immer noch das erste Zahlungsszenario, ich werde es hier einfach ändern; die abstrakte Klasse kann auch normale Methoden haben, hier füge ich einen Zahlungsdruck hinzu
abstrakte Klasse
public abstract class PayService {
/**
* 获取支付具体实现
*
* @return
*/
abstract String getType();
/**
* 具体支付方法
*
* @param order
* @param money
* @return
*/
abstract String toPay(String order, Integer money);
/**
* 支付成功打印
*/
public void sout(){
System.out.println("我支付成功了");
}
}
Implementierungsklasse (Unterklasse)
@Service
public class AliPayServiceImpl extends PayService {
/**
* 获取支付具体实现
*
* @return
*/
@Override
public String getType() {
return "Ali";
}
/**
* 具体支付方法
*
* @param order
* @param money
* @return
*/
@Override
public String toPay(String order, Integer money) {
System.out.println("阿里支付用支付宝,优惠一元");
return "Ali支付 订单号: " + order + " 金额: " + (money - 1);
}
}
// =========================================================
@Service
public class WxPayServiceImpl extends PayService {
/**
* 获取支付具体实现
*
* @return
*/
@Override
public String getType() {
return "Wx";
}
/**
* 具体支付方法
*
* @param order
* @param money
* @return
*/
@Override
public String toPay(String order, Integer money) {
System.out.println("微信支付,原价支付");
return "Wx支付 订单号: " + order + " 金额: " + money;
}
}
这里看完是不是觉得抽象比接口强大,那为什么还要接口呢?
- Schnittstellen können mehrere Vererbungsprobleme lösen und eine flexiblere Erweiterung und Wartung ermöglichen
- Abstrakte Klassen und Schnittstellen in Java haben ihre eigenen Anwendungsszenarien. Sowohl abstrakte Klassen als auch Schnittstellen können Spezifikationen definieren, aber die Methoden zur Implementierung von Spezifikationen sind unterschiedlich. Eine abstrakte Klasse ist eine Spezifikation einer konkreten Implementierung, während eine Schnittstelle eine Verhaltensspezifikation ist.
- Abstrakte Klassen können die Einschränkungen der Einzelvererbung lösen und die durch Mehrfachvererbung verursachte Komplexität und Ineffizienz vermeiden
3. Die abstrakte Klasse implementiert die Schnittstelle
Verwendungsszenario: Immer noch ein Zahlungsszenario, in der Schnittstelle sind vier Methoden (abcd) definiert und es gibt drei Implementierungsklassen ABC; darunter muss
A ab d implementieren, B muss bc d implementieren und C muss ca implementieren d,
das sind die drei Implementierungsklassen von ABC. Es ist nicht erforderlich, alle Methoden in der Schnittstelle zu implementieren, aber es ist notwendig, die d-Methode zu implementieren, und es handelt sich um eine Logik. Hier ist es nicht erforderlich, die d-Methode in zu
implementieren jede Unterklasse. Was sollen wir tun, wenn wir den Code wiederholen? Wir fügen zwischen der Schnittstelle und der Implementierungsklasse eine abstrakte Klasse hinzu
Schnittstelle
public interface PayService {
/**
* 获取支付具体实现
*
* @return
*/
String getType();
/**
* 具体支付方法
*
* @param order
* @param money
* @return
*/
String toPay(String order, Integer money);
/**
* 扣减库存
* @param num 购买数量
* @return
*/
int decreaseStash(int num);
/**
* 打印成支付
*/
void sout();
}
abstrakte Klasse
public abstract class PayAbstract implements PayService{
/**
* 获取支付具体实现
*
* @return
*/
@Override
public String getType() {
return null;
}
/**
* 具体支付方法
*
* @param order
* @param money
* @return
*/
@Override
public String toPay(String order, Integer money) {
return null;
}
/**
* 扣减库存
*
* @param num 购买数量
* @return
*/
@Override
public int decreaseStash(int num) {
return 0;
}
/**
* 打印成支付
*/
@Override
public void sout() {
System.out.println("支付成功");
}
}
drei Implementierungsklassen
@Service
public class AliPayServiceImpl extends PayAbstract {
/**
* 获取支付具体实现
*
* @return
*/
@Override
public String getType() {
return "Ali";
}
/**
* 具体支付方法
*
* @param order
* @param money
* @return
*/
@Override
public String toPay(String order, Integer money) {
System.out.println("阿里支付用支付宝,优惠一元");
return "Ali支付 订单号: " + order + " 金额: " + (money - 1);
}
}
// ============================================================
@Service
public class WxPayServiceImpl extends PayAbstract {
/**
* 具体支付方法
*
* @param order
* @param money
* @return
*/
@Override
public String toPay(String order, Integer money) {
System.out.println("微信支付,原价支付");
return "Wx支付 订单号: " + order + " 金额: " + money;
}
/**
* 扣减库存
*
* @param num 购买数量
* @return
*/
@Override
public int decreaseStash(int num) {
return num;
}
}
// ============================================================
@Service
public class JUHEPayServiceImpl extends PayAbstract {
/**
* 获取支付具体实现
*
* @return
*/
@Override
public String getType() {
return "JUHE";
}
/**
* 扣减库存
*
* @param num 购买数量
* @return
*/
@Override
public int decreaseStash(int num) {
return num;
}
}
Auf diese Weise wird zwischen der Schnittstelle und der abstrakten Klasse eine weitere Abstraktionsschicht erstellt. Die Abstraktionsschicht extrahiert die öffentliche Methode d (sout) und macht jede Implementierungsklasse flexibler, um die Methode zu implementieren
Zusammenfassen
Die Bedeutung der abstrakten Klasse, die die Schnittstelle implementiert, besteht darin, eine flexible und hierarchische Codestruktur bereitzustellen, die zur Erreichung von Modularität und Wartbarkeit beiträgt.
Insbesondere kann eine abstrakte Klasse als Basisklasse in einer Vererbungshierarchie dienen und einige öffentliche Methoden und Attribute bereitstellen, die von Unterklassen erbt und erweitert werden können. Die Schnittstelle definiert eine Reihe verwandter Methodenspezifikationen und schränkt das Verhalten der Klasse oder abstrakten Klasse ein, die diese Methoden implementiert. Dies trägt dazu bei, die Modularität des Codes sicherzustellen und die Wiederverwendbarkeit und Wartbarkeit des Codes zu erhöhen.
Die abstrakte Klasse entspricht einer erneuten Abstraktion auf der Grundlage der ursprünglichen Abstraktion und dem Extrahieren einiger öffentlicher Methoden.