国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

Java筆記 - 重寫/重載，向上轉型/向下轉型

qqlcbb / 1063人閱讀

摘要：所以靜態方法不能被覆蓋。雖然就算你重寫靜態方法，編譯器也不會報錯。也就是說，如果你試圖重寫靜態方法，不會阻止你這么做，但你卻得不到預期的結果重寫僅對非靜態方法有用。我們應該直接使用類名來訪問靜態方法，而不要使用對象引用來訪問。

重寫/重載

重寫指的是根據運行時對象的類型來決定調用哪個方法，而不是根據編譯時的類型。所以靜態方法不能被覆蓋。

（如果從重寫方法會有什么特點來看，我們是不能重寫靜態方法的。雖然就算你重寫靜態方法，編譯器也不會報錯。也就是說，如果你試圖重寫靜態方法，Java 不會阻止你這么做，但你卻得不到預期的結果（重寫僅對非靜態方法有用）。重寫指的是根據運行時對象的類型來決定調用哪個方法，而不是根據編譯時的類型。讓我們猜一猜為什么靜態方法是比較特殊的？因為它們是類的方法，所以它們在編譯階段就使用編譯出來的類型進行綁定了。使用對象引用來訪問靜態方法只是 Java 設計者給程序員的自由。我們應該直接使用類名來訪問靜態方法，而不要使用對象引用來訪問。）

向上轉型/向下轉型

assume 兩個類 Base 類 和 Agg 類，Agg 繼承與 Base .
and 一個原則：父類引用指向子類對象，子類引用不能指向父類對象(不安全)。

1 向上轉型 
javaBase f1 = new Agg (); 父類引用指向子類對象

左邊叫 生成一個父類引用Father f1
右邊叫 生成一個子類對象new Son() f1 引用指向了內存堆中Son對象。
把子類對象直接賦給父類的引用叫向上轉型，向上轉型不用強制轉換。向上轉型就是父類引用指向子類對象，這里誰指向誰記著不方便，一個簡單的記憶方法是 A a = new B(); 可以想象一個箭頭 A a => new B(); namely, A 指向 B.

javaclass Base{
    public String getField(){
        String name = "Base";
            return name;
    }
}
class Agg extends Base{
    public String getField(){
        String name = "Agg";
            return name;
    }
}

javapublic class test {
    public static void main(String[] args) {
        Base a = new Agg();
        System.out.println(""+a.getField());
    }
}

output: Agg
動態綁定，覆蓋了父類的函數
當我們調用a的方法的時候，我們會首先看看a對應的類有沒有這個方法, 如果有并且被子類覆蓋，這邊就會調用子類的方法。

javaclass Base{}
class Agg extends Base{
    public String getField(){
        String name = "Agg";
        return name;
    }
}
public class test {
    public static void main(String[] args) {
        Base a = new Agg();
        System.out.println(""+ ((Agg)a).getField());
    }
}

output: Agg.
如果沒有，編譯器就認為Base沒有這個函數，直接調用就會報錯 （從這里也能看出向上轉型會丟掉子類的一些信息）。
這時候吧a轉換成Agg類型的對象，編譯器就認為a是一個Agg 類型。可以調用Agg類的函數。

javaclass Base{
    public String getField(){
        String name = "Base";
        return name;
    }
}
class Agg extends Base{
    public String getField(){
        String name = "Agg";
            return name;
    }
}
public class test {
    public static void main(String[] args) {
        Agg b = new Agg();
        Base a =  (Base)b; 向上轉型的另一個寫法
        System.out.println(""+a.getField());
    }
}

output: Agg
這道題是向上轉型的另一個寫法.

java
class Base{
    public static String getField(){
        String name = "Base";
            return name;
    }
}
class Agg extends Base{
    public static String getField(){
        String name = "Agg";
            return name;
    }
}
public class test {
    public static void main(String[] args) {
        Agg a = new Agg();
        Base b =  new Agg();
        System.out.println(""+a.getField());
        System.out.println(""+b.getField());
    }
}

output : Agg Base
靜態函數不能覆蓋

2 向下轉型 
javaSon s1 = (Son)f1;

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

javaFather f2 = new Father();
Son s1 = (Son)f2; //編譯出錯，子類引用不能指向父類對象

如

javaclass Base{
    public String getField(){
        String name = "Base";
            return name;
    }
}
class Agg extends Base{
    public String getField(){
        String name = "Agg";
            return name;
    }
}
public class test {
    public static void main(String[] args) {
        Base a = new Base();
        Agg b = (Agg)a;  不會編譯通過，這樣向下轉型不可以，不安全。
        System.out.println(""+b.getField());
    }
}

向下轉型：當比較對象的時候，向下轉型是很有用的。
那應該如何安全的向下轉型？
先向上 - 再向下

javaBase b = new Agg(); 先向上
Agg a= (Agg)b; 再向下

再貼一個向下轉型實際應用場景的代碼，比較對象：

javapublic class Person
{
  private String name;
  private int age;

  public boolean equals(Object anObject)
  {
     if (anObject == null)
         return false;

     /* The object being passed in is checked
         to see it"s class type which is then compared
         to the class type of the current class.  If they
         are not equal then it returns false
     */

     else if (getClass( ) != anObject.getClass())
         return false;

     else
     {
        /* 
         this is a downcast since the Object class
         is always at the very top of the inheritance tree
         and all classes derive either directly or indirectly 
         from Object:
        */
        Person aPerson = (Person) anObject;
        return ( name.equals(aPerson.name) 
                && (age == aPerson.age));
     }
  }
}

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/64269.html

相關文章

  • 1、接口 2、多態

    摘要：接口的概念接口的概念接口是功能的集合，同樣可看做是一種數據類型，是比抽象類更為抽象的類。多態的前提是必須有子父類關系或者類實現接口關系，否則無法完成多態。 01接口的概念 * A:接口的概念 接口是功能的集合，同樣可看做是一種數據類型，是比抽象類更為抽象的類。 接口只描述所應該具備的方法，并沒有具體實現，具體的實現由接口的實現類(相當于接口的子類)來完成。這樣將功能的定...

    Magicer 評論0 收藏0

  • 9. java 多態

    摘要：概念所謂多態，就是指一個引用變量類型在不同的情況下的多種狀態。需進行強制轉換有風險，最好使用進行判斷。繼承在多態中必須存在有繼承關系的子類和父類。在中有兩種形式可以實現多態繼承和接口。 概念 所謂多態，就是指一個引用變量（類型）在不同的情況下的多種狀態。也可以理解為，多態是指通過指向父類的指針，來調用在不同子類中實現的方法。多態性是對象多種表現形式的體現 多態性嚴格來說有兩種描述形式:...

    wanglu1209 評論0 收藏0

  • 面向對象接口多態

    摘要：多態的前提是必須有子父類關系或者類實現接口關系，否則無法完成多態。具體格式如下父類引用指向子類對象就是多態的定義格式。多態的轉型分為向上轉型與向下轉型兩種向上轉型當有子類對象賦值給一個父類引用時，便是向上轉型，多態本身就是向上轉型的過程。 第3天 面向對象 今日內容介紹? 接口? 多態? 筆記本案例今日學習目標? 寫出定義接口的格式? 寫出實現接口的格式?...

    wangdai 評論0 收藏0

  • 向上轉型讀書筆記

    摘要：把這種對某個對象的引用視為對其基類的引用的做法被稱作向上轉型?；蛘呃^承或者重寫了的問題從子類向上轉型到父類，可能會縮小接口。因為向上轉型之后使用引用進行訪問，只能訪問父類定義的接口，而不能訪問自己定義的新接口。 preliminary 最近在讀Thinking in Java這篇是一個基本此書的整理。 什么是向上轉型upcast? 對象既可以作為它本身的類型使用，也可以作為它的基類...

    RdouTyping 評論0 收藏0

  • 《Java編程思想》筆記8.多態

    摘要：多態的作用是消除類型之間的耦合關系。編寫構造器準則用盡可能簡單的方法使對象進入正常狀態，如果可以的話，避免調用其他方法。 點擊進入我的博客 在面向對象的程序設計語言中，多態是繼數據抽象（封裝）和繼承之后的第三種基本特征。多態通過分離做什么和怎么做，從另一角度將接口和實現分離開來。多態的作用是消除類型之間的耦合關系。 8.1 再論向上轉型 對象既可以作為它自己的本類使用，也可以作為它的...

    chinafgj 評論0 收藏0

發表評論

0條評論

qqlcbb

男|高級講師

TA的文章

閱讀更多
最新活動
閱讀需要支付1元查看
<