文章目錄
- this:
- this呼叫屬性、方法：
- this呼叫構造器：
- super:
- super呼叫屬性、方法：
- super呼叫構造器：
- this與super的區別總結:
this:
this理解為：當前物件 或 當前正在創建的物件
可以呼叫的結構：屬性、方法；構造器
this呼叫屬性、方法：
先了解一下形參:
形參的意義就是給屬性賦值,我們是要給同名的屬性賦值,這時候我們就把形參名和屬性的名字寫成一樣,這樣我們就知道我們傳入的形參就是要給我們同名的屬性去賦值的.
在類的方法中，我們可以使用"this.屬性"或"this.方法"的方式，呼叫當前物件屬性或方法，但是，
通常情況下，我們都擇省略"this."，特殊情況下，如果方法的形參和類的屬性同名時，我們必須顯式的使用"this.變數"的方式，表明此變數是屬性，而非形參，
舉例:我們宣告一個類叫鞋類,給它提供私有的屬性和get/set方法和構造器:
//宣告一個鞋類
public class shoes {
//鞋的屬性
private String name;//鞋名
private int id;//編號
//無參構造器
public shoes() {
}
//有參構造器:
public shoes(String name, int id) {
// name = name;沒加this
this.name = name;
// id = id; 沒加this
this.id = id;
}
//宣告兩個方法
public void show(){
System.out.println("展示~~");
sale();//show方法中調sale方法
// this.sale();//this可省略
}
public void sale(){
System.out.println("售賣~~");
}
//get/set方法:
public String getName() {
return name;
}
public void setName(String name) {
//name = name;沒加this
this.name = name;
}
public void setId(int id) {
//id = id;沒加this
this.id = id;
}
public int getId() {
return id;
}
}
//測驗
class test {
public static void main(String[] args) {
//我們先實體化鞋類的物件來調它的屬性
shoes s = new shoes();
s.setName("nike");//這里的"nike"就是傳入的形參
System.out.println(s.getName());
//我們獲取鞋名的時候,獲取不到,意思就是形參的值又賦給了形參,代表沒有給鞋的屬性賦上值
//這個時候控制臺會輸出傳入的形參資料型別的默認值,明顯不是我們想看到的結果
s.setId(1);
System.out.println(s.getId());//鞋的id類似的也會出現同樣的情況
//"this.方法"舉例:
s.show();
/*我們先調的是show自己的方法體,然后在show方法中調了sale方法
意思是s這個物件調了show方法,我們就用調show方法的這個物件s來調sale方法,
其實在sale();前面也省略了this關鍵字,表示當前物件(就是調show方法的物件)調的sale方法*/
System.out.println("------------------------分割線--------------------");
shoes s1 = new shoes("李寧",2);//我們new的有引數的物件給它賦初值之后
System.out.println(s1.getName());
System.out.println(s1.getId());//如果沒有加this,結果還是和沒有獲取到鞋名和編號
}
}
先來看沒有加this關鍵字的情況:
結果:
然后我們給鞋屬性加上this關鍵字:
控制臺輸出的就是我們給鞋設定的名字和編號:
在類的構造器中，我們可以使用"this.屬性"或"this.方法"的方式，呼叫當前正在創建的物件屬性或方法，但是，通常情況下，我們都擇省略"this."，特殊情況下，如果構造器的形參和類的屬性同名時，我們必須顯式的使用"this.變數"的方式，表明此變數是屬性，而非形參，
同樣的我們的構造器也是一樣:如果有參構造器沒有加給屬性加this關鍵字:控制臺輸出結果也和上面一樣
加上之后:
"this.方法"舉例:我們宣告兩個方法show和sale方法來舉例體會一下this的作用:代碼參照上面:
s.show();的結果:
this呼叫構造器：
① 我們在類的構造器中，可以顯式的使用"this(形參串列)"方式，呼叫本類中指定的其他構造器
② 構造器中不能通過"this(形參串列)“方式呼叫自己
③ 如果一個類中有n個構造器，則最多有 n - 1構造器中使用了"this(形參串列)”
④ 規定："this(形參串列)“必須宣告在當前構造器的首行
⑤ 構造器內部，最多只能宣告一個"this(形參串列)”，用來呼叫其他的構造器
舉例:我們還是寫一個Shoes類 提供私有屬性和get/set方法并提供三個構造器:
public class Shoes {
//屬性
private String name;//鞋名
private int id;//編號
//get/set方法:
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
//構造器1
public Shoes() {
System.out.println("構造器1");
}
//構造器2
public Shoes(int id){
this();//調構造器1
System.out.println("構造器2");
this.id = id;
}
//構造器3
public Shoes(String name, int id) {
//通過呼叫構造器來執行其他構造器中的代碼
this(id);//調構造器2
// this.id = id;//交給構造器2來執行
this.name = name;
//我們如果需要使用到其他構造器中的代碼就可以使用"this.構造器"的方式
//這里只是為了舉例我們只寫了一行輸出陳述句,真正實際中我們寫的代碼多了,呼叫構造器的方法的優勢就體現出來了
//這樣我們可以減少代碼的冗余,提高程式執行效率
}
}
class test{
public static void main(String[] args) {
//用構造器3來實體化物件,我們在構造器3中沒有把引數id賦給當前物件
//但是通過調構造器2,構造器2中執行了 this.id = id;把id賦給了當前物件的屬性
//所以我們才可以得到當前物件s3的id
Shoes s3 = new Shoes("adidas",2021);
System.out.println(s3.getId());
}
}
運行結果:
super:
super 關鍵字可以理解為：父類的
可以用來呼叫的結構：
屬性、方法、構造器
super呼叫屬性、方法：
我們可以在子類的方法或構造器中，通過使用"super.屬性"或"super.方法"的方式，顯式的呼叫父類中宣告的屬性或方法，但是，通常情況下，我們習慣省略"super."
①特殊情況：當子類和父類中定義了同名的屬性時，我們要想在子類中呼叫父類中宣告的屬性，則必須顯式的使用"super.屬性"的方式，表明呼叫的是父類中宣告的屬性，
② 特殊情況：當子類重寫了父類中的方法以后，我們想在子類的方法中呼叫父類中被重寫的方法時，則必須顯式的使用"super.方法"的方式，表明呼叫的是父類中被重寫的方法(也就是父類中原本的方法)，
舉例兩種特殊情況:在子類的方法中呼叫父類中同名的屬性和方法:
創建一個人類,一個學生類,學生類繼承人類,和一個測驗類
//人類
public class Person {
//屬性
String name = "普通人";//姓名
int id = 1234;//身份證號
//方法
public void learn(){
System.out.println("人要學習");
}
}
//學生類
public class Student extends Person {
//宣告了與父類的同名屬性
String name = "哈利波特";//姓名
int id = 9527;//學號
@Override//子類重寫父類的方法
public void learn() {
System.out.println("學生要努力學習");
super.learn();//調父類中原本的方法
System.out.println("姓名:"+name);//子類自己的屬性
System.out.println("學號:"+id);
System.out.println("姓名:"+super.name);//父類中宣告的屬性
System.out.println("身份證號:"+super.id);
}
}
//測驗類
public class Test {
public static void main(String[] args) {
//實體化子類物件
Student student = new Student();
//調子類中重寫父類的方法
student.learn();
}
}
輸出結果:
super呼叫構造器：
我們可以在子類的構造器中顯式的使用"super(形參串列)"的方式，呼叫父類中宣告的指定的構造器
注意:
- "super(形參串列)"的使用，必須宣告在子類構造器的首行！
- 我們在類的構造器中，針對于"this(形參串列)"或"super(形參串列)"只能二者取其一，不能同時出現
- 在構造器的首行，沒顯式的宣告"this(形參串列)“或"super(形參串列)”，則默認呼叫的是父類中空參的構造器：super()
- 在類的多個構造器中，至少一個類的構造器中使用了"super(形參串列)"，呼叫父類中的構造器
舉例:還是用上面的例子,我們在人類和學生類中添加構造器:
public class Person {
//屬性
String name = "普通人";//姓名
int id = 1234;//身份證號
//構造器
public Person() {
}
public Person(String name, int id) {
this.name = name;
this.id = id;
}
//方法
public void learn(){
System.out.println("人要學習");
}
}
public class Student extends Person {
//宣告了與父類的同名屬性
String name = "哈利波特";//姓名
int id = 9527;//學號
//構造器1
public Student(String name, int id) {
this.name = name;
this.id = id;
}
//構造器2
public Student(String name, int id, String name1, int id1) {
super(name, id);//呼叫父類已有的構造器
this.name = name1;
this.id = id1;
}
@Override//子類重寫父類的方法
public void learn() {
System.out.println("學生要努力學習");
super.learn();//調父類中原本的方法
System.out.println("姓名:"+name);//子類自己的屬性
System.out.println("學號:"+id);
System.out.println("姓名:"+super.name);//父類中宣告的屬性
System.out.println("身份證號:"+super.id);
}
}
在子類構造器2中呼叫父類已有的有參構造器:
然后測驗:實體化學生類的物件并給屬性賦值,調learn方法:
public class Test {
public static void main(String[] args) {
Student student = new Student("人",8888,"學生",2021);
student.learn();
}
}
輸出結果:
this與super的區別總結:
①代表事物不同
? this表示當前所屬函式的呼叫者物件
? super表示呼叫父類的結構(屬性,方法,構造器)
②使用前提不同
? super必須要有繼承關系才能使用
? this不需要繼承關系也能使用
③呼叫的構造器不同
? super：呼叫父類的構造器
? this：呼叫當前類(本類)的構造器
說明:
在堆疊空間中存放的是物件的參考也就是物件名指向堆空間中new的物件,在堆空間中子類和父類的屬性都會有,this和super都可以通過堆疊空間的參考指向堆空間來呼叫具體的屬性.
繼續加油~~沖沖沖! ! !
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/254926.html
標籤：java