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

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. 子類中方法簽名與父類徹底同樣(包括方法的返回值，方法名和參數列表，徹底一致)時，會發生覆蓋/複寫操做，至關於修改功能

注意：

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

二、子類重寫父類方法時，修飾符要大於等於父類修飾符的權限

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關鍵字：

一、 經過super關鍵字可使用父類的內容

二、 super表明父類的一個引用對象

三、 若是用，必須出如今調用位置的第一行

四、 無論父類無參構造寫沒寫，子類構造無參裏都有super，隱式了 。通常都要寫無參構造，方便。
       若是父類沒有寫無參構造，子類的構造函數裏必須寫   super(參數)

package com.zzm.trydemo;
/*一、 經過super關鍵字可使用父類的內容,在子類中使用
 *二、 super表明父類的一個引用對象
 *三、 若是用在構造方法中，必須出如今調用位置的第一條語句！！(相似於this) 
 *  
 *四、 無論父類無參構造寫沒寫，子類構造無參裏都有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的區別

一、 this表明本類對象的引用，super表明父類對象的引用。

二、 this用於區分局部變量和成員變量

三、 super用於區分本類變量和父類變量

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

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

六、 this和super不能夠同時出如今同一個構造方法裏，他們兩個只要出現都得放在第一行