this和super

news2024/11/24 14:42:53

文章目录

this
- 用法
- - 普通的直接引用
  - 区分形参与实参
super
- 用法
- - 普通的直接引用
  - 区分子类与父类同名的属性或方法
this和super 与构造方法
总结

this

this引用表示当前对象对象的引用。

用法

普通的直接引用

public class Test {
    int a ;
    int b;
    public Test() {
        this.b = 0;
    }
}

调用当前类的成员变量

区分形参与实参

class Student {
    private String name = "用户为指定";

    public Student() {
        System.out.println("姓名：" + name);
    }

    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return this.name;
    }
}

public class test1 {
    public static void main(String[] args) {
        Student Stu = new Student();
        Stu.setName("张三");
        System.out.println("Stu's name is " + Stu.getName());
    }
}

运行结果：

姓名：用户为指定
Stu's name is 张三

name是构造方法的形参，this.name 是成员遍历

super

super可以理解为是指向自己父类对象的一个引用。

用法

普通的直接引用

class A {
    int a;

    public A(int a) {
        this.a = a;
    }
}
class B extends  A {
    int b ;

    public B(int a,int b) {
        super(a);
        this.b = b;
    }
}

public class Test {
    public static void main(String[] args) {
        B Ob = new B(1,2);
        System.out.println(Ob.a + " " + Ob.b);
    }
}

运行结果：

1 2

区分子类与父类同名的属性或方法

class Parent {
    String name;

    void name() {
        name = "Dad";
    }
}

class Son extends Parent {
    String name;

    // 重写父类的方法
    @Override
    void name() {
        name = "Son";
        super.name(); //调用父类的方法
        System.out.println(name);
        System.out.println(super.name);
    }

    public static void main(String[] args) {
        Son c = new Son();
        c.name();
    }
}

运行结果：

Son
Dad

既调用了父类的方法，也调用了父类的变量。若不调用父类方法name()，只调用父类变量name的话，则父类name值为默认值null。

this和super 与构造方法

super() 调用父类中的某一个构造函数（应该为构造函数中的第一条语句）
this() 调用本类中另一种形式的构造函数（应该为构造函数中的第一条语句）
this() 和 super() 在一个构造方法中不能同时存在

class Person {
    public static void prt(String s) {
        System.out.println(s);
    }

    Person() {
        prt("父类·无参数构造方法： " + "A Person.");
    }//构造方法(1) 

    Person(String name) {
        prt("父类·含一个参数的构造方法： " + "A person's name is " + name);
    }//构造方法(2) 
}

public class Chinese extends Person {
    Chinese() {
        super(); // 调用父类构造方法（1） 
        prt("子类·调用父类”无参数构造方法“： " + "A chinese coder.");
    }

    Chinese(String name) {
        super(name);// 调用父类具有相同形参的构造方法（2） 
        prt("子类·调用父类”含一个参数的构造方法“： " + "his name is " + name);
    }

    Chinese(String name, int age) {
        this(name);// 调用具有相同形参的构造方法（3） 
        prt("子类：调用子类具有相同形参的构造方法：his age is " + age);
    }

    public static void main(String[] args) {
        Chinese cn = new Chinese();
        cn = new Chinese("codersai");
        cn = new Chinese("codersai", 18);
    }
}

运行结果：

父类·无参数构造方法： A Person.
子类·调用父类”无参数构造方法“： A chinese coder.
父类·含一个参数的构造方法： A person's name is codersai
子类·调用父类”含一个参数的构造方法“： his name is codersai
父类·含一个参数的构造方法： A person's name is codersai
子类·调用父类”含一个参数的构造方法“： his name is codersai
子类：调用子类具有相同形参的构造方法：his age is 18