java的向上轉型

⑴ java中關於向上轉型的問題

RTTI機制
向上轉型的目的仍然是抽象。
比如
水果有顏色、味道。不同的水果有不同的顏色和味道。那麼當
水果
sg
=
new
橘子();
水果
sg1
=
new
蘋果();
sg.color();sg.taste();
sg1.color();sg1.taste();
sg,sg1都是水果實例的引用。但會調用不同的具體子類的方法。
其目地都是抽象。通過訪問父類或介面的方法(公共)達到一種對具體實現的封裝。對於介面的使用者來說，不需要關心實現細節。提高內聚，降低不必要的耦合。
再多說一句：注意轉型時帶來的
內存切片。

⑵ java 向上轉型 向下轉型

1.
引用a的類型是animal，是cat的父類。所以是「父類引用指向子類對象」。如果是「子類引用指向父類對象」，那應該寫成
cat
a
=
new
animal();但這顯然是不和邏輯的。
2.
你說的沒錯——「向上轉型後，父類也只能調用父類已經有的方法」。但是子類如果覆蓋了父類的方法，那麼即使向上轉型，方法的行為也表現為覆蓋後的行為。這也是多態的一種體現。向上轉型更多的用來體現一種編程上的「約定」。所有繼承某個類或者實現某個介面的類，一定包含某個方法，這樣在調用的時候，使得你也不必關系具體的實現細節，只要知道「這個類型中的某個方法能幫我完成工作」就可以了。
3.
向下轉型，是「引用的類型」的變化，不是對象實例類型的變化。new什麼，就是什麼。不會因為向上或者向下轉型而改變自己的類型。
4.
最後一個問題，不管向上還是向下轉型，調用的都是實際類型中的那個方法。比如，animal
a
=
new
cat(); a.叫()。那這個叫就是cat類型實例中的「叫」方法。

⑶ 在java中，向上轉型的機制是怎樣工作的

向上轉型（upcasting）：對象可以作為它本身的類型使用也可以作為它父類（基類）對象使用，java中是單繼承的，所以是一種安全的做法。

當你初始化子類時，產生一個對象時，該對象將父類的對象作為子對象包含其中。向上轉型會丟失子類的方法。但可以將所有對象至於一個共同的容器中存儲與調用，實現了容器的復用，（collection 容器集默認將所有對象作為Object存儲的），但在具體使用是要確定對象原來的身份。

Java在運行中動態識別對象和類信息有兩種機制：

1、RTTI（run-time type identification）運行期類別識別（強制類型轉換「（）」，類型轉換是在運行期進行的），它假定我們在編譯和運行期已經知道了所有的類型。

Java是通過Class對象實現RTTI機制的

Java中為每個類創建一個Class對象（*.class），它包括了與類相關的信息，用來創建類的常規對象，在運行期，一旦我們想生成某個類的對象，運行這個程序的JVM首先檢查這個類的Class對象是否載入，如果尚未載入，JVM會根據類名查找.class文件，並將其載入，之後你就可以創建這個類的任何對象了。java程序不是一開始執行，所有類就被完全載入的。Class對象僅在需要時被載入，Static語句塊是在類被載入時執行。

生成Class對象的兩種引用方式：

Class.forName（「Gun」）

類字面常量： Gun.class

RTTI的限制：類在編譯期間必須已知，在編譯期間打開和檢查.class文件。

2、反射機制（reflection）它允許我們在運行期獲得類的信息。

反射機制在運行期打開和檢查.class文件。

⑷ 在java裡面的向上轉型和向下轉型的具體好處在哪裡

java裡面的向上轉型和向下轉型的具體好處如下：

1.轉型是在繼承的基礎上而言的，繼承是面向對象語言中，代碼復用的一種機制，通過繼承，子類可以復用父類的功能，如果父類不能滿足當前子類的需求，則子類可以重寫父類中的方法來加以擴展。

2.向上轉型：子類引用的對象轉換為父類類型稱為向上轉型。通俗地說就是是將子類對象轉為父類對象。此處父類對象可以是介面

向上轉型時，父類指向子類引用對象會遺失除與父類對象共有的其他方法，也就是在轉型過程中，子類的新有的方法都會遺失掉，在編譯時，系統會提供找不到方法的錯誤。實例如下：

publicclassAnimal{
publicvoideat(){
System.out.println("animaleatting...");
}
}
classBirdextendsAnimal{
publicvoideat(){
System.out.println("birdeatting...");
}
publicvoidfly(){
System.out.println("birdflying...");
}
}
classMain{
publicstaticvoidmain(String[]args){
Animalb=newBird();//向上轉型
b.eat();
b.fly();//此處提示在Animal中沒有定義fly方法。
｝

⑸ 在java 中，什麼叫向上轉型

java 轉型問題其實並不復雜，只要記住一句話：父類引用指向子類對象。

什麼叫父類引用指向子類對象，且聽我慢慢道來.

從2個名詞開始說起：向上轉型(upcasting) 、向下轉型(downcasting).

舉個例子：有2個類，Father是父類，Son類繼承自Father。

Father f1 = new Son(); // 這就叫 upcasting （向上轉型)

// 現在f1引用指向一個Son對象

Son s1 = (Son)f1; // 這就叫 downcasting (向下轉型)

// 現在f1還是指向Son對象

第2個例子：

Father f2 = new Father();

Son s2 = (Son)f2; // 出錯，子類引用不能指向父類對象

你或許會問，第1個例子中：Son s1 = (Son)f1;問什麼 是正確的呢。

很簡單因為f1指向一個子類對象，Father f1 = new Son(); 子類s1引用當然可以指向子類對象了。

而f2 被傳給了一個Father對象，Father f2 = new Father（）；子類s1引用不能指向父類對象。

總結：

1。父類引用指向子類對象，而子類引用不能指向父類對象。

2。把子類對象直接賦給父類引用叫upcasting向上轉型，向上轉型不用強制轉換。

如：Father f1 = new Son();

3。把指向子類對象的父類引用賦給子類引用叫向下轉型(downcasting)，要強制轉換。

如：f1 就是一個指向子類對象的父類引用。把f1賦給子類引用s1即 Son s1 = (Son)f1；

其中f1前面的(Son)必須加上，進行強制轉換。

一、向上轉型。
通俗地講即是將子類對象轉為父類對象。此處父類對象可以是介面。

1，向上轉型中的方法調用。

看下面代碼：

[java] view plainprint?
package com.wensefu.others;
public class Animal {

public void eat(){
System.out.println("animal eatting...");
}
}
class Bird extends Animal{

public void eat(){
System.out.println("bird eatting...");
}

public void fly(){

System.out.println("bird flying...");
}
}
class Main{

public static void main(String[] args) {

Animal b=new Bird(); //向上轉型
b.eat();
//! error: b.fly(); b雖指向子類對象，但此時丟失fly()方法
dosleep(new Male());
dosleep(new Female());
}

public static void dosleep(Human h) {
h.sleep();
}
}

[java] view plainprint?
package com.wensefu.others;
public class Human {
public void sleep() {
System.out.println("Human sleep..");
}
}
class Male extends Human {
@Override
public void sleep() {
System.out.println("Male sleep..");
}
}
class Female extends Human {
@Override
public void sleep() {
System.out.println("Female sleep..");
}
}

注意這里的向上轉型：
Animal b=new Bird(); //向上轉型
b.eat();

此處將調用子類的eat()方法。原因：b實際指向的是Bird子類，故調用時會調用子類本身的方法。

需要注意的是向上轉型時b會遺失除與父類對象共有的其他方法。如本例中的fly方法不再為b所有。

2，向上轉型的好處。

看上面的代碼，

public static void dosleep(Human h) {
h.sleep();
}

這里以父類為參數，調有時用子類作為參數，就是利用了向上轉型。這樣使代碼變得簡潔。不然的話，
如果dosleep以子類對象為參數，則有多少個子類就需要寫多少個函數。這也體現了JAVA的抽象編程思想。

二、向下轉型。

與向上轉型相反，即是把父類對象轉為子類對象。

看下面代碼：

[java] view plainprint?
package com.wensefu.other1;
public class Girl {
public void smile(){
System.out.println("girl smile()...");
}
}
class MMGirl extends Girl{

@Override
public void smile() {

System.out.println("MMirl smile sounds sweet...");
}
public void c(){
System.out.println("MMirl c()...");
}
}
class Main{

public static void main(String[] args) {

Girl g1=new MMGirl(); //向上轉型
g1.smile();

MMGirl mmg=(MMGirl)g1; //向下轉型,編譯和運行皆不會出錯
mmg.smile();
mmg.c();

Girl g2=new Girl();
// MMGirl mmg1=(MMGirl)g2; //不安全的向下轉型,編譯無錯但會運行會出錯
// mmg1.smile();
// mmg1.c();
/*output:
* CGirl smile sounds sweet...
* CGirl smile sounds sweet...
* CGirl c()...
* Exception in thread "main" java.lang.ClassCastException: com.wensefu.other1.Girl
* at com.wensefu.other1.Main.main(Girl.java:36)
*/
if(g2 instanceof MMGirl){
MMGirl mmg1=(MMGirl)g2;
mmg1.smile();
mmg1.c();
}

}
}

Girl g1=new MMGirl(); //向上轉型
g1.smile();
MMGirl mmg=(MMGirl)g1; //向下轉型,編譯和運行皆不會出錯

這里的向下轉型是安全的。因為g1指向的是子類對象。

而
Girl g2=new Girl();
MMGirl mmg1=(MMGirl)g2; //不安全的向下轉型,編譯無錯但會運行會出錯

運行出錯：

Exception in thread "main" java.lang.ClassCastException: com.wensefu.other1.Girl
at com.wensefu.other1.Main.main(Girl.java:36)
如代碼所示，可以通過instanceof來防止出現異常。

⑹ java中向上轉型，向下轉型，強制類型轉換的原理

向上或者向下轉型
就要說到繼承
比如有2個類
a
b
b繼承a
先
b
b
=
new
b();
這個時候
a
a
=
b;
這種用法就是向上轉型
使用父類的引用
引用子類對象
向上轉型是自動的不需要其他操作
然後在上邊的基礎上
b
=
(b)a
這個就是向下轉型
當用父類引用
引用子類對象
現在想不使用父類的引用
而使用子類的引用
就是向下轉型
向下轉型必須強制轉型
必須確定對象確實是子類對象
如果是父類對象那就會報錯

⑺ java 的向上轉型到底什麼意思，怎麼表示

你好，這兩點你必須理解：
1、向上轉型就是讓父類的引用去指向子類的對象。
2、向上轉型會自動進行，因此是不需要顯示聲明的。
為了加深你的理解，舉個例子：
class Parent{}
class Child extends Parent{}
Parent p = new Child() ; //這里就用到了向上轉型，仔細體會，不難理解

⑻ java中的向上轉型向下轉型是甚麼意思該如何去理解！

下面是我個人看法，僅供參考向上轉型指子類向父類轉型或與父類型變數產生運算向下轉型指父類型向子類轉型舉個例子Objecto=newHashMap();//變數o定義的是Object類型，實際初始化時是HashMap類型（Object是所有類的父類），屬於向上轉型，沒有任何問題Strings=o.get(id);//會報錯//這條語句，從HashMap中獲得對象，賦值到String變數由於是原生的HashMap，所以裡面的元素是Object類型，賦值給String變數相當於向下轉型，有毛病，需要強迫類型轉換Strings=(String)o.get(id);//當前條件是HashMap中元素的確是String類型

⑼ 關於java中的向上轉型

這個是面向對象的三大特性之一：多態。
如果子類中存在method()方法，則java虛擬機會使用子類的method()方法；
如果沒有則去父類找到調用父類的方法。多態是將父類的引用指向子類。

⑽ 關於java的向上轉型

來自CSDN。通俗易懂。
我們在現實中常常這樣說：這個人會唱歌。在這里，我們並不關心這個人是黑人還是白人，是成人還是小孩，也就是說我們更傾向於使用抽象概念「人」。再例如，麻雀是鳥類的一種（鳥類的子類），而鳥類則是動物中的一種（動物的子類）。我們現實中也經常這樣說：麻雀是鳥。這兩種說法實際上就是所謂的向上轉型，通俗地說就是子類轉型成父類。這也符合Java提倡的面向抽象編程思想。來看下面的代碼：
package a.b;
public class A {
public void a1() {
System.out.println("Superclass");
}
}
A的子類B：
package a.b;
public class B extends A {
public void a1() {
System.out.println("Childrenclass"); //覆蓋父類方法
}
public void b1(){} //B類定義了自己的新方法
}
C類：
package a.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：
package a.b;
public class Monitor{
public void displayText() {}
public void displayGraphics() {}
}
液晶顯示器類LCDMonitor是Monitor的子類：
package a.b;
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的子類：
package a.b;
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的子類：
package a.b;
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類代碼如下：
package a.b;
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();
}
}
可能你已經意識到上述代碼有很多重復代碼，而且也不易維護。有了向上轉型，代碼可以更為簡潔：
package a.b;
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();
}
}
我們也可以採用介面的方式，例如：
package a.b;
public interface Monitor {
abstract void displayText();
abstract void displayGraphics();
}
將液晶顯示器類LCDMonitor稍作修改：
package a.b;
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可以不不作任何修改。
可以看出，向上轉型體現了類的多態性，增強了程序的簡潔性。