懵逼樹上懵逼果，懵逼樹下你和我

第一題

?

[單選題]

A派生出子類B，B派生出子類C，并且在java源代碼中有如下聲明：

1 2 3

A a0=new A(); A a1=new B(); A a2=new C();

以哪個說法是正確的

A第1行，第2行和第3行的聲明都是正確的 B第1,2,3行都能通過編譯，但第2,3行運行時出錯 C第1,2行能通過編譯，但第3行編譯出錯 D只有第1行能通過編譯

首先看到這個題，本人的確是有點懵逼的，我想著這玩意是選c吧，第一行代碼肯定沒得問題

然后第二行不是一個上轉型對象，也是可以操作的。第三行也太秀了趴，中間跨了一個類直接再來哥上轉型，這玩意肯定是有問題的。果斷選c，然而很顯然，我錯了，當然看了一眼答案

然后我看看別人的解析

多說不說，打開了自己的idea

按照要求來

public class A { } public class B extends A { } public class C extends B { } public class D {public static void main(String[] args){A a1=new A();A a2=new B();A a3=new C();} }

事實證明，沒有報錯，又回去看看上轉型對象

向上轉型

　　我們在現實中常常這樣說：這個人會唱歌。在這里，我們并不關心這個人是黑人還是白人，是成人還是小孩，也就是說我們更傾向于使用抽象概念“人”。再例如，麻雀是鳥類的一種(鳥類的子類)，而鳥類則是動物中的一種(動物的子類)。我們現實中也經常這樣說：麻雀是鳥。這兩種說法實際上就是所謂的向上轉型，通俗地說就是子類轉型成父類。這也符合Java提倡的面向抽象編程思想。

public class A { public void a1() { System.out.println("Superclass"); } } public class B extends A { public void a1() { System.out.println("Childrenclass"); //覆蓋父類方法 } public void b1(){} //B類定義了自己的新方法 } public class C { public static void main(String[] args) { A a = new B(); //向上轉型 a.a1(); } }

如果運行C，輸出的是Superclass 還是Childrenclass?不是你原來預期的Superclass，而是Childrenclass。這是因為a實際上指向的是一個子類對象。當然，你不用擔心，Java虛擬機會自動準確地識別出究竟該調用哪個具體的方法。不過，由于向上轉型，a對象會遺失和父類不同的方法，例如b1()。有人可能會提出疑問：這不是多此一舉嗎?我們完全可以這樣寫：

B a = new B(); a.a1();

確實如此!但這樣就喪失了面向抽象的編程特色，降低了可擴展性。其實，不僅僅如此，向上轉型還可以減輕編程工作量。來看下面的顯示器類Monitor：

public class Monitor{ public void displayText() {} public void displayGraphics() {} }

液晶顯示器類LCDMonitor是Monitor的子類：

public class LCDMonitor extends Monitor { public void displayText() { System.out.println("LCD display text"); } public void displayGraphics() { System.out.println("LCD display graphics"); } }

陰極射線管顯示器類CRTMonitor自然也是Monitor的子類：

public class CRTMonitor extends Monitor { public void displayText() { System.out.println("CRT display text"); } public void displayGraphics() { System.out.println("CRT display graphics"); } }

等離子顯示器PlasmaMonitor也是Monitor的子類：

public class PlasmaMonitor extends Monitor { public void displayText() { System.out.println("Plasma display text"); } public void displayGraphics() { System.out.println("Plasma display graphics"); } }

現在有一個MyMonitor類。假設沒有向上轉型，MyMonitor類代碼如下：

public class MyMonitor { public static void main(String[] args) { run(new LCDMonitor()); run(new CRTMonitor()); run(new PlasmaMonitor()); } public static void run(LCDMonitor monitor) { monitor.displayText(); monitor.displayGraphics(); } public static void run(CRTMonitor monitor) { monitor.displayText(); monitor.displayGraphics(); } public static void run(PlasmaMonitor monitor) { monitor.displayText(); monitor.displayGraphics(); } }

可能你已經意識到上述代碼有很多重復代碼，而且也不易維護。有了向上轉型，代碼可以更為簡潔：

public class MyMonitor { public static void main(String[] args) { run(new LCDMonitor()); //向上轉型 run(new CRTMonitor()); //向上轉型 run(new PlasmaMonitor()); //向上轉型 } public static void run(Monitor monitor) { //父類實例作為參數 monitor.displayText(); monitor.displayGraphics(); } }

我們也可以采用接口的方式，例如：

public interface Monitor { abstract void displayText(); abstract void displayGraphics(); }

將液晶顯示器類LCDMonitor稍作修改：

public class LCDMonitor implements Monitor { public void displayText() { System.out.println("LCD display text"); } public void displayGraphics() { System.out.println("LCD display graphics"); } }

CRTMonitor、PlasmaMonitor類的修改方法與LCDMonitor類似，而MyMonitor可以不不作任何修改。

　　可以看出，向上轉型體現了類的多態性，增強了程序的簡潔性。

向下轉型

　　子類轉型成父類是向上轉型，反過來說，父類轉型成子類就是向下轉型。但是，向下轉型可能會帶來一些問題：我們可以說麻雀是鳥，但不能說鳥就是麻雀。來看下面的例子：

public class A { void aMthod() { System.out.println("A method"); } }

A的子類B：

public class B extends A { void bMethod1() { System.out.println("B method 1"); } void bMethod2() { System.out.println("B method 2"); } }

C類：

public class C { public static void main(String[] args) { A a1 = new B(); // 向上轉型 a1.aMthod(); // 調用父類aMthod()，a1遺失B類方法bMethod1()、bMethod2() B b1 = (B) a1; // 向下轉型，編譯無錯誤，運行時無錯誤 b1.aMthod(); // 調用父類A方法 b1.bMethod1(); // 調用B類方法 b1.bMethod2(); // 調用B類方法 A a2 = new A(); B b2 = (B) a2; // 向下轉型，編譯無錯誤，運行時將出錯 b2.aMthod(); b2.bMethod1(); b2.bMethod2(); } }

從上面的代碼我們可以得出這樣一個結論：向下轉型需要使用強制轉換。運行C程序，控制臺將輸出：

Exception in thread "main" java.lang.ClassCastException: a.b.A cannot be cast to a.b.B at a.b.C.main(C.java:14) A method A method B method 1B method 2

其實黑體部分的向下轉型代碼后的注釋已經提示你將發生運行時錯誤。為什么前一句向下轉型代碼可以，而后一句代碼卻出錯?這是因為a1指向一個子類B的對象，所以子類B的實例對象b1當然也可以指向a1。而a2是一個父類對象，子類對象b2不能指向父類對象a2。那么如何避免在執行向下轉型時發生運行時ClassCastException異常?我們修改一下C類的代碼：

A a2 = new A(); if (a2 instanceof B) { B b2 = (B) a2; b2.aMthod(); b2.bMethod1(); b2.bMethod2(); }

這樣處理后，就不用擔心類型轉換時發生ClassCastException異常了。

所以答案為A

文章僅個人理解，來在各大網站。如有不合理之處，歡迎吐槽。

閱讀目錄（置頂)(長期更新計算機領域知識）https://blog.csdn.net/weixin_43392489/article/details/102380691

閱讀目錄（置頂)(長期更新計算機領域知識）https://blog.csdn.net/weixin_43392489/article/details/102380882

閱讀目錄（置頂)(長期科技領域知識）https://blog.csdn.net/weixin_43392489/article/details/102600114

歌謠帶你看java面試題 https://blog.csdn.net/weixin_43392489/article/details/102675944

總結

以上是生活随笔為你收集整理的java面试题1 牛客：A派生出子类B，B派生出子类C，并且在java源代码中有如下声明：的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。