【Java】this 与 super 关键字

目录

this 关键字基本使用

this关键字在继承中的使用

super关键字使用

super 和 this 的比较

this 关键字基本使用

1. this 关键字可以用来访问本类的属性、方法、构造器
2. this 用于区分当前类的属性和局部变量，this代表当前对象
3. 访问成员方法的语法：this.方法名(参数列表);
4. 访问构造器语法： this( 参数列表 ); 注意 只能在构造器中访问另外一个构造器 , 必须放在第一 条语句
5. this 不能在类定义的外部使用，只能在类定义的方法中使用。

/**
 * this 基本使用
 */
public class This01 {
    public static void main(String[] args) {
        A a = new A();
        a.a1();
        a.a3();
    }
}

class A {

    String name = "龙部";

    //1.this 用于区分当前类的属性和局部变量，this代表当前对象
    public void a1() {
        String name = "狗屁";
        //name 就近原则 访问的是name = "狗屁"
        System.out.println("name=" + name);//输出 name=狗屁
        //this.name 精准定位 访问属性
        System.out.println("name=" + this.name);//输出 name=龙部
    }

    //2.访问成员方法的语法：this.方法名(参数列表);
    public void a2() {
        System.out.println("a1方法");
    }

    public void a3() {
        System.out.println("a2方法");
        a2();//第一种方法
        this.a2();//第二种方法
    }

    //3.访问构造器语法：this(参数列表);
    //注意只能在构造器中使用(即只能在构造器中访问另外一个构造器, 必须放在第一 条语句)
    public A() {
        this("少爷");//访问A(String name)的构造器
        System.out.println("A的构造器");

    }

    public A(String name) {
        System.out.println("A(String name)的构造器");
    }
    
}

/**
 * this关键字在继承中的使用
 */
public class This02 {
    public static void main(String[] args) {
        BB bb = new BB();
        bb.b2();
    }
}

class AA {

    String name = "少爷";
    int age = 20;
    String address = "12栋";
    private String hobby = "跑步";


    public void a1() {
        System.out.println("AA的 a1() 方法");
    }

    private void a2() {
        System.out.println("AA的 a2() 方法");
    }

}

class BB extends AA {

    String name = "狗屁";
    int age = 21;

    public void b1() {
        System.out.println("BB的 b1() 方法");
    }

    public void b2() {

        //访问属性的规则:
        //s1 和 this.s1 查找的规则是
        //(1) 先找本类，如果有，则调用
        //(2) 如果没有，则找父类(如果有，并可以调用，则调用)
        //(3) 如果父类没有，则继续找父类的父类,整个规则，就是一样的,直到 Object 类
        // 提示：如果查找属性的过程中，找到了，但是不能访问(private) ， 则报错, cannot access
        // 如果查找属性的过程中，没有找到，则提示属性不存在

        System.out.println(name);//输出 狗屁 本类中有name属性
        System.out.println(this.name);//输出 狗屁  本类中有name属性

        // 本类中没有address属性 去父类中查找
        System.out.println(this.address);//输出 12栋

        // 属性 private 访问权限 编译报错
        //System.out.println(this.hobby);


        //调用方法的规则:
        //因为子类 BB 没有 temp 方法，因此我可以使用下面三种方式
        //找 temp 方法时(temp() 和 this.temp())，顺序是:
        // (1)先找本类，如果有，则调用
        // (2)如果没有，则找父类(如果有，并可以调用，则调用)
        // (3)如果父类没有，则继续找父类的父类,整个规则，就是一样的，直到 Object 类 顶级父类
        // 提示：如果查找方法的过程中，找到了，但是不能访问， 则报错, cannot access
        // 如果查找方法的过程中，没有找到，则提示方法不存在
        b1();//输出 BB的 b1() 方法
        this.b1();//输出 BB的 b1() 方法

        //本类中没有a1() 方法 去父类中查找
        a1();//输出 AA的 a1() 方法
        this.a1();//输出 AA的 a1() 方法

        //方法 private 访问权限 编译报错
        //this.a2();
    }

}

super关键字使用

1. super 代表父类的引用，用于访问父类的属性、方法、构造器
2. 访问父类的属性，但不能访问父类的private属性 super.属性名；
3. 访问父类的方法，不能访问父类的private方法super.方法名(参数列表);
4. 访问父类的构造器 super(参数列表);只能放在构造器的第一句，只能出现一句!
5. 调用父类的构造器的好处(分工明确,父类属性由父类初始化，子类的属性由子类初始化)
6. 当子类中有和父类中的成员(属性和方法)重名时，为了访问父类的成员，必须通过super。如果没有重名使用super、this、直接访问是一样的效果!

/**
 * super 关键字使用
 *
 */
public class Super02 {
    public static void main(String[] args) {

        BB bb = new BB();
        bb.b1();
        bb.b2();
        bb.b3();
    }

}

class Base { //父类是 Object
    public int s5 = 999;
    public int age = 111;

    public void cal() {
        System.out.println("Base 类的 cal() 方法...");
    }

}

class AA extends Base {
    public int s1 = 100;//公开
    protected int s2 = 200;//保护
    int s3 = 300;//默认
    private int s4 = 400;//私有

    public AA() {//无参构造器
    }

    public AA(String name) {
    }

    public AA(String name, int age) {
    }

    public void test100() {//公开
        System.out.println("aa");
    }

    protected void test200() {//保护
    }

    void test300() {//默认
    }

    private void test400() {//私有
    }

    public void cal() {
        System.out.println("AA 类的 cal() 方法...");
    }

}

class BB extends AA {
    private int s1 = 888;

    //1. 访问父类的属性 , 但不能访问父类的 private 属性
    // 直接查找父类，即使本类中存在相同属性也会跳过直接查找父类
    public void b1() {
        //s1 属性本类中含有 但直接查找父类
        System.out.println(super.s1 + " " + super.s2 + " " + super.s3);
        //super.s4 访问不了 私有
    }


    //2. 访问父类的方法，不能访问父类的 private 方法 super.方法名(参数列表);
    // 直接查找父类，即使本类中存在相同方法也会跳过直接查找父类
    public void test100() {//公开
        System.out.println("bb");
    }

    public void b2() {
        super.test100();//输出 aa
        super.test200();
        super.test300();
        //super.test400();//不能访问父类 private 方法
    }


    //3. 访问父类的构造器 super(参数列表);
    //只能放在构造器的第一句，只能出现一句！
    public BB() {
        super("少爷");
        //super("龙部",22) 报错 虽然是调用不同构造器但是也只能出现一句
    }


    //4. 编写测试方法
    //super 的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用 super 去访问爷爷类的成员；
    // 如果多个基类(上级类)中都有同名的成员，使用 super 访问遵循就近原则。A->B->C
    public void b3() {
        System.out.println("super.s5=" + super.s5);
        super.cal();//输出 AA 类的 cal() 方法...
    }

    public void cal() {
        System.out.println("B 类的 cal() 方法...");
    }

}

super 和 this 的比较