溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章主要介紹如何解決Java中向上造型向下造型和接口回調中的問題，文中介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們一定要看完！
最近回顧了一下java繼承中的問題，下面貼代碼：
public class Base {
protected String temp = "base";
public void fun(){
System.out.print("BASE fun()");
}
public static void main(String[] args) {
Base b =new Base();//實例化Base對象
b.fun(); //調用父類中fun()的方法
System.out.println(b.temp);//訪問父類中的成員變量temp
/*****************************************************/
System.out.println("/***************/");
Son son = new Son();//實例化Son對象
son.fun(); //調用son的fun方法
System.out.println(son.temp);//訪問son的成員變量temp
Son S_son=new Son(); //實例化Son對象
Base B_s =(Base)S_son; //向上造型-----------相當于Base s =new Son();
B_s.fun(); //調用子類的fun()方法
System.out.println(B_s.temp);//訪問父類的成員變量temp
/******************************************************/
System.out.println("/***************/");
Base s =new Son();//向上造型
s.fun(); //調用子類的方法
System.out.println(s.temp);//調用父類的成員變量temp
Base ba =new Son();
Son so = (Son)ba; //向下造型
so.fun(); //調用子類的fun()方法
System.out.println(so.temp);//訪問子類的成員變量temp
}
}
class Son extends Base{
protected String temp = "Son";
public void fun(){
System.out.print("SON fun()");
}
}運行結果：
BASE fun()base /***************/ SON fun()Son SON fun()base /***************/ SON fun()base SON fun()Son
結論總結：
1、父類的引用變量可以指向子類對象，子類的引用變量不能指向父類對象。
2、向上造型（upcasting）：把子類對象直接賦給父類引用，向上轉型不用強制轉型。如：
Base base = new Son(); 向上造型–隱式
3、向下造型（downcasting）：把指向子類對象的父類引用賦給子類引用，要強制轉型。
Base b= new Son();
Son s = (Son)base;----------向下造型–必須強制轉換，且必須有繼承關系
4、upcasting 會丟失子類特有的方法,但是子類overriding 父類的方法，子類對象去 調用方法有效
5、調用方法或成員變量的規律：
前提：子類存在重寫方法，父類和子類中同時有相同名稱的成員變量。
(1)當進行了向上造型的引用型變量—父類引用變量只能調用子類的重寫方法，但父類的引用變量只能訪問父類中的成員變量
(2)當進行了向下造型的引用型變量—子類引用變量只調用子類重寫方法，子類的引用變量只能訪問子類的成員變量。
(3)自己想了個通俗的說法，調用方法，得當前的引用變量指向的對象；調用變量，得看當前引用變量的類型。
即，調方法，看對象，調變量，看類型。（可以試驗一下）
接口回調與向上造型
/**
* 接口回調，和向上造型的對比
* @author Character_Painter
*
*/
public class Inter extends Father implements Person,Teacher{
public void study(){
System.out.println("學習");
}
public void sleep(){
System.out.println("子類sleep()方法");
}
public static void main(String[] args) {
Father f = new Inter();
f.sleep();//向上轉型---調用
Person p=new Inter();
p.eat(); //接口回調方法
Teacher t = new Inter();
t.teach(); //接口回調方法
}
@Override
public void eat() {
System.out.println("重寫eat()方法");
}
@Override
public void teach() {
System.out.println("重寫teache()方法");
}
}
interface Person{
public void eat();
}
interface Teacher{
public void teach();
}
class Father{
public void sleep(){
System.out.println("父類sleep()方法");
}
}運行結果
子類sleep()方法
重寫eat()方法
重寫teache()方法
總結：
使用接口方式，其目的應該是實現多個父類型的方法實現，強調一個多種實現，而向上造型，針對的是一對一的繼承關系，向上造型后，可以調用子類的重寫的方法。這就是我認為他們的區別。
補充知識：Java向下轉型的意義與塑型的三個方面
一開始學習 Java 時不重視向下轉型。一直搞不清楚向下轉型的意義和用途，不清楚其實就是不會，那開發的過程肯定也想不到用向下轉型。
其實向上轉型和向下轉型都是很重要的，可能我們平時見向上轉型多一點，向上轉型也比較好理解。
但是向下轉型，會不會覺得很傻，我是要用子類實例對象，先是生成子類實例賦值給父類引用，在將父類引用向下強轉給子類引用，這不是多此一舉嗎？我不向上轉型也不向下轉型，直接用子類實例就行了。
我開始學習Java時也是這么想的，這誤區導致我覺得向下轉型就是沒用的。
隨著技術的提升，我在看開源的項目學習，發現很多地方都用了向下轉型的技術，這就讓我重視了起來，想要重新來復習（學習）這個知識點。也是搜索了許多博客文章，但都沒具體說明向下轉型，只是給了例子演示怎么使用，反而是向上轉型講了一堆（可能是我沒找到）。
這篇博客就是講向下轉型的，那我們就來學習下向下轉型，了解下這種特性的意義和使用場景
新建一個電子產品接口，如下：
public interface Electronics{
}
很簡單，什么方法都沒有。
新建一個Thinkpad筆記本類，并實現電子產品接口：
public class Thinkpad implements Electronics{
//Thinkpad引導方法
public void boot(){
System.out.println("welcome,I am Thinkpad");
}
//使用Thinkpad編程
public void program(){
System.out.println("using Thinkpad program");
}
}新建一個Mouse鼠標類，并實現電子產品接口：
public class Mouse implements Electronics{
//鼠標移動
public void move(){
System.out.println("move the mouse");
}
//鼠標點擊
public void onClick(){
System.out.println("a click of the mouse");
}
}新建一個Keyboard鍵盤類，并實現電子產品接口：
public class Keyboard implements Electronics{
//使用鍵盤輸入
public void input(){
System.out.println("using Keyboard input");
}
}這里子類比較多，是為了更好的理解。每個類的方法的邏輯實現也很簡單。打印了一行信息
接下來，我們想象一個情景：我們去商城買電子產品，電子產品很多吧，比如筆記本電腦，鼠標，鍵盤，步步高點讀機哪里不會點哪里，我們用的手機，等等，這些都屬于電子產品。電子產品是抽象的。好，那么我們決定買一臺Thinkpad，一個鼠標和一個鍵盤。
這時，我們需要一個購物車來裝這些電子產品吧。我們可以添加進購物車，然后通過購物車還能知道存放的電子產品數量，能拿到對應的電子產品。
那么，一個購物車類就出來了，如下：
import java.util.ArrayList;
import java.util.List;
public class ShopCar{
private List<Electronics> mlist = new ArrayList<Electronics>();
public void add(Electronics electronics){
mlist.add(electronics);
}
public int getSize(){
return mlist.size();
}
public Electronics getListItem(int position){
return mlist.get(position);
}
}List 集合是用來存放電子產品的，add 方法用來添加電子產品到購物車，getSize 方法用來獲取存放的電子產品數量，getListItem 方法用來獲取相應的電子產品。
可以看到 List<Electronics> 用了泛型的知識，至于為什么要用泛型？這個不做介紹了，泛型很重要的。
而我覺得比較疑惑的是為什么是放 Electronics 的泛型，而不是放Thinkpad，Mouse，Keyboard，Phone等？
那么如果是List<Thinkpad>，肯定是放不進鼠標Mouse的吧，難道要生成3個集合？這里是定義了3個電子產品類，但是我如果有100種電子產品呢，要定義100個集合?
這太可怕了。所以之前，我們寫了一個Electronics接口，提供了一個Electronics的標準，然后讓每一個Electronics子類都去實現這個接口。
實際上這里又涉及到了向上轉型的知識點，我們雖然在add 方法將子類實例傳了進來存放，但子類實例在傳進去的過程中也進行了向上轉型
所以，此時購物車里存放的子類實例對象，由于向上轉型成Electronics，已經丟失了子類獨有的方法，以上述例子來分析，Thinkpad實例就是丟失了boot() 和program() 這兩個方法，而Mouse實例就是丟失了move()和onClick()這兩個方法
但是實際使用Thinkpad或Mouse或Keyboard時，這種情況肯定不是我們想要的
接著我們寫一個測試類 Test 去測試購物車里的電子產品。
測試類 Test 如下：
public class Test{
public static final int THINKPAD = 0;
public static final int MOUSE = 1;
public static final int KEYBOARD = 2;
public static void main(String[] args){
//添加進購物車
ShopCar shopcar = new ShopCar();
shopcar.add(new Thinkpad());
shopcar.add(new Mouse());
shopcar.add(new Keyboard());
//獲取大小
System.out.println("購物車存放的電子產品數量為 ——> "+shopcar.getSize());
//開始測試thinkpad電腦
Thinkpad thinkpad = (Thinkpad)shopcar.getListItem(THINKPAD);
thinkpad.boot();
thinkpad.program();
System.out.println("-------------------");
//開始測試Mouse鼠標
Mouse mouse = (Mouse)shopcar.getListItem(MOUSE);
mouse.move();
mouse.onClick();
System.out.println("-------------------");
//開始測試Keyboard鍵盤
Keyboard keyboard = (Keyboard)shopcar.getListItem(KEYBOARD);
keyboard.input();
}
}運行截圖：
舉個例子分析就好
//開始測試thinkpad電腦 Thinkpad thinkpad = (Thinkpad)shopcar.getListItem(THINKPAD); thinkpad.boot(); thinkpad.program();
shopcar.getListItem(THINKPAD)
這句代碼是獲取到Electronics類型的實例。不是Thinkpad的實例
通過向下轉型，賦值給子類引用
Thinkpad thinkpad = (Thinkpad)shopcar.getListItem(THINKPAD);
這樣子類實例又重新獲得了因為向上轉型而丟失的方法（boot 和program）
總結一下吧，很多時候，我們需要把很多種類的實例對象，全部扔到一個集合。（這句話很重要）
在這個例子里就是把Thinkpad筆記本，Mouse鼠標，KeyBoard鍵盤等實例對象，全部扔到一個Shopcar購物車集合。
但是肯定不可能給他們每個種類都用一個獨立的集合去存放吧，這個時候我們應該尋找到一個標準，接口就是一個標準。這些都是各種電子產品，抽象成電子產品。然后一個Electronics接口就出來了。
在回到剛才，我們把很多種類的實例對象全部扔到一個集合。或許這樣比較好理解：把很多種類的子類實例對象全部扔到存放父類實例的集合。
經過了這個過程，子類實例已經賦值給了父類引用（即完成了向上轉型），但很遺憾的丟失了子類擴展的方法。
很好的是Java語言有個向下轉型的特性，讓我們可以重新獲得丟失的方法，即強轉回子類
所以我們需要用到子類實例的時候，就從那個父類集合里拿出來向下轉型就可以了，一樣可以使用子類實例對象
……
我在搜索java向下轉型的意義時，得到一個比較好的答案是這樣的：
最大的用處是java的泛型編程，用處很大，Java的集合類都是這樣的。
而在Android開發中，我們在Layout文件夾，用xml寫的控件。為什么能在Activity等組件中通過 findViewById() 方法找到呢？為什么 findViewById(R.id.textview) 方法傳入TextView的id后，還要轉型為TextView呢？這就是 Java 向下轉型的一個應用
以上是如何解決Java中向上造型向下造型和接口回調中的問題的所有內容，感謝各位的閱讀！希望分享的內容對大家有幫助，更多相關知識，歡迎關注億速云行業資訊頻道！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
