Java面向對象中：方法重載和方法重寫以及區別、 this關鍵字和super關鍵字以及區別

2020-04-13 Java面向對象中：方法重載和方法重寫、 this關鍵字和super關鍵字方法重載：是指同一個類中的多個方法具有相同的名字,但這些方法具有不同的參數列表,即參數的數量或參數類型或者參數順序不能完全相同；重載是一個類中多態性的一種表現總結： 1.同一個類中 2.方法名相同 ...

2020-04-13

Java面向對象中：方法重載和方法重寫、 this關鍵字和super關鍵字

方法重載：是指同一個類中的多個方法具有相同的名字,但這些方法具有不同的參數列表,即參數的數量或參數類型或者參數順序不能完全相同；重載是一個類中多態性的一種表現

總結：

1.同一個類中

2.方法名相同

3.參數列表不同，即參數的數量或參數類型或參數順序不能完全相同

4.對其他沒有要求,（例如：對返回值類型沒有要求一致）

package com.zzm.trydemo;
/* 方法重載：
 * 1.同一個類中
 * 2.方法名相同
 * 3.參數列表不同，即參數的數量 或 參數類型 或 參數順序 不能完全相同
 * 
 * */
public class Test1_Overload {
    public static void main(String[] args) {
        student();
        student("小明",5);
        student(18,"小紅");
}
    
    public static void student(){
        System.out.println("我是一個學生");
    }
    public static void student(String name,int age){
        System.out.println("我是一個學生，我叫"+name+"，我今年"+age+"歲");
    }
    public static void student(int age,String name){
        System.out.println("我是一個學生，我叫"+name+"，我今年"+age+"歲");
    }

}

/* 代碼輸出：
 *我是一個學生
 *我是一個學生，我叫小明，我今年5歲
 *我是一個學生，我叫小紅，我今年18歲
 * 
 * */

方法重載案例

方法重寫：是存在子父類之間的,子類定義的方法與父類中的方法具有相同的方法名字,相同的參數表和相同的返回類型；

重寫是父類與子類之間多態性的一種表現；

重寫是為了調用子類對象時，改變父類的功能

總結：

1.方法重寫：訪問修飾符返回值類型方法名(參數類型參數){代碼...}
2.方法重寫用於繼承中(子類 Extends父類)的子類里--------不在同一個類中
3.訪問修飾符許可權：子類>=父類（public>protected>default>private）
4.返回值類型： 4.1.基本類型或者 void ---子類和父類相同
4. 2.引用類型 -----子類<=父類
5.方法名、參數列表：子類同父類相同,一模一樣

6. 繼承後，子類就擁有了父類的功能

7. 那麼在子類中，可以添加子類特有的功能也可以修改父類的原有功能

8. 子類中方法簽名與父類完全一樣(包括方法的返回值，方法名和參數列表，完全一致)時，會發生覆蓋/覆寫操作，相當於修改功能

註意：

1、父類中的私有方法不能被重寫

2、子類重寫父類方法時，修飾符要大於等於父類修飾符的許可權

package com.zzm.trydemo;
/*
 *方法重寫：訪問修飾符  返回值類型  方法名(參數類型 參數){代碼...}
 *方法重寫用於繼承中(子類 Extends父類)的子類里---在不同一個類中
 *訪問修飾符 許可權： 子類>=父類
 *返回值類型：          1.基本類型 或者void ---子類和父類相同
 *             2.引用類型                    ---子類<=父類
 *方法名、參數列表：子類同父類相同,一模一樣
 */
public class Test2_OverRide {
    public static void main(String[] args) {
        Student1 s=new Student1();
        s.teach();
    }
}
class Teacher1{
    public void teach(){
        System.out.println("老師上課");
    }
    
}
class Student1 extends Teacher1{
    public void teach(){
        System.out.println("學生聽課");
    }
}

/*
 * 輸出結果：
 * 學生聽課
 * 
 * */

方法重寫案例

重載與重寫的區別（Overload和Override的區別）

1、目的不同

overload用於增加程式的可讀性(做法不同,但是做的同一事情)。 override用於提供其超級類已經提供的方法的特定實現。

2、範圍不同

overload 在相同的類範圍內內執行,是一個類中多態性的一種表現。 override發生在兩類具有繼承（繼承）的關係,是父類與子類之間多態性的一種表現。

3、參數不同

overload參數必須不同。 override參數必須相同。

this關鍵字：

1.this 代表本類對象引用，在本類中使用
2.局部變數和成員變數同名時，用this可調用本類成員方法或者本類成員變數，調用方式 this.成員

因為在構造方法（構造函數）中，有個經典的this用法，所以也順便提一提

構造方法（構造函數）：構造方法是與類同名，且沒有返回值類型，主要是完成對象的創建或者對象的初始化

修飾符類名(【參數】){

代碼……

}

package test.constructe;
//構造方法創建
public class Constr {
    public static void main(String[] args) {
        Person p=new Person();//無參創建對象，底層會自動調用無參構造方法
        Person p2=new Person("小明");//含參創建對象，底層會自動調用含參構造方法
        
    }
}
class Person{
    //構造方法，與類同名，修飾符 類名(參數列表){方法體}
    public Person(){//預設會存在構造方法--前提沒有提供含參構造方法
        System.out.println("無參構造方法");
    }
    //重載構造方法
    public Person(String name){
        System.out.println("含參構造方法 "+name);
    }
}

/*
 *無參構造方法
 *含參構造方法 小明
 * 
 * 
 */

構造方法案例

package com.zzm.trydemo;

/*
 *1.this 代表本類對象引用，在本類中使用    
 *2.局部變數和成員變數同名時，用this可調用本類成員方法或者本類成員變數
 */

public class Test3_This {
    public static void main(String[] args) {
        ThisDemo td=new ThisDemo();//創建無參構造對象時，就會自動調用無參構造方法
        ThisDemo td2=new ThisDemo(30);
        td2.f1();
    }
}
class ThisDemo{
    int sum=20;
    
    public ThisDemo(){//一般，沒有用也要寫出來
        //this(999);//this 不能在兩個都早參數中相互調用，那是死迴圈
        System.out.println("自動調用無參構造方法");
    }
    public ThisDemo(int sum){
        this();//在構造方法中，放在第一行；在一個構造函數中可以調另一個構造函數
        System.out.println("含參構造方法，已經傳入值"+sum);
        this.sum=sum;
    }
    
    public void f1(){
        int sum=10;
        System.out.println("就近原則"+sum);
        
        ThisDemo t=new ThisDemo();//又會調用一次無參構造
        System.out.println("新創建一個對象仍然使用的是成員變數的值"+t.sum);//仍然使用的是成員變數的值
        
        System.out.println("使用的傳入的賦值後的值"+this.sum);//使用的傳入的賦值後的值
        
        f2();//同this.f2();意義結果相同，通常this是隱式，不寫直接調用，氮實際上是有this關鍵字的
    }
    
    public void f2(){
        System.out.println("這是f2");
    } 

}

/*
 * 輸出結果：
 *自動調用無參構造方法
 *自動調用無參構造方法
 *含參構造方法，已經傳入值30
 *就近原則10
 *自動調用無參構造方法
 *新創建一個對象仍然使用的是成員變數的值20
 *使用的傳入的賦值後的值30
 *這是f2
 * 
 * 
 * */

this案例

super關鍵字：

1、通過super關鍵字可以使用父類的內容

2、 super代表父類的一個引用對象

3、如果用，必須出現在調用位置的第一行

4、不管父類無參構造寫沒寫，子類構造無參里都有super，隱式了。一般都要寫無參構造，方便。
如果父類沒有寫無參構造，子類的構造函數里必須寫 super(參數)

package com.zzm.trydemo;
/*1、 通過super關鍵字可以使用父類的內容,在子類中使用
 *2、 super代表父類的一個引用對象
 *3、 如果用在構造方法中，必須出現在調用位置的第一條語句！！(類似於this) 
 *  
 *4、 不管父類無參構造寫沒寫，子類構造無參里都有super，隱式了 。一般都要寫無參構造，方便
 *  如果父類沒有寫無參構造，子類的構造函數里必須寫super(參數)
 * */
public class Test4_Super {
    public static void main(String[] args) {
        Student2 s=new Student2();
    }

}
class Person2{
    int a=1;

    public Person2(){//父類無參構造
        System.out.println("無參Person2");
    }
    public Person2(int a){//父類有參構造
        System.out.println("有參Person2");
    }
    
    public void f(){
        System.out.println("父類f方法");
    }
     
}
class Student2 extends Person2{
    int a=2;

    public Student2(){//子類無參構造
        //super();//先調用父類的無參構造；隱式的，可以不寫，不寫也會調用父類的無參構造；必須放在第一行
        super(1);//super(1)會將super()覆蓋掉
        System.out.println("Student2");
        System.out.println("調用子類的a值"+a);
        System.out.println("調用父類的a值"+super.a);
        f();
        super.f();
        
    }
    
    public void f(){
        System.out.println("子類f方法");
    }
}


/*
 * 輸出結果：
 *有參Person2
 *Student2
 *調用子類的a值2
 *調用父類的a值1
 *子類f方法
 *父類f方法 
 *
 */

super案例

this和super的區別

1、 this代表本類對象的引用，super代表父類對象的引用。

2、 this用於區分局部變數和成員變數

3、 super用於區分本類變數和父類變數

4、 this.成員變數 this.成員方法() this(【參數】)代表調用本類內容

5、 super.成員變數 super.成員方法() super(【參數】)，代表調用父類內容

6、 this和super不可以同時出現在同一個構造方法里，他們兩個只要出現都得放在第一行