this和super关键字

this和super关键字

this关键字访问普通成员

​ this.成员变量名; 先在本类中查找成员变量,如果本类中没有，则去父类中查找，直到Object类，如果依然没有找到，则编译失败。只要找到了，就不会继续向上查找。

​ this.成员方法(参数); 先在本类中查找成员方法,如果本类中没有，则去父类中查找，直到Object类，如果依然没有找到，则编译失败。

super关键字访问普通成员

​ super.成员变量名; 直接去访问父类中查找成员变量,直到Object类，如果依然没有找到，则编译失败。 super.成员方法(参数); 直接去访问父类中成员方法，直到Object类，如果依然没有找到，则编译失败。

super查找原则：父类 > .... > Object类this查找原则：本类 > 父类 > .... > Object类

什么情况会使用super调用父类的成员方法？

子类重写父类方法时，仍然需要保留父类原有功能时，就可以使用super调用父类的该方法。

this关键字调用构造方法

​ this(参数列表); 调用本类构造方法，如果本类没有，则编译失败，报错。

this关键字调用构造方法注意事项

​ 必须使用在构造方法中且必须是第一行有效语句。记住两个必须。

保证父类的相关内容会 优先于 子类对象产生

super关键字调用构造方法

​ * super(参数); 调用父类的构造方法，如果没有参数表示调用父类无参数构造方法。如果父类中没有该构造方法，则编译失败。 * 子类中的构造方法都会默认调用父类的无参数构造方法。 * 如果手动通过super调用了父类的构造方法，则默认不会再通过super()调用父类无参数构造方法了。

super关键字调用构造方法注意事项

​ * 必须使用在构造方法中且必须是第一行有效语句。 * this和super关键字调用构造方法不能同时使用。

什么时候会在子类构造方法中使用super调用父类的构造方法？

​ *当需要在构造时给父类中定义的成员变量赋值时

this和super的区别?

分别是什么呢? this代表本类对应的引用。 super代表父类存储空间的标识(可以理解为父类引用,可以操作父类的成员)

怎么用呢? A:调用成员变量 this.成员变量 调用本类的成员变量 super.成员变量 调用父类的成员变量

B:调用构造方法 this(...) 调用本类的构造方法 super(...) 调用父类的构造方法

C:调用成员方法 this.成员方法 调用本类的成员方法

​ super.成员方法 调用父类的成员方法

注意事项：

this(...)或者super(...)必须出现在第一条语句上。 如果不是放在第一条语句上，就可能对父类的数据进行了多次初始化，所以必须放在第一条语句上。

this和super关键字访问普通成员(非private)

this关键字访问普通成员 this.成员变量名;

• 先在本类中查找成员变量,如果本类中没有，则去父类中查找，直到Object类，如果依然没有找到，则编译失败。

• 只要找到了，就不会继续向上查找。

  this.成员方法(参数); 先在本类中查找成员方法,如果本类中没有，则去父类中查找，直到Object类，如果依然没有找到，则编译失败。

super关键字访问普通成员 super.成员变量名; 直接去访问父类中查找成员变量,直到Object类，如果依然没有找到，则编译失败。 super.成员方法(参数); 直接去访问父类中成员方法，直到Object类，如果依然没有找到，则编译失败。super查找原则：父类 > .... > Object类this查找原则：本类 > 父类 > .... > Object类

什么情况会使用super调用父类的成员方法？ * 子类重写父类方法时，仍然需要保留父类原有功能时，就可以使用super调用父类的该方法。

this关键字调用构造方法

* this(参数); 调用本类构造方法，如果本类没有，则编译失败，报错。

/**
 * 人类：父类
 */
public class Person{
    // 成员变量
    public String name = "jack";
    public int age;
    
    // 成员方法
    public void eat() {
        System.out.println("吃饭");
    }
    public void sleep() {
        System.out.println("睡觉");
    }
}
/**
 * 学生类：继承Person类，是Person类的子类
 */
public class Student extends Person{
    public String name = "rose";
    
    public void eat() {
        // 调用父类的eat方法保留父类原有功能的实现
        super.eat();
        System.out.println("Student类的eat方法");
    }
    
    public void show() {
        this.eat();
        String name = "lucy";
        System.out.println("我的名字：" + name);
        
        //   this.成员方法 调用本类的成员方法
        System.out.println("我的名字：" + this.name);
        
        //super.成员方法 调用父类的成员方法
        System.out.println("我的名字：" + super.name);
    }
}
​
public class Demo01 {
    public static void main(String[] args) {
        // 创建学生对象
        Student stu = new Student();
        // 调用show方法
        stu.show();
    }
}   

this和super访问构造方法

this关键字调用构造方法注意事项 * 必须使用在构造方法中且必须是第一行有效语句。

super关键字调用构造方法 * super(参数); 调用父类的构造方法，如果没有参数表示调用父类无参数构造方法。如果父类中没有该构造方法，则编译失败。 * 子类中的构造方法都会默认调用父类的无参数构造方法。 * 如果手动通过super调用了父类的构造方法，则默认不会再通过super()调用父类无参数构造方法了。

super关键字调用构造方法注意事项 * 必须使用在构造方法中且必须是第一行有效语句。 * this和super关键字调用构造方法不能同时使用。

什么时候会在子类构造方法中使用super调用父类的构造方法？

* 在构造方法中当需要给父类中定义的成员变量赋值时

/**
 * 老师类
 * 
 *
 */
public class Teacher {
    private String name;
    private int age;
    private String gender;
    
    public Teacher(String name, int age) {
        System.out.println("两个参数的构造方法");
        this.name = name;
        this.age = age;
    }
    public Teacher(String name, int age, String gender) {
        /*
        this.name = name;
        this.age = age;
        */
        
        //调用本类构造方法
        this(name,age);
        System.out.println("三个参数的构造方法");
        this.gender = gender;
    }
    
    public Teacher() {
        System.out.println("无参数构造方法");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
}
/**
 * 员工类
 * 
 *
 */
public class Employee {
    private String name;
    private int age;
    
    public Employee() {
        System.out.println("父类无参数构造");
    }
    
    public Employee(String name, int age) {
        System.out.println("父类两个参数的构造方法");
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}   
​
/**
 * 工人类:继承Employee
 * 
 */
public class Worker extends Employee {
    // 特有成员变量
    private String gender;
​
    // 构造方法
    public Worker() {
        super(); // 调用父类的无参数构造方法
        System.out.println("子类无参数");
    }
    public Worker(String name, int age) {
        super(name, age); 
        /*this.setName(name);
        this.setAge(age);*/
        System.out.println("子类两个参数的构造方法");
    }
​
    public Worker(String gender) {
        // this("张三",23);
        this.gender = gender;
    }
​
    public String getGender() {
        return gender;
    }
​
    public void setGender(String gender) {
        this.gender = gender;
    }
    
    // 显示信息
    public void show() {
        System.out.println("姓名：" + this.getName());
        System.out.println("年龄：" + this.getAge());
        System.out.println("性别：" + this.gender);
    }
}
​
/** 测试类 */
public class Demo02 {
    public static void main(String[] args) {
        // 创建老师对象
        Teacher t = new Teacher("老王", 25,"男");
        System.out.println(t.getName()+"="+t.getAge());
        
        // 创建工人对象
        Worker w = new Worker("李四",24);
        // 调用show方法
        w.show();
    }
}