Day08-Java

文章目錄

Day08-Java
- - 1、多型性
  - - - 1.1 向上轉型
      - 1.2 向下轉型
  - 2、抽象類
  - - - 2.1 抽象類的基本概念
  - 3、介面
  - - - 3.1 介面的基本概念
      - 3.2 介面的使用限制
      - 3.3 使用介面定義標準
      - 3.4 抽象類與介面的區別

1、多型性

多型性是面向物件的最后一個特征，它本身主要分為兩個方面：

? 方法的多型性：多載與覆寫

? 1 多載：同一個方法名稱，根據引數型別以及個數完成不同功能；

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

? 物件的多型性：父子類物件的轉換，

? 1 向上轉型：子類物件變為父類物件，父類父類物件 = 子類子類物件自動；

? 2 向上轉型：父類物件變為子類物件，格式：子類子類物件 = （子類）父類實體，強制；

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

這種操作主要觀察兩點：

? 1 看實體化的是哪一類（new）；

2 看new的這個類之中是否被覆寫了父類呼叫的方法，

1.1 向上轉型

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

1.2 向下轉型

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

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

以上的程式在編譯的時候沒有發生任何錯誤資訊，但是在執行的時候出現了“ClassCastException”錯誤提示，表示的是類轉換例外，即：兩個沒有關系的類互相發生了物件的強制轉型，

轉型的因素：

? 1 在實際作業之中，物件的向上轉型為主要使用，向上轉型之后，多有方法以父類的方法為主，但是具體的實作，還是要看子類是否覆寫了此方法；，

? 2 向下轉型，因為在進行向下轉型操作之前，一定要首先發生向上轉型，以建立兩個物件之間的聯系，如果沒有這種聯系，是不可能發生向下轉型的，一旦發生了運行中就會出現“ClassCastException”當需要呼叫子類自己特殊定義方法的時候，菜需要向下轉型，

? 3 不轉型，在一些資源較少的時候，如：移動開發，

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();    //向上轉型
		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
*/

為了日后的操作方便，在撰寫代碼的時候，盡量不要去執行向下的轉型操作，子類盡量不要去擴充新的方法名稱（父類沒有的方法名稱），依據父類定義的操作完善方法，

例題：利用物件向上轉型完成

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

這樣以來就得到了型別的統一，就算有再多的子類出現，方法或者是類也不需要進行修改了，但是在這塊必須強調的是：子類操作的程序之中，盡量向父類靠攏，

以后所有的代碼之中，都會存在物件的轉型問題，并且向上轉型居多，

在日后的所有開發之中，像之前程式那樣，一個類去繼承另外一個已經實作好的類的情況，是不可能出現的，即：一個類不能去繼承一個已經實作好的類，只能繼承抽象類或實作介面，

2、抽象類

在以后你進行的專案開發中，絕對不要出現一個類繼承一個已經實作好的類，

物件多型性的核心本質在于方法的覆寫，這樣的操作有些不合要求，所以要對子類的方法進行強制的要求就必須采用我們的抽象類進行實作，

2.1 抽象類的基本概念

普通類就是一個完善的功能類，可以直接產生物件并且可以使用，里面的方法都是帶有方法體的，而抽象類之中最大的特點是包含了抽象方法，而抽象方法是只宣告而未實作（沒有方法體）的方法，而抽象方法定義的時候要使用abstract關鍵字完成，而抽象方法一定要在抽象類之中，抽象類要使用是用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是抽象的; 無法實體化
                A a =new A();
                     ^
		1 個錯誤

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

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

抽象方法為什么不能實體化物件？

抽象類中包含抽象方法，而抽象方法與普通方法最大的區別就是沒有方法體，不知道具體的實作，而如果產生了實體化就意味著以可以呼叫類中的所有操作，

抽象類的使用原則：

所有抽象類必須要含有子類
抽象類的子類必須覆寫抽象中的全部抽象方法——方法覆寫一定要考慮到權限問題，抽象方法可以使用任意權限，要求權限盡量public
抽象物件可以通過物件多型性，利用子類為其實作實體化

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

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

關于抽象類的若干中疑問？

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

不能，因為final定義的類不能有子類，而抽象類必須有子類，

2、抽象類之中能否包含構造方法？

可以，因為抽象類之中除了包含抽象方法之外，還包含了普通方法和屬性，而屬性一定要在構造方法執行完畢之后才可以進行初始化操作；

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

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

4、抽象類能否使用static宣告？

如過定義的是外部抽象類，則不能夠使用static宣告，可是如果定義的是內部類，那么這個內部的抽象類使用了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();//向上轉型
		a.print();
	}
}

結論：如果構造方法沒有執行，類中物件中屬性一定都是其對應資料型別的默認值，

抽象類的最大特點在于強制規定了子類的實作結構，

3、介面

抽象類和普通類最大的特點就是約定了子類的實作要求：但是抽象類有一個缺點——單繼承局限，如果要想要求以及避免單繼承局限，就需要使用介面，在以后的開發中，介面優先，在一個操作中既可以使用抽象類又可以使用我們的介面，優先考慮介面，

3.1 介面的基本概念

介面就是一個抽象方法和全域常量的集合，屬于一種特殊的類，如果一個類定義的時候全部由抽象方法和全域常量所組成的話，那么這種類就稱為介面，但是介面是使用interface關鍵字定義的，

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

那么在介面之中，也同樣存在了抽象方法，很明顯，介面物件無法進行物件的實體化操作，那么介面的使用原則如下：

1、每一個介面必須定義子類，子類使用implement關鍵字實作介面；

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

3、利用介面的子類，采用物件的向上轉型方式，進行介面物件的實體化操作，

在Java之中每一個抽象類都可以實作多個介面,但是反過來講,一個介面卻不能繼承抽象類,可是Java之中,一個介面卻可以同時繼承多個介面，以實作介面的多繼承操作，

//因為介面和類的定義命名要求相同，所以為了區分介面和類
//建議在所以的介面前面追加一個字母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中get方法：" + 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中get方法：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)
轉換例外
		*/
		INews mn = new NewsImpl();
		IMessage m1 = (IMessage) mn;
		System.out.println(mn.get());
	}
}

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

3.2 介面的使用限制

完整定義：

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

簡化定義：

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

介面之中所有訪問權限只有一種:public,即:定義介面方法的時候就算沒寫上public,最終也是public.

在以后的撰寫介面的時候，大部分的介面里面只會提供抽象方法，很少在介面里面看見許多的全域常量，很多時候防止避免開發者出現混亂，所以介面的方法都會加上public，
當一個子類需要實作介面又需要繼承抽象類的時候，請先使用extends繼承一個抽象類，再使用implements實作多個介面，

//因為介面和類的定義命名要求相同，所以為了區分介面和類
//建議在所以的介面前面追加一個字母I
interface INews{
	public String get();//抽象方法
}
//可以再類上進行明確描述，在以后的開發之中也經常出現以下的命名習慣
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實作多個介面，但是介面不能夠去繼承抽象類；

//因為介面和類的定義命名要求相同，所以為了區分介面和類
//建議在所以的介面前面追加一個字母I
interface INews{
	public String get();//抽象方法
}
//可以再類上進行明確描述，在以后的開發之中也經常出現以下的命名習慣
abstract class AbstractMessage implements INews{
//只有介面中的abstract中才可以省略，抽象類中的不能省略
	public abstract void print();
}
class NewsImpl extends AbstractMessage{
	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();
	}
}

實際上此時關系屬于三層繼承，

介面與抽象類

//因為介面和類的定義命名要求相同，所以為了區分介面和類
//建議在所以的介面前面追加一個字母I
interface INews{
	public String get();//抽象方法
	public void pirnt();  
}
//假設一個介面可能有無數個子類，但是對于一個方法的實作是一樣的
abstract class AbstractMessage implements INews{

	public  void print(){
		System.out.println("www.baidu.com");
	}
}
//生怕別人不知道NewsImpl是INews介面的子類，做一個重復標記而已
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();
	}
}

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.介面可以定義一系列的內部介面，包括：內部普通類、內部抽象類、內部介面，其中使用static定義的內部介面就相當于是一個外部介面

而在開發之中,內部類是永遠不會受到概念限制的,在一個類中可以定義內部類,在一個抽象類之中也可以抽象內部類,在一個介面里面也可以定義內部抽象類或內部介面.但是從實際的開發來講用戶去定義內部抽象類或內部介面的時候是比較少見的(android開發中見過)，而且在定義內部介面的時候如果使用了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 使用介面定義標準

以上對于介面的概念并不是很難理解，但是需要強調的是，在實際開發之中，介面有三大主要功能：

制定操作標準；
表示一種能力；
將服務器端的遠程方法試圖暴露給客戶端，

定義USB介面：

interface USB{
	public void install();	//進行安裝
	public void work();	//進行作業
}

定義USB的子類：

class Computer{
	public void plugin(USB usb){
		usb.install();
		usb.work();
	}
}
class Flash implements USB{
	public void install(){
		System.out.println("安裝U盤驅動");
	}
	public void work(){
		System.out.println("U盤進行作業");
	}
}
class Printer implements USB{
	public void install(){
		System.out.println("安裝列印機驅動");
	}
	public void work(){
		System.out.println("列印機進行作業");
	}
}

源代碼：

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

發現使用介面和物件多型性結合，對于引數的統一更加明確，而且可以發現介面時再類之上的設計，

3.4 抽象類與介面的區別

區別	抽象類	介面
定義關鍵字	使用abstract class進行宣告	使用interface進行宣告
組成	全域常量、全域變數、構造方法、抽象方法、普通方法	全域變數、抽象方法
權限	可以使用任何權限	只能使用public權限
關系	一個抽象類可以實作多個介面	介面不能繼承抽象類，卻可以繼承多個介面
使用	子類使用extends	子類使用implements
設計模式	模板設計模式	工廠模式、代理模式
局限	一個子類只能繼承一個抽象方法	一個子類可以實作多個介面