java关键字this和关键字super的总结

java关键字this的总结

this是对象内部指代自身的引用,同时也是解决成员变量和局部变量同名问题；
this可以调用成员变量，不能调用局部变量；
this也可以调用成员方法，但是在普通方法中可以省略this，在构造方法中不允许省略，必须是构造方法的第一条语句。

而且在静态方法当中不允许出现this关键字。

对象创建的过程和this的本质

构造方法是创建Java对象的重要途径，通过new关键字调用构造器时，构造器也确实返回该类的对象，但这个对象并不是完全由构造器负责创建。创建一个对象分为如下四步：

   1. 分配对象空间，并将对象成员变量初始化为0或空

　　2. 执行属性值的显示初始化

　　3. 执行构造方法

　　4. 返回对象的地址给相关的变量

this的本质就是“创建好的对象的地址”! 由于在构造方法调用前，对象已经创建。因此，在构造方法中也可以使用this代表“当前对象” 。

this最常的用法：

  　1.  在程序中产生二义性之处，应使用this来指明当前对象;普通方法中，this总是指向调用该方法的对象。构造方法中，this总是指向正要初始化的对象。

　　2. 使用this关键字调用重载的构造方法，避免相同的初始化代码。但只能在构造方法中用，并且必须位于构造方法的第一句。

　　3. this不能用于static方法中。

this关键字使用练习：

this代表当前“对象”示例

//this关键字练习
public class ThisTest01 {
    //定义三个私有属性
    private int id;
    private  String name;
    private  String address;
    //无参构造
    public ThisTest01() {

    }
    //有参构造
    public ThisTest01(int id, String name, String address) {
        //初始化
        System.out.println("正在初始化已经创建好的对象： "+this);
        this.id = id;
        this.name = name;
        this.address = address;
    }
    public void check(){
        System.out.println("学号："+id+"姓名"+name+"家庭住址"+address);
        //不写this效果一样
        System.out.println("=============================");
        System.out.println("学号："+this.id+"姓名"+this.name+"家庭住址"+this.address);

    }
    //主函数入口
    public static void main(String[] args) {
        //实例化对象方式一
        ThisTest01 stu01 = new ThisTest01(  2020  ,"  WanWan  ","  云南昆明");
        //对象访问方法
        System.out.println("打印学生基本信息："+stu01);
        stu01.check();
        System.out.println("============stu02==============");
        //实例化对象方式二
        ThisTest01 stu02 = new ThisTest01();
        stu02.id=2019;
        stu02.name="晚风花间寺中人";
        stu02.address="CSND博客";
        System.out.println("打印学生基本信息："+stu02);
        stu02.check();
    }
}

运行结果：

定义的对象，直接输出就是输出地址，

System.out.println("正在初始化已经创建好的对象： "+this);

System.out.println("打印学生基本信息："+stu01);

正在初始化已经创建好的对象： ThisTest01@506e1b77

可以理解为：stu01=this

同理：

System.out.println("打印学生基本信息："+stu02);

打印学生基本信息：ThisTest01@37a71e93

正在初始化已经创建好的对象： ThisTest01@506e1b77
打印学生基本信息：ThisTest01@506e1b77
学号：2020姓名  WanWan  家庭住址  云南昆明
=============================
学号：2020姓名  WanWan  家庭住址  云南昆明
============stu02==============
打印学生基本信息：ThisTest01@37a71e93
学号：2019姓名晚风花间寺中人家庭住址CSND博客
=============================
学号：2019姓名晚风花间寺中人家庭住址CSND博客

this()调用重载构造方法

//this关键字练习
public class ThisTest02 {
    int a,b,c;  //成员变量
    //无参构造
    public ThisTest02() {
        System.out.println("这是无参构造器");
    }
    //有参构造
    //重载构造方法
    public ThisTest02(int a, int b) {   //局部变量

        //错误1示范：Method call expected
        //ThisTest02(); //这是无法调用构造方法的

        this(); //调用无参的构造方法，并且必须位于第一行！   Call to 'this()' must be first statement in constructor body
        this.a = a;
        this.b = b;
        System.out.println("这是被调用的构造器");
    }

    public ThisTest02(int a, int b, int c) {
        // 调用带参的构造方法，并且必须位于第一行！
        this(a,b);
//        this.a = a;
//        this.b = b;
        this.c = c;
        System.out.println("这是调用的构造器");
    }
    //定义一个方法
    void show(){
        System.out.println("糟糕！我被别的构造器调用了");
    }
    void study(){
        //在构造器中调用别的构造器，两者效果相同
        this.show();
        show();
        System.out.println("这个假期，你学习java了吗");
    }
    //主函数入口
    public static void main(String[] args) {
        //以下三种初始化方式研究this()调用重载构造方法
        //ThisTest02 stu = new ThisTest02();
        //ThisTest02 stu = new ThisTest02(2,3);
        ThisTest02 stu = new ThisTest02(2,3,4);
        System.out.println(stu);
        stu.study();
    }
}

运行结果：

这是无参构造器
这是被调用的构造器
这是调用的构造器
ThisTest02@b4c966a
糟糕！我被别的构造器调用了
糟糕！我被别的构造器调用了
这个假期，你学习java了吗

super关键字

super是直接父类对象的引用。可以通过super来访问父类中被子类覆盖的方法或属性。

  使用super调用普通方法，语句没有位置限制，可以在子类中随便调用。

  若是构造方法的第一行代码没有显式的调用super(...)或者this(...);那么Java默认都会调用super(),含义是调用父类的无参数构造方法。这里的super()可以省略。

super关键字练习：

public class TestSuper01 {
    public static void main(String[] args) {
        new ChildClass().f();
    }
}
class FatherClass {
    public int value;
    public void f(){
        value = 100;
        System.out.println ("FatherClass.value="+value);
    }
}
class ChildClass extends FatherClass {
    public int value;
    public void f() {
        super.f();  //调用父类对象的普通方法
        value = 200;
        System.out.println("ChildClass.value="+value);
        System.out.println(value);
        System.out.println(super.value); //调用父类对象的成员变量
    }
}

运行结果：

FatherClass.value=100
ChildClass.value=200
200
100

推荐优质博文：https://www.cnblogs.com/xdp-gacl/p/3636071.html