Java学习笔记-基础day-6-this和super关键字详解

1、this和super关键字的介绍

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

2、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()可以在本类的一个构造方法中，调用另一个构造方法

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

3、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 method(){
          System.out.println("父类 method");
      }
  }
  
  class Zi extends Fu{
      
      public void show(){
          // 访问父类的method方法
          super.method();
      }
  
      @Override
      public void method(){
          super.method();// 调用父类的method方法
          System.out.println("子类 method");
      }
  }
  

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

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

小结

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调用父类的构造方法,必须放在子类构造方法的第一行

4、super的注意事项

super的注意事项一

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

  class Ye{
      int num = 10;
      public void method(){
          System.out.println("爷类 method");
      }
  }
  
  class Fu extends Ye{
      //此处无num，去Ye类找
      public void method(){
          System.out.println("父类 method");
      }
  }
  
  class Zi extends Fu{
      int num = 1000;
      public void show(){
          System.out.println(super.num);//10
          super.method();//父类 method
      }
  }
  
  public class Test {
      public static void main(String[] args) {
          Zi zi = new Zi();
          zi.show();
      }
  }
  

super的注意事项二

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

  class Fu{
      public Fu(){
          System.out.println("父类空参构造");
      }
  
      public Fu(int num){
          System.out.println("父类有参构造");
      }
  }
  
  class Zi extends Fu{
      public Zi1(){
          // super();默认调用
      }
  
      public Zi1(int num){
          // super();默认调用
      }
  }
  

  super的注意事项三

  
  // 问题: super调用父类的构造方法有什么用?
  
  class Person{
      private String name;
      private int age;
  
      public Person(String name, int age) {
          this.name = name;
          this.age = age;
      }
  }
  
  class Student extends Person{
      //此处继承了name和age属性，但是无法使用this.属性进行初始化
      public Student(String name,int age){
         super(name,age);
      }
  }
  
  public class Test {
      public static void main(String[] args) {
          /*
              问题: super调用父类的构造方法有什么用?
              结果: 为了在创建子类对象的时候,初始化从父类继承过来的属性
           */
  
          // 创建Student类的对象
          Student stu = new Student("张三", 18);
          stu.show();
      }
  }
  

小结

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