this和super详解

this和super详解

1.this

java中的this关键字：

• this是一个关键字，翻译为：这个
• this 是一个引用，this是一个变量，this变量中保存的是指向本身对象的内存地址，this村住在JVM堆内存的对象中。
• 一个对象一个this；100个对象有100个不同的this。
• this可以出现在”实例方法“中，this指向当前正在执行这个动作的对象。（有对象参与的要定义为实例方法）
• 大多数this可以省略。
• static的方法调用不需要对象，所以不能使用this，不能调用实例方法和实例变量。
• 实例方法可以调用实例方法，可以使用this（this可以省略）。
• 用来区分局部变量和实例变量的时候，this不能省略

this可以使用在哪里：

1. 能够使用在实例方法当中，代表当前对象（语法格式：this.）
2. 能够使用在构造方法中，通过当前的构造方法调用其它的构造方法（this(实参)），this()只能出现在第一行。

代码如下：

public class Thisuse {

    String name;
    static int date = 20220416;

    public Thisuse() {
        this("黎明");//这里是调用有参构造方法构建，但是必须在第一行
    }

    public Thisuse(String name) {
        this.name = name; //这里的this不能省略，因为就近原则
    }

    public static void happy(){
        System.out.println(date+"很快乐");//能够使用静态变量和静态方法。
        //System.out.println(this.name+"很快乐");不能够使用this
    }

    public void run(){
        System.out.println(this.name+"在跑步");//能够使用this，也可以省略
        happy();//也可以调用静态变量和方法
    }

}

一个需要注意的点是：静态方法也可以通过对象引出，格式：对象.方法，但是不建议使用。当对象为null的时候，调用实例方法和实例变量会出现空指针异常，但是调用静态方法是可以的。

2.super

super与this对比：

this：

1. this能够出现在实例方法和构造方法中。
2. this的语法为：（this.）和（this()）。
3. this不能够出现在静态方法中。
4. this.在大部分情况下是可以省略的
5. 当区分局部变量和实例变量的时候，this.是不能省略的。
6. this()或this(实参)只能出现在构造方法的第一行，通过当前走早方法区调用“本类”中的其他构造方法，目的是代码复用。

super：

1. super能够出现在实例方法和构造方法中。
2. super的语法为：（super.）和（super()）。
3. super不能够出现在静态方法中。
4. super.在大部分情况下是可以省略的
5. 当区分局部变量和实例变量的时候，super.是不能省略的。
6. super()或super(实参)只能出现在构造方法的第一行，通过当前走早方法区调用“父类”中的其他构造方法，目的是：创建子类对象的时候，先初始化父类特征。

public class Super {
    public static void main(String[] args) {
        new Son();
    }
}
class Father{
    public Father(){
        System.out.println("父类无参构造");
    }
    public Father(int i){
        System.out.println("父类有参构造");
    }
}
class Son extends Father{
    public Son(){
        //super();
        System.out.println("子类无参构造");
    }
}

结果显示：

父类无参构造

子类无参构造

解释：此时super()调用的是父类的无参构造方法

``

public class Super {
    public static void main(String[] args) {
        new Son();
    }
}
class Father{
    public Father(){
        System.out.println("父类无参构造");
    }
    public Father(int i){
        System.out.println("父类有参构造");
    }
}
class Son extends Father{
    public Son(){
        super(100);
        System.out.println("子类无参构造");
    }
}

结果显示：

父类有参构造

子类无参构造

解释：此时super(100)调用的是父类的有参构造方法。

结论：

• super()表示通过子类的构造方法调用父类的构造方法。子类的构造是首先构造其父类。
• 当子类既没有this()又没有super()时，会默认有一个super()；表示通过当前的子类调用父类的无参构造方法。因此，以防止子类调用失败，我们要创建类的时候要创建无参数构造方法。
• 因为this()和super()都需要在第一行，所以两者不能同时存在。

super(实参)的使用

super(实参)能够使得子类访问父类的私有属性。（子类继承的父类，父类的私有属性也被继承了下来，只是由于private的原因，私有属性不能访问，而使用super()则能够进行访问。）

作用：初始化当前对象的父类特征。

代码如下：

class Dad{
    private int dadMoney;
    public Dad() {
    }
    public Dad(int dadMoney) {
        this.dadMoney = dadMoney;
    }
}
class Baby extends Dad{
    int babyMoney;
    public Baby(){
    }
    public Baby(int dadMoney,int babyMoney){
       //this.dadMoney = dadMoney;//这样写是不对的，私有变量只能在本类中使用。（this）
       //super.dadMoney = dadMoney;//这样写，因为父类的是私有的所以不能调用
       super(dadMoney);
       this.babyMoney=babyMoney;
    }
}

再看下面的代码：

public class Super3 {
    public static void main(String[] args) {
        B b = new B("张三");
        b.shopping();
    }
}
class A{
    String name;
    public A() {
    }
    public A(String name) {
        this.name = name;
    }
}
class B extends A{
    public B(){}
    public B(String name){
        super(name);
    }
    public void shopping(){
        System.out.println(this.name+"正在购物");
        System.out.println(super.name+"正在购物");
        System.out.println(name+"正在购物");
    }
}

以上结果：

张三正在购物
张三正在购物
张三正在购物

解释：整个对象创建，尽管继承了父类特征，但是并没有创建父类。整个过程只创建了一个子类对象。this指的是对象B，其中B也包括父类特征name，那么super.知道的name与this.的是一个。

super.不能省略的情况

当子类中出现与父类变量（方法）同名的情况，不能省略。

``

public class Super3 {
    public static void main(String[] args) {
        B b = new B("张三");
        b.shopping();
    }
}
class A{
    String name;
    public A() {
    }
    public A(String name) {
        this.name = name;
    }
}
class B extends A{
    String name;
    public B(){}
    public B(String name){
        super(name);
    }
    public void shopping(){
        System.out.println(this.name+"正在购物");//访问的子对象的name属性
        System.out.println(super.name+"正在购物");//访问的父类的name属性
        System.out.println(name+"正在购物");//访问的子对象的name属性
    }
}

结果显示：

null正在购物
张三正在购物
null正在购物

super不能单独使用

this可以单独使用代表自身，进行输出。super不行，不能够单独输出。

这是因为：super不是引用，也不保存内存地址，也不指向任何对象。它只代表当前对象内部的那一块父类型的特征。