2. 程式人生 > >菜雞的Java課筆記 第二十 方法的覆寫

菜雞的Java課筆記 第二十 方法的覆寫

阿新 • • 發佈：2018-12-05

1.方法的覆寫
    當子類定義了與父類中的完全一樣的方法時（方法名稱，引數型別以及個數，返回值型別）這樣的操作就稱為方法的覆寫
    範例：觀察方法的覆寫

class A{
    public void print(){
        System.out.println("******************");
    }
}
class B extendsa A{
    
    }    
}

public class inherit{
    public static void main(String args[]){
        B b
 
= new B();
        b.print();
    }
}
/*
結果：
******************
*/


    此時B是A的子類，並且B類中沒有定義任何的方法。此時B類將直接繼承A類中的println（）方法執行
    範例：發生覆寫

class A{
    public void print(){
        System.out.println("******************");
    }
}
class B extendsa A{
    public void print(){  //
 
 方法名稱一樣
        System.out.println("!!!!!!!!!!!!!!!!!!");
    }    
}

public class inherit{
    public static void main(String args[]){
        B b= new B();
        b.print();
    }
}
/*
結果：
!!!!!!!!!!!!!!!!!!
*/

...  

class A{
    public void print(){
        System.out.println("******************");
    }
}

 
class B extendsa A{
    public void print(){  // 與父類的方法完全一樣
        System.out.println("!!!!!!!!!!!!!!!!!!");
    }    
}
class C extendsa A{
    public void print(){
        System.out.println("￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥");
}
public class inherit{
    public static void main(String args[]){
        C c = new C();
        c.print();
    }
}
/*
結果：
￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥￥
*/     

        (主要是看 new 誰)   
        此時的程式之中使用了B類進行物件的例項化操作，並且在B類中已經明確的覆寫了A類中的print()方法
        那麼最終所呼叫的一定就是被覆寫過的方法
        
    範例：分析方法覆寫的含義

class Person{
    private String name;
    private int age;
    public void setName(String name){
        this.name = name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public String getName(){
        return this.name;
    }
    public int getAge(){
        return this.age;
    }
    public String getlnfo(){
        return     "姓名："+this.name
                +"，年齡："+this.age;
    }
}
class Student extends Person{  // Student 是Person 的子類
    private String school; // 子類自己擴充的屬性
    public void setSchool(String school){
        this.school = school;
    }
    public String getSchool(){
        return this.school;
    }
    
}
public class inherit{
    public static void main(String args[]){
        Student stu = new Student();// 例項化子類物件
        stu.setName("少爺");//通過Person類繼承而來
        stu.setAge(20);//通過Person類繼承而來
        stu.setSchool("清華");//子類自己擴充的屬性
        System.out.println(stu.getlnfo());
    }
}
/*
結果： （問題：少了School 這個值）
姓名：少爺，年齡：20
*/

******************************************        

class Person{
    private String name;
    private int age;
    public void setName(String name){
        this.name = name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public String getName(){
        return this.name;
    }
    public int getAge(){
        return this.age;
    }
    public String getlnfo(){
        return     "姓名："+this.name
                +"，年齡："+this.age;
}
}
class Student extends Person{  // Student 是Person 的子類
    private String school; // 子類自己擴充的屬性
    public void setSchool(String school){
        this.school = school;
    }
    public String getSchool(){
        return this.school;
    }
    public String getlnfo(){ // 保留方法名稱，但是有需要對功能進行擴充
        return     super.getlnfo()
                +"學校："+this.school;
        // return     "姓名："+super.getName()
                +"，年齡："+super.getAge()
                +"學校："+this.school;
    }
public class inherit{
    public static void main(String args[]){
        Student stu = new Student();// 例項化子類物件
        stu.setName("少爺");//通過Person類繼承而來
        stu.setAge(20);//通過Person類繼承而來
        stu.setSchool("清華");//子類自己擴充的屬性
        System.out.println(stu.getlnfo());
    }
}       

        實質上所謂的方法覆寫原因：
        父類中定義的方法名稱是其他程式所認可的名稱，屬於使用的習慣
        但是子類在使用的過程之中，發現原始的方法不能夠支援自己的操作，而且又需要保留豬方法名稱，這樣才出現了覆寫的概念
        並且通過以上的分析可以發現一點：
            this.方法()：會先找本類中是否有指定的方法，如果本類沒有則使用父類繼承而來的方法
            super.方法()：不查詢本類的方法，而直接找父類的方法
        但是覆寫本身也是有嚴格要求的：被覆寫的方法不能夠擁有比父類更為嚴格的訪問控制權限。
        對於訪問的控制權限嚴格來講一共有四個，已經學習過三個：private<default(friend)<public
        按照以上的思路，如果說現在父類中的方法使用了public訪問許可權宣告，那麼子類只能夠使用public 而如果父類使用了default訪問許可權宣告，那麼子類可以使用public或default
    範例：錯誤的覆寫

class A{
    public void print(){
        System.out.println("******************");
    }
}
class B extendsa A{
    void print(){  // 此時的方法訪問許可權嚴格
        System.out.println("!!!!!!!!!!!!!!!!!!");
    }    
}
public class inherit{
    public static void main(String args[]){
        B b= new B();
        b.print();
    }
}
/*
結果：出錯
*/

       
        但是此時又會出現這樣一種情況，如果父類中的方法使用了private呢？那麼子類覆寫方法時如果使用了default也屬於許可權擴大這樣可以覆寫嗎？
    範例：正常覆寫

class A{
    public void fun(){
        this.print();
    }
    public void print(){
        System.out.println("******************");
    }
}
class B extendsa A{
    public void print(){  
        System.out.println("!!!!!!!!!!!!!!!!!!");
    }    
}
public class inherit{
    public static void main(String args[]){
        B b= new B();
        b.fun();
    }
}
/*
結果：
!!!!!!!!!!!!!!!!!!
*/

       
        下面將父類中的println（）方法許可權修改為private

class A{
    public void fun(){
        this.print();
    }
    private void print(){
        System.out.println("******************");
    }
}
class B extendsa A{
    public void print(){  
        System.out.println("!!!!!!!!!!!!!!!!!!");
    }    
}
public class inherit{
    public static void main(String args[]){
        B b= new B();
        b.fun();
    }
}
/*
結果：
******************
*/

       
        從許可權的角度來看此時應該符合覆寫的要求
        通過結果可以發現，此時子類並沒有進行方法的覆寫所以就可以得出結論：
            父類中private宣告的方法不能夠被子類所覆寫，而且最重要的是這樣的操作幾乎沒有意義
        在實際之中對於方法的定義，95%的情況下都只會使用public宣告

在進行方法覆寫之後都會存在有一個就近取用的關係，如果面對本類方法自己呼叫自己的情況，因為預設情況下呼叫本類方法時都會採用“this.方法()” 的形式處理
        而在使用this呼叫結構的時候，會首先找到本類如果本類找不到的操作再去查詢父類
        為了可以不查詢本類而直接找到父類，建議使用“ super.方法() ” 的形式呼叫
        
        以後為了表示明確，強烈建議：子類訪問父類方法前都是 super
    
    面試題：請解釋Overloading與Override的區別？在進行Overloading的時候能否返改變回值型別

區別 方法過載  方法覆寫
單詞 Overloading  Override
範圍 發生在一個類中 發生在繼承關係之中
定義 方法名稱相同，引數的型別以及個數不同 方法名稱相同，引數的型別以及個數，返回值全部相同
許可權 沒有許可權要求 被覆寫的方法不能擁有比父類更為嚴格的訪問控制權限


        在進行方法過載的時候可以使用不同的返回值型別，但是從設計的標準來講不建議使用


 2.屬性的覆蓋
    當子類定義了與父類屬性名稱相同的屬性時，就稱為屬性的覆蓋
    範例：觀察屬性的覆蓋

class A{
    String info = "mysterious";
}
class B extendsa A{
    int info = 100; // 名稱相同
    public void print(){
        System.out.println(this,info);
        System.out.println(super.info);
    }
}
public class inherit{
    public static void main(String args[]){
        B b= new B();
        b.print();
    }
}
/*
結果：
100
mysterious
*/

       
        從實際開發的標準要求來講，類中的屬性必須使用private封裝，那麼一旦使用了private封裝屬性覆蓋沒有意義了
    面試題：請解釋this與super的區別？

區別 this  super
概念 表示呼叫本類屬性（this.屬性），本類方法（this.方法，this（）） 呼叫父類屬性（super.屬性），父類方法（super.方法（），super（））
構造要求 呼叫構造方法是必須放在構造方法的首行，所以this（）與super（）不能夠同時出現，但是子類永遠會去呼叫父類中的構造方法 呼叫構造方法是必須放在構造方法的首行，所以this（）與super（）不能夠同時出現，但是子類永遠會去呼叫父類中的構造方法
特殊要求 表示當前物件  


        使用this實際上會先從本類開始查詢所需要的內容，如果沒有去查詢父類，而如果使用的是super則表示不查詢本類直接查詢父類的定義

總結
1.所有類中的屬性都必須使用private定義，這樣一來覆蓋屬性就沒有任何意義了
2.方法的覆寫呼叫特點：
    看例項化的是那個子類的物件（new 出現在哪裡或者說是new哪個類）
    觀察呼叫的方法是否已經被該子類覆寫，如果覆寫則呼叫被覆寫的方法，如果沒有覆寫則呼叫從父類繼承而來的方法



相關推薦

菜雞的Java課筆記 第二十 方法的覆寫

1.方法的覆寫    當子類定義了與父類中的完全一樣的方法時（方法名稱，引數型別以及個數，返回值型別）這樣的操作就稱為方法的覆寫    範例：觀察方法的覆寫 class A{ public void print(){

菜雞的Java課筆記 第二十一 final 關鍵字

使用final定義類，屬性，方法            final在一些書中被稱為終結器，意思是：利用final定義的類不能夠有子類，利用final定義的方法不能夠被覆寫，利用final定義的變數就成為了常量，常量無法修

菜雞的Java課筆記 第二十二 物件多型性

本次只是圍繞著多型性的概念來進行講解，但是所講解的程式碼與實際的開發幾乎沒有關係，而且多型一定是在繼承性的基礎上才可以操作的，        而本次將使用類繼承的關係來描述多型的性質，實際的開發中不會出現普通類的繼承關係（一個已經完善的類不應該再被繼

菜雞的Java課筆記 第十四 String 類常用方法

/*String 類常用方法    將所有String類的常用方法全部記下來，包括方法名稱，引數作用以及型別    一個成熟的程式語言，除了它的語法非常完善之外，那麼也需要提供有大量的開發類庫    而需要知道的java

菜雞的Java課筆記 第六 方法

前提：現在所講解的方法定義格式，只屬於JAVA 方法定義的其中一種組成方式。而完整的組成方式將隨著學習逐步滲透。　　1.方法的基本定義　　　　方法（Method（麥斯而））在一些書中也會有人將其說是  函式（Function（防滲）） 。但是兩者的含義完全相同的，那什麼是方法？為什麼需要有方法？實際

菜雞的Java課筆記 第十五 this 關鍵字

this 關鍵字                對於this關鍵字有三種用法:表示本類屬性，呼叫本類方法，當前物件    &nbs

菜雞的Java課筆記 第十六 引用傳遞

referenceDelivery    引用傳遞是整個java 的精髓，也是所有初學者最難學的地方        引用的本質：同一塊堆記憶體可以被不同的棧記憶體所指向    下面

菜雞的Java課筆記 第十九 繼承

繼承性的主要目的，繼承的實現，繼承的限制                繼承是面向物件中的第二大主要特點，其核心的本質在於：可以將父類的功能一直沿用下去    

菜雞的Java課筆記 第二十三 抽象類的概念

abstractClass 抽象類的概念        1.抽象類的基本定義        2.抽象類的使用原則        &

Java學習筆記第二天——方法

方法：其實就是完成特定功能的程式碼塊 定義格式： 修飾符 返回值型別 方法名（引數型別 引數名1，引數型別 引數名2……）{ 方法體； return 返回值； } 格式解釋： 1.修飾符 目前記住public s

菜雞的Java筆記 第二十六 內部類 innerClass

/*    innerClass        從實際的開發來看，真正寫到內部類的時候是在很久以後了，短期內如果是自己編寫程式碼，幾乎是見不到內部類出現的       &

菜雞的Java筆記 第二十七 連結串列基本概念

連結串列基本概念        1.連結串列的基本形式        2.單向連結串列的完整實現         &nb

菜雞的Java筆記 第二十八 包的定義

包的主要作用以及定義    包的匯入操作    系統常見的開發包    jar 程式命令        包的定義     

菜雞的Java筆記 第二十九 單例設計模式

SingleCase 單例設計模式        1.單例設計模式的特點        2.多例設計模式的特點    內容    

菜雞的Java課筆記 第四

　　數學運算子，邏輯運算，三目運算，位運算 　　double d2 = 314e2; //採用科學計數法的寫法，表示10的2次方。= 31400.0 程式碼寫的越簡單越好   簡化運算子 　　程式碼：x＝x＋y 可以變成x＋＝y 　　求模（％） 　　＋＋（自

菜雞的Java課筆記 第九 接收鍵盤輸入

package mysterious; import java.util.Scanner; public class lianxi { public static void hhh (){ Scanner b = new Scanner(System.in);

菜雞的Java課筆記 多對多對映

要求：    1.將資料還原為簡單java類    2.資料的輸出：        可以根據一個使用者輸出它對應的角色以及每個角色對應的許可權，以及包含的具體的許可權詳情： &nb

學習筆記第二十節課

作業安裝與卸載軟件 linux下和windows下的安裝軟件方法差不多。一共有三種方法。 rpm和windows下的exe很像，可以直接安裝 不用太多的設置。安裝路徑和文件名都是設定好的。 yum是另一種方式去安裝rpm包，在centos下安裝的包叫rpm包。 yum會自動安裝依賴的包，（比如要安裝一個a包

學習筆記第二十一節課

作業yum更換國內源 有時候自帶的yum源，不好用，因為自帶的裏面的網址資源是國外的。從國內下載很慢。 想辦法更改國內的源。 實驗： 先把dvd給刪除了， 然後把之前刪除的給cp回來。 然後刪除 CentOS-Base.repo 改一個CentOS7-Base-163.repo 新的需要去下載，寫入下載

學習筆記第二十二節課

作業shell介紹 shell是一個命令解釋器，提供用戶和機器之間的交互。 用戶配置的最後一個段 就是shell 創建的普通的用戶 它的shell是bin bash 每個用戶都可以有自己的shell sentos7 的shell 是bash 除此之外還有 zsh ksh ，用起來和bash 很像，