Analisis terperinci tentang kata kunci ini dan super Java

Artikel ini membawakan anda pengetahuan yang berkaitan tentang java terutamanya isu yang berkaitan tentang ini dan kata kunci super, serta beberapa perbezaannya. Semoga ia membantu semua orang.

Pembelajaran yang disyorkan: "tutorial video java"

1. Penggunaan kata kunci "ini"

1. Gambaran Keseluruhan

• Apakah ini?

Di Jawa, kata kunci this sukar difahami Fungsinya sangat hampir dengan maksudnya, yang bermaksud "semasa".

2. Fungsi

this kata kunci boleh digunakan untuk mengubah suai dan memanggil: sifat, kaedah, pembina.
thisKata kunci hanya boleh digunakan dalam kaedah.
Ia digunakan di dalam kaedah, yang merupakan rujukan kepada objek yang mempunyai kaedah ini
Ia digunakan di dalam pembina, yang mewakili objek yang dimulakan oleh pembina.

3. Menggunakan

• Bilakah anda harus menggunakan kata kunci ini?

Apabila objek yang memanggil kaedah perlu digunakan dalam kaedah, gunakan this. Khusus: Kita boleh menggunakan this untuk membezakan atribut dan pembolehubah setempat. Contohnya: this.name = name;

3.1 Atribut dan kaedah yang diubah suai

this difahami sebagai: objek semasa atau objek yang sedang dicipta
dalam kaedah kelas , kita boleh menggunakan this.属性 atau this.方法 untuk memanggil sifat atau kaedah objek semasa. Walau bagaimanapun, biasanya, kami memilih untuk meninggalkan this.. Dalam kes khas, jika parameter formal kaedah mempunyai nama yang sama dengan atribut kelas, kita mesti menggunakan secara eksplisit this.变量 untuk menunjukkan bahawa pembolehubah ialah atribut, bukan parameter formal.
Apabila menggunakan this untuk mengakses sifat dan kaedah, jika ia tidak ditemui dalam kelas ini, ia akan dicari dari kelas induk.

Demonstrasi kod:

class Person{ // 定义Person类
    private String name ;
    private int age ;
    public Person(String name,int age){
      this.name = name ; 
      this.age = age ; }
    public void getInfo(){
      System.out.println("姓名：" + name) ;
      this.speak();
    }
    public void speak(){
      System.out.println(“年龄：” + this.age);
    } }

3.2 Memanggil pembina

Dalam pembina kelas, kita boleh menggunakan Kaedah this.属性 atau this.方法 untuk memanggil sifat atau kaedah objek yang sedang dibuat. Walau bagaimanapun, biasanya, kami memilih untuk meninggalkan this.. Dalam kes khas, jika parameter formal pembina mempunyai nama yang sama dengan sifat kelas, kita mesti menggunakan secara eksplisit this.变量 untuk menunjukkan bahawa pembolehubah ialah atribut, bukan parameter formal.

Dalam pembina kelas, kita boleh menggunakan kaedah this(形参列表) secara eksplisit untuk memanggil pembina lain yang dinyatakan dalam kelas ini. Pembina

tidak boleh memanggil pembinanya sendiri melalui kaedah this(形参列表).

Jika terdapat n pembina dalam kelas, maka boleh mempunyai paling banyak n - 1 pembina menggunakan this(形参列表)

menetapkan: this(形参列表) mesti diisytiharkan dalam baris pertama pembina semasa dalam .

Di dalam pembina, hanya boleh mengisytiharkan paling banyak satu untuk memanggil pembina lain. this(形参列表)

Kecuali pembina, pengkompil melarang memanggil pembina dalam mana-mana kaedah lain.

Demo kod:

class Person{ // 定义Person类
   private String name ;
   private int age ;
   public Person(){ // 无参构造器
     System.out.println("新对象实例化") ;
   }
   public Person(String name){
     this(); // 调用本类中的无参构造器
     this.name = name ;
   }
   public Person(String name,int age){
     this(name) ; // 调用有一个参数的构造器
     this.age = age;
   }
   public String getInfo(){
     return "姓名：" + name + "，年龄：" + age ;
   } }

3.3 Kembalikan objek semasa

Demo kod:

public class Leaf {
    int i = 0;
    Leaf increment(){
        i++;
        return this;
    }
    void print(){
        System.out.println("i = "+i);
    }
    public static void main(String args[]){
        Leaf x = new Leaf();
        x.increment().increment().increment().print();//i = 3
    }}

2. Penggunaan kata kunci "super"

1. Gambaran Keseluruhan

(1)

difahami sebagai: kelas ibu bapa super

(2) Gunakan super dalam kelas Java untuk memanggil operasi tertentu dalam kelas induk:

boleh digunakan untuk mengakses atribut super yang ditakrifkan dalam induk kelas.

boleh digunakan untuk memanggil super kaedah ahli yang ditakrifkan dalam kelas induk.
boleh digunakan untuk memanggil superpembina kelas induk dalam pembina kelas anak. Terutama apabila ahli dengan nama yang sama muncul dalam kelas anak atau ibu bapa, anda boleh menggunakan
untuk menunjukkan bahawa anda sedang memanggil ahli kelas induk Pengesanan super tidak terhad kepada langsung kelas ibu bapa. super
serupa dengan super dalam penggunaan this mewakili rujukan kepada objek kelas ini dan this mewakili pengenalpastian ruang memori kelas induk. super

2. Gunakan

untuk memanggil secara eksplisit struktur kelas induk dalam subkelas.

3.使用

3.1 调用属性和方法

我们可以在子类的方法或构造器中。通过使用"super.属性“或”super.方法“的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略”super."。

当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。

当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。

3.2 调用构造器

（1）子类中所有的构造器默认都会访问父类中空参数的构造器。

（2）当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器，否则编译出错。同时，只能”二选一”，不能同时出现，且必须放在构造器的首行。

（3）在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器。

代码演示：

public class Person {
    private String name;
    private int age;
    private Date birthDate;
    public Person(String name, int age, Date d) {
       this.name = name;
       this.age = age;
       this.birthDate = d; }
    public Person(String name, int age) {
       this(name, age, null);
    }
    public Person(String name, Date d) {
       this(name, 30, d);
    }
    public Person(String name) {
       this(name, 30);
    } }public class Student extends Person {
    private String school;
    public Student(String name, int age, String s) {
      super(name, age);
      school = s; 
    }
    public Student(String name, String s) {
      super(name);
      school = s; 
    }// 编译出错: no super(),系统将调用父类无参数的构造器。
    public Student(String s) { 
      school = s; 
    } }

三、this和super的区别

No.	区别点	this	super
1	访问属性	访问本类中的属性，如果本类没有此属性则从父类中继续查找	直接访问父类中的属性
2	调用方法	访问本类中的方法，如果本类没有此方法则从父类中继续查找	直接访问父类中的方法
3	调用构造器	调用本类构造器，必须放在构造器的首行	调用父类构造器，必须放在子类构造器的首行

四、子类对象实例化的全过程

（1）从结果上来看：（继承性）
 子类继承父类以后，就获取了父类中声明的属性或方法。
 创建子类的对象，在堆空间中，就会加载所有父类中声明的属性。

（2）从过程上来看：
当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器，…直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有父类中的结构，子类对象才可以考虑进行调用。

（3）明确：虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象。

推荐学习：《java视频教程》

Atas ialah kandungan terperinci Analisis terperinci tentang kata kunci ini dan super Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!