java中抽象類和接口的相同和不同點介紹

更新時間：2021年12月19日 09:04:10 作者：白了又了白1992

大家好，本篇文章主要講的是java中抽象類和接口的相同和不同點介紹，感興趣的同學趕快來看一看吧，對你有幫助的話記得收藏一下，方便下次瀏覽

前言

本文簡單介紹抽象類，接口以及它們的異同點，另附簡單的代碼舉例。

一、抽象類是什么？

在 Java 語言中使用 abstract class 來定義抽象類。抽象類是不能被實例化的，即不能用new關(guān)鍵字來實例化對象。包含抽象方法的一定是抽象類，但抽象類不一定包含抽象方法。如果一個子類實現(xiàn)了父類（抽象類）的所有抽象方法，那么該子類可以不必是抽象類，否則就是抽象類。抽象類中的抽象方法的修飾符只能為public或者protected。

為什么要在抽象類中定義抽象方法呢？下面我們來看一個代碼實例：

package example;
 
import java.util.Date;
 
public abstract class GeometricObject {
	private String color="white";
	private boolean filled;
	private java.util.Date dateCreated;
	protected GeometricObject() {
		dateCreated=new java.util.Date();
	}//構(gòu)建默認的幾何對象
	protected GeometricObject(String color,boolean filled) {
		dateCreated=new java.util.Date();
		this.color=color;
		this.filled=filled;
	}
	public String getColor() {
		return color;
	}//返回顏色
	public void setColor(String color) {
		this.color=color;
	}//設置新的顏色
	public boolean getFilled() {
		return filled;
	}
	public void setFilled(boolean filled) {
		this.filled=filled;
	}
	public java.util.Date getDateCreated(){
		return dateCreated;
	}
	public abstract double getArea();//抽象方法定義得到面積
	public abstract double getPerimeter();//抽象方法得到周長
}

我們假設自定義的Circle類和Rectangle類均為GeometricObject的子類，且均有求各自面積的getArea()方法和各自周長的getPerimeter()方法，但這些方法并不能在父類中定義，因為具體的計算方法要取決于幾何對象的具體類型。所以采取抽象方法進行定義，這樣可以保證父類中的抽象方法可以在子類中被重寫。

抽象類只有定義沒有實現(xiàn)。

下面是抽象類值得注意的幾點：

1.抽象方法不能包含在非抽象類中。如果抽象父類的子類不能實現(xiàn)所有的抽象方法，那么子類也必須定義為抽象的。也就是說，在繼承自抽象類的非抽象子類中，必須實現(xiàn)所有的抽象方法。還要注意到，抽象方法是靜態(tài)的。

2.抽象類不能使用new操作符來初始化。但仍然可以定義它的構(gòu)造方法，這個構(gòu)造方法在它的子類的構(gòu)造方法中進行調(diào)用。

3.包含抽象方法的類必須是抽象的。但是是可以定義一個不包含抽象方法的抽象類，這個抽象類用于作為定義新子類的基類。

4.即使子類的父類是具體的，這個子類也可以是抽象的。

5.不能使用new操作符從一個抽象類創(chuàng)建一個實例，但是抽象類可以用做一種數(shù)據(jù)類型。

例如：GeometricObject[] objects=new GeometricObject[10];是正確的，。

6.子類可以重寫父類的方法并將它定義為抽象的，這雖然不常見，但很適用于當父類的方法實現(xiàn)在子類中變得無效時的情況。

二、接口是什么？

接口是一種與類很相似的結(jié)構(gòu)，用于為對象定義共同操作，但它的目的是指明相關(guān)或者不相關(guān)類的對象的共同行為。

Java中接口使用interface關(guān)鍵字修飾。接口是抽象方法的集合。如果一個類實現(xiàn)了某個接口，那么它就繼承了這個接口的抽象方法。

類和接口之間的關(guān)系稱為接口繼承。

下面是簡單的代碼舉例：

package example;
 
public class TestEdible {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Object[] objects= {new Tiger(),new Chicken(),new Apple()};
		//創(chuàng)建由Tiger，Chicken和Apple類型的三個對象構(gòu)成的數(shù)組
		for(int i=0;i<objects.length;i++) {
			if(objects[i] instanceof Edible)
				System.out.println(((Edible)objects[i]).howToEat());
			if(objects[i] instanceof Animal) {
				System.out.println(((Animal)objects[i]).sound());
		}
		}//如果可食用，則調(diào)用howToEat方法，如果是動物，則調(diào)用sound方法
	}
 
}
abstract class Animal{
	private double weight;
	public double getWeight() {
		return weight;
	}
	public void setWeight(double weight) {
		this.weight=weight;
	}
	public abstract String sound();//返回動物的聲音，是抽象方法，被具體的animal類實現(xiàn)
}
class Chicken extends Animal implements Edible{
	@Override
	public String howToEat() {
		return "Chicken: Fry it";
	}//實現(xiàn)了Edible接口。當一個類實現(xiàn)接口時，該類實現(xiàn)定義在接口中的所有方法。
	@Override
	public String sound() {
		return "Chicken: cock-a-doodle-doo";
	}
}
class Tiger extends Animal{
	@Override
	public String sound() {
		return "Tiger:RROOAARR";
	}
}
abstract class Fruit implements Edible{
}//Fruit類實現(xiàn)了Edible，但沒有實現(xiàn)howToEat方法，所以它必須定義為abstract。
class Apple extends Fruit{
		@Override
		public String howToEat() {
			return "Apple:Make apple cider";
	}
}//Fruit的具體子類必須實現(xiàn)howToEat方法，所以Apple類實現(xiàn)了howToEat方法。

需要注意的是，接口中所有的數(shù)據(jù)域都是public static final，而且所有方法都是public abstract，但Java允許忽略這些修飾符。

即下面的兩個代碼是等價的：

public interface T {
	public static final int K=1;
	public abstract void p();
}

public interface T {
	int K=1;
	void p();
}

盡管public修飾符對于定義在接口中的方法可以省略，但是在子類實現(xiàn)中方法必須定義為public。

三、抽象類和接口的異同點

一個類可以實現(xiàn)多個接口，但是只能繼承一個父類。

首先我們先來列舉個表格簡單講述一下抽象類和接口之間的異同點：

比較點	抽象類	接口
關(guān)鍵字	abstract class	interface
字段	無限制	變量必須是public static final
方法	既可以含普通方法，又可以含抽象方法，無限制	只能含抽象方法，且必須是public的
繼承/實現(xiàn)	只能被類或抽象類繼承	既可以被接口繼承，也能被類或抽象類實現(xiàn)
多重繼承	不支持	可以繼承多個父接口

java只允許為類的繼承做單一繼承，但是允許使用接口做多重繼承。例如：

public class NewClass extends BaseClass implements Interface1,...,InterfaceN{
}

利用extends，接口可以繼承其他接口，這樣的接口被稱為子接口。例如：下面的代碼中，NewInterface是Interface1,...,InterfaceN的子接口。

public interface NewInterface extends Interface1,...,InterfaceN{
}

一個實現(xiàn)NewInterface的類必須實現(xiàn)在NewInterface，Interface1,...,InterfaceN中定義的抽象方法。接口可以繼承其他接口但不能繼承類。一個類可以繼承它的父類同時實現(xiàn)多個接口。

所有的類都有一個共同的根類Object，但是接口并沒有共同的根。與類相似，接口同樣也可以定義一種類型。一個接口類型的變量可以引用任何實現(xiàn)該接口的類的實例。如果一個類實現(xiàn)了一個接口，那么這個接口就類似于該類的一個父類?？梢詫⒔涌诋斪饕环N數(shù)據(jù)類型使用，將接口類型的變量轉(zhuǎn)換為它的子類，反過來同樣可以。

通常情況下，使用接口的頻率更高，因為接口比類更加靈活，不用使所有東西都屬于同一個類型的類。

下面進行一個簡單的代碼舉例：

abstract class Animal{
    public  abstract String howToEat();
}//在Animal中定義howToEat方法
//Animal的兩個子類定義如下
class Chicken extends Animal{
	@Override
	public String howToEat() {
		return "Chicken: Fry it";
    }
}
class Duck extends Animal{
	@Override
	public String howToEat() {
		return "Roast it";
    }
}
public static void main(String[] args) {
    Animal animal = new Chicken();
    eat(animal);
 
    Animal animal = new Duck();
    eat(animal);
}
public static void eat(Animal animal){
    System.out.println(animal.howToEat());
}

假設給定這個繼承結(jié)構(gòu)，java在調(diào)用方法時可以根據(jù)對象動態(tài)地決定調(diào)用具體的howToEat方法。但有一個限制條件，即該子類必須是另一種動物才可以。如果一種動物不可食用，那么此刻再繼承Animal類就并不合適了。

限制條件這個問題在接口中可以被解決，例如：

public class Demo{
public static void main(String[] args) {
    Edible stuff = new Chicken();
    eat(stuff);
 
    Edible stuff = new Broccoli();
    eat(stuff);
  }
public static void eat(Edible stuff){
    System.out.println(stuff.howToEat());
  }
}
interface Edible{
    public String howToEat();
}
class Chicken implements Edible{
	@Override
	public String howToEat() {
		return "Chicken: Fry it";
	}
}
class Broccoli implements Edible{
	@Override
	public String howToEat() {
		return "Broccoli: Stir-fty it";
	}
}

定義表示可食用對象的一個類，只須讓該類實現(xiàn)Edible接口即可。任何Edible對象都可以被傳遞以調(diào)用HowToEat方法。