Java多態(tài)性抽象類與接口的具體用法

本篇內(nèi)容主要講解“Java多態(tài)性抽象類與接口的具體用法”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實(shí)用性強(qiáng)。下面就讓小編來帶大家學(xué)習(xí)“Java多態(tài)性抽象類與接口的具體用法”吧!

目錄

• 1、多態(tài)性

• 1.1 向上轉(zhuǎn)型

• 1.2 向下轉(zhuǎn)型

• 2、抽象類

• 2.1 抽象類的基本概念

• 3、接口

• 3.1 接口的基本概念

• 3.2 接口的使用限制

• 3.3 使用接口定義標(biāo)準(zhǔn)

• 3.4 抽象類與接口的區(qū)別

1、多態(tài)性

多態(tài)性是面向?qū)ο蟮淖詈笠粋€特征，它本身主要分為兩個方面：

方法的多態(tài)性：重載與覆寫

1 重載：同一個方法名稱，根據(jù)參數(shù)類型以及個數(shù)完成不同功能；

2 覆寫：通一個方法，根據(jù)操作的子類不同，所完成的功能也不同。

對象的多態(tài)性：父子類對象的轉(zhuǎn)換。

1 向上轉(zhuǎn)型：子類對象變?yōu)楦割悓ο?，父?父類對象 = 子類 子類對象 自動；

2 向上轉(zhuǎn)型：父類對象變?yōu)樽宇悓ο?，格式：子?子類對象 = （子類）父類實(shí)例，強(qiáng)制；

class A{
	public void print(){
		System.out.println("A輸出");
	}
}
class B extends A{
	public void print(){
		System.out.println("B輸出");
	}
}
public class TestDemo1{
	public static void main(String args[]){
		B b = new B();
		//B輸出
		b.print();
	}
}

這種操作主要觀察兩點(diǎn)：

1 看實(shí)例化的是哪一類（new）；

2 看new的這個類之中是否被覆寫了父類調(diào)用的方法。

1.1 向上轉(zhuǎn)型

public class TestDemo1{
	public static void main(String args[]){
		A a = new B();  //向上轉(zhuǎn)型
        //B輸出
		a.print();
	}
}

1.2 向下轉(zhuǎn)型

public class TestDemo1{
	public static void main(String args[]){
		A a = new B();  //向上轉(zhuǎn)型
        B b = (B) a;    //向下轉(zhuǎn)型
		b.print();
	}
}

public class TestDemo1{
	public static void main(String args[]){
		A a = new A();  //沒有轉(zhuǎn)型
        B b = (B) a;     //向下轉(zhuǎn)型
		b.print();
	}
}
/*
Exception in thread "main" java.lang.ClassCastException: A cannot be cast to B
        at DuoTaiXing.main(TestDemo1.java:14)
*/

以上的程序在編譯的時候沒有發(fā)生任何錯誤信息，但是在執(zhí)行的時候出現(xiàn)了“ClassCastException”錯誤提示，表示的是類轉(zhuǎn)換異常，即：兩個沒有關(guān)系的類互相發(fā)生了對象的強(qiáng)制轉(zhuǎn)型。

轉(zhuǎn)型的因素：

1 在實(shí)際工作之中，對象的向上轉(zhuǎn)型為主要使用，向上轉(zhuǎn)型之后，多有方法以父類的方法為主，但是具體的實(shí)現(xiàn)，還是要看子類是否覆寫了此方法；。

2 向下轉(zhuǎn)型，因?yàn)樵谶M(jìn)行向下轉(zhuǎn)型操作之前，一定要首先發(fā)生向上轉(zhuǎn)型，以建立兩個對象之間的聯(lián)系，如果沒有這種聯(lián)系，是不可能發(fā)生向下轉(zhuǎn)型的，一旦發(fā)生了運(yùn)行中就會出現(xiàn)“ClassCastException”當(dāng)需要調(diào)用子類自己特殊定義方法的時候，菜需要向下轉(zhuǎn)型。

3 不轉(zhuǎn)型，在一些資源較少的時候，如：移動開發(fā)。

class A{
	public void print(){
		System.out.println("A輸出");
	}
}
class B extends A{
	public void print(){
		System.out.println("B輸出");
	}
	public void funB(){
		System.out.println("funB");
	}
}
public class TestDemo1{
	public static void main(String args[]){
		A a = new B();    //向上轉(zhuǎn)型
		System.out.println(a instanceof A);
		System.out.println(a instanceof B);
		if (a instanceof B){
			B b = (B) a;
			b.funB();
		}
	}
}
/*
true
true
funB
*/

為了日后的操作方便，在編寫代碼的時候，盡量不要去執(zhí)行向下的轉(zhuǎn)型操作，子類盡量不要去擴(kuò)充新的方法名稱（父類沒有的方法名稱），依據(jù)父類定義的操作完善方法。

例題：利用對象向上轉(zhuǎn)型完成

class A{
	public void print(){
		System.out.println("A輸出");
	}
}
class B extends A{
	public void print(){
		System.out.println("B輸出");
	}
}
class C extends A{
	public void print(){
		System.out.println("C輸出");
	}
}
public class TestDemo2{
	public static void main(String args[]){
		fun(new B());
		fun(new C());
	}
	public static void fun(A a){
		a.print();
	}
}

這樣以來就得到了類型的統(tǒng)一，就算有再多的子類出現(xiàn)，方法或者是類也不需要進(jìn)行修改了，但是在這塊必須強(qiáng)調(diào)的是：子類操作的過程之中，盡量向父類靠攏。

以后所有的代碼之中，都會存在對象的轉(zhuǎn)型問題，并且向上轉(zhuǎn)型居多。

在日后的所有開發(fā)之中，像之前程序那樣，一個類去繼承另外一個已經(jīng)實(shí)現(xiàn)好的類的情況，是不可能出現(xiàn)的。即：一個類不能去繼承一個已經(jīng)實(shí)現(xiàn)好的類，只能繼承抽象類或?qū)崿F(xiàn)接口。

2、抽象類

在以后你進(jìn)行的項(xiàng)目開發(fā)中，絕對不要出現(xiàn)一個類繼承一個已經(jīng)實(shí)現(xiàn)好的類。

對象多態(tài)性的核心本質(zhì)在于方法的覆寫，這樣的操作有些不合要求，所以要對子類的方法進(jìn)行強(qiáng)制的要求就必須采用我們的抽象類進(jìn)行實(shí)現(xiàn)。

2.1 抽象類的基本概念

普通類就是一個完善的功能類，可以直接產(chǎn)生對象并且可以使用，里面的方法都是帶有方法體的，而抽象類之中最大的特點(diǎn)是包含了抽象方法，而抽象方法是只聲明而未實(shí)現(xiàn)（沒有方法體）的方法，而抽象方法定義的時候要使用abstract關(guān)鍵字完成，而抽象方法一定要在抽象類之中，抽象類要使用是用abstract聲明。

abstract class A{
	private String msg = "www.baidu.com";//屬性
	public void print(){	//普通方法
		System.out.println(msg);
	}
	//{}為方法體，所有的抽象方法上是不包含有方法體的
	public abstract void fun() ; //抽象方法
}

public class ChouXiang{
	public static void main(String args[]){
	/*
	ChouXiang.java:12: 錯誤: A是抽象的; 無法實(shí)例化
                A a =new A();
                     ^
		1 個錯誤

	*/
		A a =new A();
	}
}

抽象類比普通類多了抽象方法而已，沒有上面特殊的。

抽象方法為什么不能實(shí)例化對象？

抽象類中包含抽象方法，而抽象方法與普通方法最大的區(qū)別就是沒有方法體，不知道具體的實(shí)現(xiàn)，而如果產(chǎn)生了實(shí)例化就意味著以可以調(diào)用類中的所有操作。

抽象類的使用原則：

• 所有抽象類必須要含有子類

• 抽象類的子類必須覆寫抽象中的全部抽象方法——方法覆寫一定要考慮到權(quán)限問題，抽象方法可以使用任意權(quán)限，要求權(quán)限盡量public

• 抽象對象可以通過對象多態(tài)性，利用子類為其實(shí)現(xiàn)實(shí)例化

abstract class A{
	private String msg = "www.baidu.com";//屬性
	public void print(){	//普通方法
		System.out.println(msg);
	}
	//{}為方法體，所有的抽象方法上是不包含有方法體的
	public abstract void fun() ; //抽象方法
}
//一個子類只能夠利用extends來繼續(xù)繼承抽象類，所以依然存在單繼承局限 
class B extends A{//定義抽象類的子類
	public void fun(){
		System.out.println("Hello");
	}
}
public class ChouXiang{
	public static void main(String args[]){
		A a =new B();//向上轉(zhuǎn)型
		a.print();
		a.fun();
	}
}

通過以上的一個程序，現(xiàn)在就可以清楚的發(fā)現(xiàn)，與之前類不一樣的是，抽象類定義出了子類必須要覆寫的方法，而之前的類子類可以有選擇性的來決定是否覆寫。而且可以發(fā)現(xiàn)，抽象類實(shí)際上就比普通類多了一些抽象方法而已，其他的定義和普通類完全一樣。如果把普通類比喻成一盤炒熟的菜，那么抽象類就是一盤半成品。

關(guān)于抽象類的若干中疑問？

1、抽象類能否使用final定義？

不能，因?yàn)閒inal定義的類不能有子類，而抽象類必須有子類。

2、抽象類之中能否包含構(gòu)造方法？

可以，因?yàn)槌橄箢愔谐税橄蠓椒ㄖ?，還包含了普通方法和屬性，而屬性一定要在構(gòu)造方法執(zhí)行完畢之后才可以進(jìn)行初始化操作；

3、抽象類之中能否不包含抽象方法？

可以，抽象類之中可以沒有抽象方法，但是反過來來講，如果有抽象，則一定是抽象類。即使抽象類之中沒有抽象方法也不能被直接實(shí)例化。

4、抽象類能否使用static聲明？

如過定義的是外部抽象類，則不能夠使用static聲明，可是如果定義的是內(nèi)部類，那么這個內(nèi)部的抽象類使用了static聲明之后，就表示一個外部的抽象類。

abstract class A{
	private String str = "Hello,China";
	static abstract class B{
		public abstract void print();
	}	
}
class C extends A.B{
	public void print(){
		System.out.println("你好,中國");
	}
}
public class ChouXiang{
	public static void main(String args[]){
		A a =new B();//向上轉(zhuǎn)型
		a.print();
	}
}

結(jié)論：如果構(gòu)造方法沒有執(zhí)行，類中對象中屬性一定都是其對應(yīng)數(shù)據(jù)類型的默認(rèn)值。

抽象類的最大特點(diǎn)在于強(qiáng)制規(guī)定了子類的實(shí)現(xiàn)結(jié)構(gòu)。

3、接口

抽象類和普通類最大的特點(diǎn)就是約定了子類的實(shí)現(xiàn)要求：但是抽象類有一個缺點(diǎn)——單繼承局限，如果要想要求以及避免單繼承局限，就需要使用接口。在以后的開發(fā)中，接口優(yōu)先，在一個操作中既可以使用抽象類又可以使用我們的接口，優(yōu)先考慮接口。

3.1 接口的基本概念

接口就是一個抽象方法和全局常量的集合，屬于一種特殊的類，如果一個類定義的時候全部由抽象方法和全局常量所組成的話，那么這種類就稱為接口，但是接口是使用interface關(guān)鍵字定義的。

interface A{//定義接口
	public static final String INFO="Hello,World";
	public abstract void print();
}
interface B{
	public abstract void get();
}

那么在接口之中，也同樣存在了抽象方法，很明顯，接口對象無法進(jìn)行對象的實(shí)例化操作，那么接口的使用原則如下：

1、每一個接口必須定義子類，子類使用implement關(guān)鍵字實(shí)現(xiàn)接口；

2、接口的子類（如果不是抽象類）則必須覆寫接口之中所定義的全部抽象方法；

3、利用接口的子類，采用對象的向上轉(zhuǎn)型方式，進(jìn)行接口對象的實(shí)例化操作。

在Java之中每一個抽象類都可以實(shí)現(xiàn)多個接口,但是反過來講,一個接口卻不能繼承抽象類,可是Java之中,一個接口卻可以同時繼承多個接口，以實(shí)現(xiàn)接口的多繼承操作。

//因?yàn)榻涌诤皖惖亩x命名要求相同，所以為了區(qū)分接口和類
//建議在所以的接口前面追加一個字母I
interface IMessage{
	public static final String MSG = "www.baidu.com";
	public abstract void print();//抽象方法
}
interface INews{
	public abstract String get();
}
class MessageImpl implements IMessage,INews{
	public void print(){
		System.out.println("IMessage中print方法：" +IMessage.MSG);
	}
	public String get(){
		return "INews中g(shù)et方法：" + IMessage.MSG;
	}
}
class NewsImpl implements INews{
	public String get(){
		return null;
	}
}
public class InFa{
	public static void main(String args[]){
		IMessage ms = new MessageImpl();
		//InFa
		ms.print();
		INews m = new MessageImpl();
		//INews中g(shù)et方法：www.baidu.com
		System.out.println(m.get());
		
		/*
Exception in thread "main" java.lang.ClassCastException: NewsImpl cannot be cast to IMessage
at InFa.main(InFa.java:33)
轉(zhuǎn)換異常
		*/
		INews mn = new NewsImpl();
		IMessage m1 = (IMessage) mn;
		System.out.println(mn.get());
	}
}

但是需要說明的是:接口之中的全部組成就是抽象方法和全局常量,那么在開發(fā)之中一下的兩種定義接口的最終效果是完全一樣的:

3.2 接口的使用限制

完整定義：

interface A{ 
	public static final String INFO="接口A";
	public abstract void print();
}

簡化定義：

interface A{//定義接口
	 public String INFO="接口A";
	 public void print();
}

接口之中所有訪問權(quán)限只有一種:public,即:定義接口方法的時候就算沒寫上public,最終也是public.

1. 在以后的編寫接口的時候，大部分的接口里面只會提供抽象方法，很少在接口里面看見許多的全局常量。很多時候防止避免開發(fā)者出現(xiàn)混亂，所以接口的方法都會加上public。

2. 當(dāng)一個子類需要實(shí)現(xiàn)接口又需要繼承抽象類的時候，請先使用extends繼承一個抽象類，再使用implements實(shí)現(xiàn)多個接口。

//因?yàn)榻涌诤皖惖亩x命名要求相同，所以為了區(qū)分接口和類
//建議在所以的接口前面追加一個字母I
interface INews{
	public String get();//抽象方法
}
//可以再類上進(jìn)行明確描述，在以后的開發(fā)之中也經(jīng)常出現(xiàn)以下的命名習(xí)慣
abstract class AbstractMessage{
//只有接口中的abstract中才可以省略，抽象類中的不能省略
	public abstract void print();
}
class NewsImpl extends AbstractMessage implements INews{
	public String get(){
		return "www.baidu.com";
	}
	public void print(){}	//有方法體就叫覆寫
}
public class InFa1{
	public static void main(String args[]){
		INews news = new NewsImpl();
		System.out.println(news.get());
		//NewsImpl是抽象類和接口的共同子類
		AbstractMessage am = (AbstractMessage) news;
		am.print();
	}
}

3.一個抽象類可以使用implements實(shí)現(xiàn)多個接口，但是接口不能夠去繼承抽象類；

//因?yàn)榻涌诤皖惖亩x命名要求相同，所以為了區(qū)分接口和類
//建議在所以的接口前面追加一個字母I
interface INews{
	public String get();//抽象方法
}
//可以再類上進(jìn)行明確描述，在以后的開發(fā)之中也經(jīng)常出現(xiàn)以下的命名習(xí)慣
abstract class AbstractMessage implements INews{
//只有接口中的abstract中才可以省略，抽象類中的不能省略
	public abstract void print();
}
class NewsImpl extends AbstractMessage{
	public String get(){
		return "www.baidu.com";
	}
	public void print(){}	//有方法體就叫覆寫
}
/*
該類的調(diào)用相當(dāng)于孫子實(shí)例化爺爺對象 將 爺爺對象轉(zhuǎn)換為兒子對象
*/
public class InFa1{
	public static void main(String args[]){
		INews news = new NewsImpl();
		System.out.println(news.get());
		//NewsImpl是抽象類和接口的共同子類
		AbstractMessage am = (AbstractMessage) news;
		am.print();
	}
}

實(shí)際上此時關(guān)系屬于三層繼承。

接口與抽象類

//因?yàn)榻涌诤皖惖亩x命名要求相同，所以為了區(qū)分接口和類
//建議在所以的接口前面追加一個字母I
interface INews{
	public String get();//抽象方法
	public void pirnt();  
}
//假設(shè)一個接口可能有無數(shù)個子類，但是對于一個方法的實(shí)現(xiàn)是一樣的
abstract class AbstractMessage implements INews{

	public  void print(){
		System.out.println("www.baidu.com");
	}
}
//生怕別人不知道NewsImpl是INews接口的子類，做一個重復(fù)標(biāo)記而已
class NewsImpl extends AbstractMessage implements INews{
	public String get(){
		return "www.baidu.com";
	}
	public void print(){}	//有方法體就叫覆寫
}
/*
該類的調(diào)用相當(dāng)于孫子實(shí)例化爺爺對象 將 爺爺對象轉(zhuǎn)換為兒子對象
*/
public class InFa1{
	public static void main(String args[]){
		INews news = new NewsImpl();
		System.out.println(news.get());
		//NewsImpl是抽象類和接口的共同子類
		AbstractMessage am = (AbstractMessage) news;
		am.print();
	}
}

4.一個接口可以使用extends來繼承多個父接口。

interface A{
	public void pirntA();  
}
interface B{
	public void pirntB();  
}
interface C extends A,B{
	public void pirntC();
}
class Impl implements C{
	public void pirntA();  
	public void pirntB();  
	public void pirntC();  
}

public class InFa1{
	public static void main(String args[]){
	}
}

5.接口可以定義一系列的內(nèi)部接口，包括：內(nèi)部普通類、內(nèi)部抽象類、內(nèi)部接口，其中使用static定義的內(nèi)部接口就相當(dāng)于是一個外部接口

而在開發(fā)之中,內(nèi)部類是永遠(yuǎn)不會受到概念限制的,在一個類中可以定義內(nèi)部類,在一個抽象類之中也可以抽象內(nèi)部類,在一個接口里面也可以定義內(nèi)部抽象類或內(nèi)部接口.但是從實(shí)際的開發(fā)來講用戶去定義內(nèi)部抽象類或內(nèi)部接口的時候是比較少見的(android開發(fā)中見過)，而且在定義內(nèi)部接口的時候如果使用了static，表示一個外部接口。

interface A{
	public void printA();
static interface B{  //外部接口
		public void printB();
	}
}
class X implements A.B{
	public void printA(){
		System.out.println("A");
	}
	public void printB(){
		System.out.println("B");
	}
}
public class Inter{
	public static void main(String args[]){
		A.B ab = new X();
		ab.printB();
	}
}

3.3 使用接口定義標(biāo)準(zhǔn)

以上對于接口的概念并不是很難理解，但是需要強(qiáng)調(diào)的是，在實(shí)際開發(fā)之中，接口有三大主要功能：

• 制定操作標(biāo)準(zhǔn)；

• 表示一種能力；

• 將服務(wù)器端的遠(yuǎn)程方法試圖暴露給客戶端。

定義USB接口：

interface USB{
	public void install();	//進(jìn)行安裝
	public void work();	//進(jìn)行工作
}

定義USB的子類：

class Computer{
	public void plugin(USB usb){
		usb.install();
		usb.work();
	}
}
class Flash implements USB{
	public void install(){
		System.out.println("安裝U盤驅(qū)動");
	}
	public void work(){
		System.out.println("U盤進(jìn)行工作");
	}
}
class Printer implements USB{
	public void install(){
		System.out.println("安裝打印機(jī)驅(qū)動");
	}
	public void work(){
		System.out.println("打印機(jī)進(jìn)行工作");
	}
}

源代碼：

interface USB{
	public void install();	//進(jìn)行安裝
	public void work();	//進(jìn)行工作
}
class Computer{
	public void plugin(USB usb){
		usb.install();
		usb.work();
	}
}
class Flash implements USB{
	public void install(){
		System.out.println("安裝U盤驅(qū)動");
	}
	public void work(){
		System.out.println("U盤進(jìn)行工作");
	}
}
class Printer implements USB{
	public void install(){
		System.out.println("安裝打印機(jī)驅(qū)動");
	}
	public void work(){
		System.out.println("打印機(jī)進(jìn)行工作");
	}
}
public class InFa3{
	public static void main(String args[]){
	/*
安裝U盤驅(qū)動
U盤進(jìn)行工作
安裝打印機(jī)驅(qū)動
打印機(jī)進(jìn)行工作
	*/
		Computer cm = new Computer();
		cm.plugin(new Flash());
		cm.plugin(new Printer());
	}
}

發(fā)現(xiàn)使用接口和對象多態(tài)性結(jié)合，對于參數(shù)的統(tǒng)一更加明確。而且可以發(fā)現(xiàn)接口時再類之上的設(shè)計(jì)。

3.4 抽象類與接口的區(qū)別

通過上面的分析可以得出結(jié)論：在開發(fā)之中，抽象類和接口實(shí)際上都是可以使用的，并且使用哪一個都沒有明確的限制，可是抽象類有一個最大的缺點(diǎn)—一個子類只能夠繼承一個抽象類，存在單繼承的局限，所以當(dāng)遇到抽象類和接口都可以實(shí)現(xiàn)的情況下，優(yōu)先考慮接口，避免單繼承局限。

除了單繼承的局限之外，實(shí)際上使用抽象類和接口都是類似的，但是在實(shí)際的開發(fā)中，抽象類的設(shè)計(jì)比接口的復(fù)雜。

到此，相信大家對“Java多態(tài)性抽象類與接口的具體用法”有了更深的了解，不妨來實(shí)際操作一番吧！這里是億速云網(wǎng)站，更多相關(guān)內(nèi)容可以進(jìn)入相關(guān)頻道進(jìn)行查詢，關(guān)注我們，繼續(xù)學(xué)習(xí)！