A. java中，上轉型對象操作隱藏變數，為什麼不等同於子類對象操作相同的那個變數
上轉型對象指的是用子類創建一個對象，並且把這個對象的引用放到父類的對象中。上轉型對象用.訪問隱藏的變數，如果子類對象重寫了這個變數，則需要用super關鍵字來訪問隱藏的變數。上轉型變數調用被重寫的方法時，訪問被繼承的變數，調用未被重寫的方法時，訪問隱藏變數。子類如果重寫，無法直接調用被隱藏的變數和方法，需要用super關鍵字，但是上轉型對象不需要。這是俺的理解，希望有幫助。😝
B. 在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來防止出現異常。
C. 在java 中，什麼叫向上轉型
在Java中，"向上轉型"（Upcasting）是一個概念，指的是將子類對象賦值給父類引用的過程。這種操作使得父類引用可以指向子類對象，但不會丟失子類特有的方法。例如，如果有一個`Father`類和一個繼承自它的`Son`類，代碼`Father f1 = new Son();`就是向上轉型的實例。這樣做的好處在於，當使用父類引用調用方法時，會調用子類的方法，如`f1.eat()`會調用`Son`類的`eat()`方法。
相反，"向下轉型"（Downcasting）則是將父類引用轉換為子類引用，如`Son s1 = (Son)f1;`。這是安全的，因為`f1`原本指向的就是`Son`對象。然而，如果父類引用沒有指向子類對象，直接向下轉型可能會導致`ClassCastException`，如`Father f2 = new Father(); Son s2 = (Son)f2;`。
總結來說，向上轉型是將子類賦值給父類引用，允許調用子類的方法，而向下轉型則需要確保父類引用確實指向子類對象，否則可能會引發運行時異常。這種靈活性是Java面向對象編程中的重要特性，體現了抽象和多態的原理。
D. java中的向上轉型向下轉型是甚麼意思該如何去理解！
下面是我個人看法，僅供參考向上轉型指子類向父類轉型或與父類型變數產生運算向下轉型指父類型向子類轉型舉個例子Objecto=newHashMap();//變數o定義的是Object類型，實際初始化時是HashMap類型（Object是所有類的父類），屬於向上轉型，沒有任何問題Strings=o.get(id);//會報錯//這條語句，從HashMap中獲得對象，賦值到String變數由於是原生的HashMap，所以裡面的元素是Object類型，賦值給String變數相當於向下轉型，有毛病，需要強迫類型轉換Strings=(String)o.get(id);//當前條件是HashMap中元素的確是String類型
E. java中向上轉型和向下轉型有何用途
無論來是上轉還是下自轉都是為了讓類的使用范圍和適用范圍發生變化，以便操作不同范圍的變數或者方法。
1上轉型是指將子類對象使用父類引用進行引用。
得：上轉型對象可以操作和使用子類繼承或者重寫的方法。
失：上轉型對象喪失了對子類新增成員變數或新增的方法的操作和使用。
2與向上轉型相反，即是把父類對象轉為子類對象：作用也與上轉相反。
java 轉型問題其實並不復雜，只要記住一句話：父類引用指向子類對象。子類和父類中定義同名的變數時，僅僅是隱藏了，變數沒有多態性；而對於覆蓋的方法，Java表現出多態性，會調用更具體的子類裡面的方法，無論從哪裡調用，無論使用什麼引用類型調用。