欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Java中this和super关键字

程序员文章站 2022-05-13 20:04:09
...

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调用父类的构造方法,是为了在创建子类对象的时候,初始化从父类继承过来的属性
相关标签: class