java中抽象類和接口的相同和不同點是什么

這篇文章將為大家詳細講解有關java中抽象類和接口的相同和不同點是什么，文章內容質量較高，因此小編分享給大家做個參考，希望大家閱讀完這篇文章后對相關知識有一定的了解。

前言

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

一、抽象類是什么？

在 Java 語言中使用 abstract class 來定義抽象類。抽象類是不能被實例化的，即不能用new關鍵字來實例化對象。包含抽象方法的一定是抽象類，但抽象類不一定包含抽象方法。如果一個子類實現了父類（抽象類）的所有抽象方法，那么該子類可以不必是抽象類，否則就是抽象類。抽象類中的抽象方法的修飾符只能為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();
	}//構建默認的幾何對象
	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()方法，但這些方法并不能在父類中定義，因為具體的計算方法要取決于幾何對象的具體類型。所以采取抽象方法進行定義，這樣可以保證父類中的抽象方法可以在子類中被重寫。

抽象類只有定義沒有實現。

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

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

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

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

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

5.不能使用new操作符從一個抽象類創建一個實例，但是抽象類可以用做一種數據類型。

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

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

二、接口是什么？

接口是一種與類很相似的結構，用于為對象定義共同操作，但它的目的是指明相關或者不相關類的對象的共同行為。

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

類和接口之間的關系稱為接口繼承。

下面是簡單的代碼舉例：

package example;
 
public class TestEdible {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Object[] objects= {new Tiger(),new Chicken(),new Apple()};
		//創建由Tiger，Chicken和Apple類型的三個對象構成的數組
		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());
		}
		}//如果可食用，則調用howToEat方法，如果是動物，則調用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類實現
}
class Chicken extends Animal implements Edible{
	@Override
	public String howToEat() {
		return "Chicken: Fry it";
	}//實現了Edible接口。當一個類實現接口時，該類實現定義在接口中的所有方法。
	@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類實現了Edible，但沒有實現howToEat方法，所以它必須定義為abstract。
class Apple extends Fruit{
		@Override
		public String howToEat() {
			return "Apple:Make apple cider";
	}
}//Fruit的具體子類必須實現howToEat方法，所以Apple類實現了howToEat方法。

需要注意的是，接口中所有的數據域都是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修飾符對于定義在接口中的方法可以省略，但是在子類實現中方法必須定義為public。

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

一個類可以實現多個接口，但是只能繼承一個父類。

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

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

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

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

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

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

所有的類都有一個共同的根類Object，但是接口并沒有共同的根。與類相似，接口同樣也可以定義一種類型。一個接口類型的變量可以引用任何實現該接口的類的實例。如果一個類實現了一個接口，那么這個接口就類似于該類的一個父類。可以將接口當作一種數據類型使用，將接口類型的變量轉換為它的子類，反過來同樣可以。

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

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

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

假設給定這個繼承結構，java在調用方法時可以根據對象動態地決定調用具體的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";
	}
}

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

關于java中抽象類和接口的相同和不同點是什么就分享到這里了，希望以上內容可以對大家有一定的幫助，可以學到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。