Kurzgefasstes Verständnis von Java-Abstrakten Klassen und Schnittstellen

Heute möchte ich meine eigenen Gedanken über die abstrakten Klassen und Schnittstellen in Java teilen, inklusive Referenzmaterialien:

Einleitung: Abstrakte Klasse

1、定义：

public abstract class 类名{}

Java语言中所有的对象都是用类来进行描述，但是并不是所有的类都是用来描述对象的。我所理解的抽象类其实就是对同一类事物公共部分的高度提取，这个公共部分包括属性和行为。比如牛、羊、猪它们的公共属性是都有毛，公共行为是都哺乳，所以我们可以把公共部分抽象成一个哺乳类，含有属性毛和行为哺乳，当牛、羊、猪继承了哺乳类后也就有了哺乳的功能，至于怎么完成这个功能就需要自己去实现了。

2、特点

（1）被Abstract关键字修饰的类是抽象类；

（2）含有抽象方法的类一定是抽象类，但是抽象类不一定含有抽象方法；且抽象方法必须是public或protected，否则不能被子类继承。默认为public。

（3）抽象方法中不能有实现，否则编译报错；

（4）抽象类中可以定义自己的成员变量和成员方法；

（5）子类继承抽象类时，必须实现抽象类中的所有抽象方法，否则该子类也要被定义为抽象类；

（6）抽象类不能被实例化。

3、验证以上规定是否确实如其所述

这是我在word中编辑的一张验证表，把它截成图片放在这里：

从上图的验证结果来看，那些理论都是正确的

二、接口

1、定义：

public interface 接口名{}

接口是用来提供方法的。按我的理解，它是对多个类公共行为的高度提取，比如所有的动物它们的公共行为是吃和睡，那么我们就可以将这两个行为提取出来封装在一个接口中，当某个动物需要执行这个行为的时候只要调用该接口，然后在自己的类里面完成具体实现就行。这样理解好像跟抽象类没什么区别，那再看下面的这个例子。如果把这两个行为放在抽象类中，但是该抽象类中还有一个爬的行为，此时当一种爬行动物，比如蛇，当它继承这个类的时候，会实现吃、睡、爬行这三个方法，于是它便有了吃、睡、爬的功能；但是如果一个飞行类的动物如鸟，当它继承了这个方法的时候，同样的也有了吃、睡、爬的功能，很明显，爬不是它需要的功能，这就有点词不达意了，但是当他们继承了只有吃、睡的接口，就有了吃、睡的基本功能，至于爬和飞，可以抽象出来放在抽象类中，按需继承，按需实现自己需要的功能就OK了。

2、特点：

（1）接口中可以有自己的成员变量，但会被隐式地指定为public static final，而且也只能是public static final的，接口中所有的方法都是抽象方法，都会被隐式地指定为public abstract的。

（2）Schnittstellen definieren nur abstrakte Methoden, haben keine spezifische Implementierung;

（3）Klassen, die Schnittstellen implementieren, müssen alle Methoden, die in der Schnittstelle definiert sind, implementieren;

3、Überprüfe, ob die obigen Theorien korrekt sind

Gleichzeitig wurde bestätigt, dass alle obigen Theorien korrekt sind!

Drittes, der Unterschied zwischen abstrakter Klasse und Schnittstelle:

1、Abstrakte Klassen können eigene Member-Methoden und ihre spezifische Implementierung haben; Schnittstellen können nur abstrakte Methoden enthalten;

2、Abstrakte Klassen können verschiedene Arten von Member-Variablen enthalten; die Member-Variablen in Schnittstellen müssen public static final sein;

3、Eine Klasse kann nur eine abstrakte Klasse erben, aber mehrere Schnittstellen implementieren können;

4、Abstrakte Klassen können statische Codeblöcke und statische Methoden enthalten; Schnittstellen können keine statischen Codeblöcke und statischen Methoden definieren;

Überprüfe, dass eine Klasse nur eine abstrakte Klasse erben kann, aber mehrere Schnittstellen implementieren kann

Zunächst definiere zwei abstrakte Klassen: eine Säugetierklasse Mummals und eine Kletterklasse Crawler

/**
 * @createtime 2017Jahr3Monat17Tag Vormittag10:33:27
 * @description Säugetierklasse 
 */
public abstract class Mammals {
	public String foods;
	public abstract void nurse();
	public void eat(String food){
		this.foods = food;
		System.out.println("essen"+foods);
	}
}

/**
 * 
 * @createtime 2017Jahr3Monat17Tag Vormittag11:23:09
 * @description Definiere eine abstrakte Klasse--Kletterklasse
 */
public abstract class Crawler {
	public abstract void crawl();
}

Zweitens, definiere zwei Schnittstellen: eine ist die Basisschnittstelle BaseAction; die andere ist die SpecialAction-Schnittstelle

/**
 * 
 * @createtime 2017Jahr3Monat17Tag Vormittag11:03:42
 * @description Definiere eine Schnittstelle für grundlegende Verhaltensweisen
 */
public interface BaseAction {
	public String name = "";
	public void eat();
	public void sleep();
}

/**
 * @createtime 2017Jahr3Monat17Tag Vormittag11:24:56
 * @description Definiere eine Schnittstelle, um spezielle Verhaltensweisen zu realisieren
 */
public interface SpecialAction {
  public void study();
}

Dann, definiere eine Basisklasse People, die von der Klasse Mummals erbt und die Schnittstellen BaseAction und SpecialAction implementiert.

/**
 * @createtime 2017Jahr3Monat17Tag Vormittag11:25:48
 * @description Definiere eine gewöhnliche Klasse--Menschen, Erben von Säugetieren, Implementierung von Basisschnittstellen und speziellen Schnittstellen
 */
public class People extends Mammals implements BaseAction, SpecialAction {}}
	@Override
	  public void study() {
		// TODO Auto-generierter Methodenstummel
	}
	@Override
	  public void eat() {
		// TODO Auto-generierter Methodenstummel
	}
	@Override
	  public void sleep() {
		// TODO Auto-generierter Methodenstummel
	}
	@Override
	  public void nurse() {
		// TODO Auto-generierter Methodenstummel
	}
}

Es ist erkennbar, dass eine Unterklasse mehrere Schnittstellen implementieren kann

Schließlich, lassen Sie die Basisklasse People gleichzeitig die Klasse Mammals und die Klasse Crawler erben

/**
 * @createtime 2017Jahr3Monat17Tag Vormittag11:25:48
 * @description Definiere eine gewöhnliche Klasse--Menschen, Erben von Säugetieren, Implementierung von Basisschnittstellen und speziellen Schnittstellen
 */
public class People extends Mammals, Crawler {
	@Override
	  public void nurse() {
		// TODO Auto-generierter Methodenstummel
	}
}

Zusammenfassung

Das ist der gesamte Inhalt dieses Artikels über meine persönliche Auffassung von Java-Abstrakten Klassen und Schnittstellen. Ich hoffe, es hilft Ihnen. Interessierte Freunde können weiterhin die Website konsultieren:

Beispielcode zur Vererbung und Abstraktion von Beans in Spring

Kernidee von Hibernate und Kurzeinführung in Schnittstellen

Java-Schnittstelle (interface) und Beispielnutzung in Java

Bitte hinterlassen Sie eine Nachricht, wenn Sie etwas Verbessernes vorschlagen können. Vielen Dank, dass Sie die Unterstützung dieser Website begrüßen!

Erklärung: Der Inhalt dieses Artikels wurde aus dem Internet übernommen und gehört dem Urheberrechtsinhaber. Der Inhalt wurde von Internetbenutzern freiwillig beigesteuert und hochgeladen. Diese Website besitzt keine Eigentumsrechte und hat den Inhalt nicht von Hand bearbeitet. Sie übernimmt auch keine Haftung für rechtliche Verantwortlichkeiten. Wenn Sie urheberrechtlich anstößige Inhalte entdecken, sind Sie herzlich eingeladen, eine E-Mail an notice#w zu senden.3codebox.com (Bitte ersetzen Sie # durch @, wenn Sie eine E-Mail senden, um zu melden, und fügen Sie relevante Beweise bei. Sobald nachgewiesen, wird die Website die beanstandeten urheberrechtlichen Inhalte sofort löschen.)