this和super在类中的成员变量访问中起到了很重要的作用。this和super都有两种用法，这里先解释this 的用法。

this语句【this.()】

this语句只能在构造方法中使用，且必须放在构造方法中的首行，this语句的作用是直接为成员变量赋值。

this关键字

this关键字用来访问成员变量，同时也可以用于区别成员方法中定义的与成员变量同名的局部变量

下面看一下示例：

  1. package com.bxw.demo.demo04;
  3. public class this语句与关键字 {
  4.     public static void main(String[] args) {
  5.         Test test = new Test();
  6.         // 获取初始化赋值
  7.         System.out.println("name:" + test.getName() + " age:" + test.getAge());
  8.     }
  9. }
  10. // 创建一个类
  11. class Test{
  12.     private String name;
  13.     private int age;
  15.     public Test() {
  16.         // 使用this语句为成员变量初始化赋值
  17.         this("jack",23);
  18.     }
  19.     public Test(String name, int age){
  20.         this.name = name; // 这就是this关键字，用于直接访问成员变量，同时区分成员变量与局部变量
  21.         this.age = age;
  22.     }
  24.     public String getName() {
  25.         return name;
  26.     }
  28.     public void setName(String name) {
  29.         this.name = name;
  30.     }
  32.     public int getAge() {
  33.         return age;
  34.     }
  36.     public void setAge(int age) {
  37.         this.age = age;
  38.     }
  39. }

super语句【super()】

super语句用于子类为父类初始化赋值，这里需要提前涉及到继承的知识，也就是super语句是针对父类的成员变量。同样的super语句也只能在子类的构造方法的首行，且只能出现一次。这里还需要注意的是，super语句和this语句都必须出现在构造方法的首行，因此两个语句只能二选一。

super关键字

同样的，super关键字也是用于访问父类的成员变量，且只能在子类的成员方法中使用。

下面看一个示例：

  1. package com.bxw.demo.demo04;
  3. public class super语句与关键字 {
  4.     public static void main(String[] args) {
  5.         new Zi().get();
  6.     }
  7. }
  8. // 创建父类
  9. class Fu {
  10.     private String name;
  11.     private int age;
  12.     public Fu() {
  13.     }
  14.     public Fu(String name, int age) {
  15.         this.name = name;
  16.         this.age = age;
  17.     }
  18.     public String getName() {
  19.         return name;
  20.     }
  21.     public void setName(String name) {
  22.         this.name = name;
  23.     }
  24.     public int getAge() {
  25.         return age;
  26.     }
  27.     public void setAge(int age) {
  28.         this.age = age;
  29.     }
  30. }
  32. // 创建子类
  33. class Zi extends Fu{
  34.     private int id;
  35.     public Zi() {
  36.         super("jack",34);
  37.     }
  38.     public Zi(String name, int age, int id) {
  39.         super(name, age); // 这里就是super语句的体现，不过这个我们不用，我用可以只用空参构造来演示
  40.         this.id = id;
  41.     }
  42.     // 创建一个方法，用户获取父类初始化后的成员变量的值
  43.     public void get(){
  44.         System.out.println("父类中的name:" + super.getName() + "父类中的age:" + super.getAge());
  45.         // 这里需要解释解释一下，this关键字可以直接访问本类中的成员变量，无论是私有还是公共的。
  46.         // 但是子类访问父类的成员变量，如果父类中的成员变量是私有的，那么只能通过啊super关键字
  47.         // 通过super关键字调用父类中的公共访问方式，从而来访问父类中的成员变量
  48.     }
  50. }