This关键字和Super关键字

this关键字：

1、this调用本类的属性：

• this.属性名，表示调用本类中属性。当参数与类中属性同名时，类中属性无法被正确赋值。

  所以只要在类中方法访问类中属性，应该加上this关键字

2、this调用本类方法：

1）调用本类普通方法：this.方法名字（方法参数）;

class Person {
    private String name;
    private String school;

    public Person(String name, String school) {
        this.name = name;
        this.school = school;
        //调用本类中的普通方法
        this.print();
    }

    public void print() {
        System.out.println("普通方法");
    }
}

2）this调用本类构造方法：构造方法可以互相调用，但是不可以成环，并且必须位于构造方法代码的首行。

• 调用有参构造this(参数)；
• 调用无参构造 this();

  class A {
      public A() {
          System.out.println("无参构造");
      }
      public A(String string) {
          this();
          System.out.println("有参构造，参数类型为:"+string);
      }
      public A(int n) {
          this("String");
          System.out.println("有参构造，构造参数为整形");
      }
  }
  //运行结果：
  无参构造
  有参构造，参数类型为:String
  有参构造，构造参数为整形

3、 this表示当前对象。

public class Test {
    public static void main(String[] args) {
        B b = new B();
        b.print();
    }
}
class B {
    public void print() {
        System.out.println(this);
    }
}
//运行结果： www.exercises.Test4_4.B@2133c8f8

---

super关键字：需要有继承的存在

1、super调用父类构造方法（非private）。必须位于首行

• 当调用父类的无参构造时，系统会自动在子类的无参构造前加上super（）；表示先调用父类的无参构造方法。super语句可以省略，此时子类可以使用this调用构造方法。

  public class Test4_4 {
      public static void main(String[] args) {
          new D("str");
      }
  }
  
  class C {
      public C () {
          System.out.println("我是父类无参构造方法");
      }
  }
  
  class D extends C {  //因为父类存在无参构造，所以super()； 可以省略不写，但是会默认调用。
      public D () {
          System.out.println("我是子类无参构造方法");
      }
      public D(String str) {
          this();
          System.out.println("我是子类有参构造方法");
      }
  
  }
  //运行结果：
  我是父类无参构造方法
  我是子类无参构造方法
  我是子类有参构造方法

   

• 当父类不存在无参构造时，必须在子类构造方法中使用super（参数）；明确指定调用父类的哪个有参构造。此时super语句不能省略。

• 如果子类的构造方法调用了父类的构造方法，就不能再调用本类中其他的构造方法，因为调用本类构造方法和调用父类构造方法都必须位于首行，同时调用会冲突。

class C {
    public C (int n) {
        System.out.println("我是父类无参构造方法");
    }
}

class D extends C {
    public D () {
        super(1); //此时super调用父类构造方法不可以省略不写，并且必须位于构造方法的首行
        System.out.println("我是子类无参构造方法");
    }
}

2、super调用父类属性（非private）

class E {
    public String name;
    public int age;

    public E(String name) {
        this.name = name;
    }
}

class F extends E {
    public F () {
        super("小黑"); //父类没有无参构造，所以必须调用父类有参构造
        System.out.println("父类的name是:"+super.name);
        super.age = 20;   //直接调用父类非private属性
        System.out.println("父类的age是："+super.age);
    }
}

public class Test {
    public static void main(String[] args) {
        new F();
    }
}

运行结果：
父类的name是:小黑
父类的age是：20