Java中this和super关键字

this和super关键字的介绍

• this：存储的“当前对象”的引用；
  • this可以访问：本类的成员属性、成员方法、构造方法；
• super：存储的“父类对象”的引用；
  • super可以访问：父类的成员属性、成员方法、构造方法；

this关键字的三种用法

• this访问本类成员变量: this.成员变量

public class Student{
    String name = "张三";
    public void show(){
        String name = "李四";
        System.out.println("name = " + name);// 李四
        System.out.println("name = " + this.name);// 张三
    }
}

• this访问本类成员方法: this.成员方法名()

public class Student{
    public void show(){
        System.out.println("show方法...");
        this.eat();
    }
    public void eat(){
        System.out.println("eat方法...");
    }
}

• this访问本类构造方法: this()可以在本类的一个构造方法中，调用另一个构造方法

public class Student{
    public Student(){
        System.out.println("空参构造方法...");
    }

    public Student(String name) {
        this();//当使用this()调用另一个构造方法时，此代码必须是此构造方法的第一句有效代码。
        System.out.println("有参构造方法...");
    }
}
public class Demo {
    public static void main(String[] args) {
        Student stu2 = new Student();
    }
}

super关键字的三种用法

• super访问父类的成员变量: super.父类成员变量名

class Fu{
    int num = 100;
}

class Zi extends Fu{
    int num = 10;

    public void show(){
        int num = 1;
        System.out.println("局部变量num:"+num);// 1
        System.out.println("Zi 类中的num:"+this.num);// 10
        System.out.println("Fu 类中的num:"+super.num);// 100

      }
}

• super访问父类的成员方法: super.成员方法名();

class Fu{
    public void method1(){
        System.out.println("Fu method1...");
    }
}

class Zi extends Fu{
    public void show(){
        // 访问父类的method1方法
        super.method1();
    }

    @Override
    public void method1(){
        super.method1();// 调用父类的method1方法
        System.out.println("Zi method1...");
    }
}

• super访问父类的构造方法: super()

public class Fu{
    public Fu(){
        System.out.println("Fu 类的空参构造方法..");
    }
    public Fu(String name, int age) {
        System.out.println("Fu 类的有参构造方法..");
    }
}
public class Zi extends Fu{
    public Zi(){
        super();// 调用父类的空参构造方法
        System.out.println("Zi 类的空参构造方法..");
    }
    public Zi(String name,int age){
        super(name,age);// 调用父类的有参构造方法
         System.out.println("Zi 类的有参构造方法..");
    }
}
public class Demo {
    public static void main(String[] args) {
        Zi zi = new Zi();
        System.out.println("----------------------");
        Zi z2 = new Zi("刘德华", 17);
    }
}

小结

this关键字的三种用法:
   this可以访问本类的成员变量: this.成员变量         一般用来区分同名的成员变量和局部变量
   this可以访问本类的成员访问: this.成员方法名(实参);
   this可以访问本类的构造方法:
        空参构造: this();
        有参构造: this(实参);
            注意:
                 1.只能在本类的构造方法中使用this调用其他构造方法
                 2.在本类的构造方法中使用this调用其他构造方法,必须放在该构造方法的第一行,否则会报错
                 3.两个构造方法不能使用this相互调用

super关键字的三种用法:
     super可以访问父类的成员变量: super.成员变量         一般用来区分父子类中同名的成员变量
     super可以访问父类的成员方法: super.成员方法(实参);   一般用来在子类中访问父类的成员方法
     super可以访问父类的构造方法:
          空参构造: super();
          有参构造: super(实参);
           注意:
                 1.子类的构造方法默认会调用父类的空参构造方法
                 2.super访问父类的构造方法,可以用来初始化从父类继承过来的属性
                 3.在子类的构造方法中,使用super调用父类的构造方法,必须放在子类构造方法的第一行

super的注意事项一

- super访问成员变量和成员方法: 优先去父类中找,如果有就直接使用,如果没有就去爷爷类中找,如果有,就用,依次类推...

  ```java
  class Ye{
      int num = 10;
      public void method(){
          System.out.println("Ye method");
      }
  }
  class Fu extends Ye{
      int num = 100;
      public void method(){
          System.out.println("Fu method");
      }
  }
  class Zi extends Fu{
      int num = 1000;
      public void show(){
          System.out.println(super.num);
          super.method();
      }
  }
  
  public class Test {
      public static void main(String[] args) {
  
          Zi zi = new Zi();
          zi.show();
      }
  }

super的注意事项二

• 子类的构造方法默认会调用父类的空参构造方法,如果父类中的没有空参构造方法,只定义了有参构造方法,会编译报错

class Fu1{
    public Fu1(){
        System.out.println("Fu1 空参构造");
    }

    public Fu1(int num){
        System.out.println("Fu1 有参构造");
    }
}

class Zi1 extends Fu1{
    public Zi1(){
        // super();
    }

    public Zi1(int num){
        // super();
    }
}

// 问题: super调用父类的构造方法有什么用?
class Person{
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void show(){
        System.out.println(name+","+age);
    }
}

class Student extends Person{
    public Student(String name,int age){
       super(name,age);
    }
}

public class Test2 {
    public static void main(String[] args) {
        /*
            super的注意事项二
              1.子类的构造方法默认会调用父类的空参构造方法
              2.如果父类中的没有空参构造方法,只定义了有参构造方法,会编译报错
            问题: super调用父类的构造方法有什么用?
            结果: 为了在创建子类对象的时候,初始化从父类继承过来的属性
         */
        // 通过调用子类的空参构造方法,创建子类对象
        // Zi1 zi = new Zi1();

        // 通过调用子类的有参构造方法,创建子类对象
        //Zi1 zi = new Zi1(100);

        // 创建Student类的对象
        Student stu = new Student("张三", 18);
        stu.show();

    }
}

小结

• super访问成员变量和成员方法: 优先去父类中找,如果有就直接使用,如果没有就去爷爷类中找,如果有,就用,依次类推…
• 子类的构造方法默认会调用父类的空参构造方法,如果父类中的没有空参构造方法,只定义了有参构造方法,会编译报错
• 子类构造方法中使用super调用父类的构造方法,是为了在创建子类对象的时候,初始化从父类继承过来的属性