浅谈Java抽象类和接口的个人理解

Oggi voglio condividere la mia comprensione delle classi astratte e degli interface in Java, inclusi contenuti di riferimento:

1、Classe astratta

1、定义：

public abstract class NomeClasse{}

In Java, tutti gli oggetti sono descritti tramite classi, ma non tutte le classi sono utilizzate per descrivere oggetti. La mia comprensione della classe astratta è che è un'elevata estrazione delle parti comuni di una categoria di cose, che include attributi e comportamenti. Ad esempio, il bovino, la pecora e il maiale hanno in comune l'attributo di avere peli e il comportamento di allattamento, quindi possiamo astrarre la parte comune in una classe mammifera, che contiene l'attributo peli e il comportamento di allattamento. Quando il bovino, la pecora e il maiale ereditano la classe mammifera, acquisiscono anche la funzione di allattamento, e come completare questa funzione deve essere realizzato autonomamente.

2、Caratteristiche

(1) Le classi modificate con la parola chiave Abstract sono classi astratte;

（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）接口中只定义抽象方法，没有具体的实现；

（3）实现接口的类必须实现接口中定义的所有方法；

3、验证以上理论是否正确

同样，验证出上面的理论都是正确的！

三、抽象类和接口的区别：

1、抽象类中可以有自己的成员方法及其具体实现；接口中只能包含抽象方法；

2、在抽象类中可以包含各种类型的成员变量；接口中的成员变量只能是public static final的；

3、Una classe può ereditare solo una classe astratta, ma può implementare più interfacce;

4、Le classi astratte possono contenere blocchi statici e metodi statici; Le interfacce non possono definire blocchi statici e metodi statici;

Verificare che una classe possa ereditare solo una classe astratta, ma può implementare più interfacce

Prima di tutto, definire due classi astratte: una classe mammifero Mammals, una classe di scrittura Crawler

/**
 * @createtime 17 marzo 2017 ore 10:33:27
 * @description Classe mammifero 
 */
public abstract class Mammals {
	public String foods;
	public abstract void nurse();
	public void eat(String food){
		this.foods = food;
		System.out.println("Mangiare"+foods);
	}
}

/**
 * 
 * @createtime 17 marzo 2017 ore 11:23:09
 * @description Definire una classe astratta - classe di scrittura
 */
public abstract class Crawler {
	public abstract void crawl();
}

In secondo luogo, definire due interfacce: una interfaccia di base BaseAction; e un'interfaccia speciale SpecialAction

/**
 * 
 * @createtime 17 marzo 2017 ore 11:03:42
 * @description Definire un'interfaccia chiamata comportamento di base
 */
public interface BaseAction {
	public String name = "";
	public void eat();
	public void sleep();
}

/**
 * @createtime 17 marzo 2017 ore 11:24:56
 * @description Definire un'interfaccia per implementare comportamenti speciali
 */
public interface SpecialAction {
  public void study();
}

Poi definire una classe base People, che eredita la classe Mammals e implements l'interfaccia BaseAction e l'interfaccia SpecialAction

/**
 * @createtime 17 marzo 2017 11:25:48
 * @description Definire una classe comune - Uomo, ereditare la classe Mammals e implementare l'interfaccia di base e l'interfaccia speciale
 */
public class People extends Mammals implements BaseAction,SpecialAction{
	@Override
	  public void study() {}}
		// TODO metodo stub automaticamente generato
	}
	@Override
	  public void eat() {
		// TODO metodo stub automaticamente generato
	}
	@Override
	  public void sleep() {
		// TODO metodo stub automaticamente generato
	}
	@Override
	  public void nurse() {
		// TODO metodo stub automaticamente generato
	}
}

Si può vedere che una sottoclasse può implementare più interfacce

Infine, far ereditare la classe base People alla classe Mummals e alla classe Crawler

/**
 * @createtime 17 marzo 2017 11:25:48
 * @description Definire una classe comune - Uomo, ereditare la classe Mammals e implementare l'interfaccia di base e l'interfaccia speciale
 */
public class People extends Mammals, Crawler {
	@Override
	  public void nurse() {
		// TODO metodo stub automaticamente generato
	}
}

Conclusione

Questo è tutto il contenuto che ho trattato nel mio articolo su una breve discussione delle classi astratte e delle interfacce in Java, spero possa essere utile a tutti voi. Gli amici interessati possono continuare a consultare il nostro sito:

Esempio di ereditarietà e astrazione di bean in Spring

Introduzione all'idea centrale di Hibernate e ai concetti di interfaccia

Esempio di utilizzo dell'interfaccia (interface) in Java

Se c'è qualcosa di insufficiente, sei libero di lasciare un commento. Grazie per il supporto dei nostri amici a questo sito!

Dichiarazione: il contenuto di questo articolo è stato prelevato da Internet, il copyright è di proprietà del rispettivo autore, il contenuto è stato contribuito e caricato autonomamente dagli utenti di Internet, questo sito non detiene i diritti di proprietà, non è stato editato manualmente e non assume responsabilità legali correlate. Se trovi contenuti sospetti di violazione del copyright, sei invitato a inviare una email a: notice#oldtoolbag.com (al momento dell'invio dell'email, sostituisci # con @) per segnalare il problema e fornire prove pertinenti. Una volta verificata la sussistenza del problema, questo sito rimuoverà immediatamente il contenuto sospetto di violazione del copyright.