this和super的用法

this的用法

1.this可以用来修饰、调用：属性、方法、构造器

    2.this修饰属性和方法：
      this理解为：当前对象  或 当前正在创建的对象

     2.1  在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是，
          通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式
          的使用"this.变量"的方式，表明此变量是属性，而非形参。

     2.2 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。
         但是，通常情况下，我们都选择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式
         的使用"this.变量"的方式，表明此变量是属性，而非形参。

    3. this调用构造器
      ① 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器
      ② 构造器中不能通过"this(形参列表)"方式调用自己
      ③ 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)"
      ④ 规定："this(形参列表)"必须声明在当前构造器的首行
      ⑤ 构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器

           实例：
 public class PersonTest {
public static void main(String[] args) {
	
	Person p1 = new Person();
	
	p1.setAge(1);
	System.out.println(p1.getAge());
	
	p1.eat();
	
	System.out.println();
	
	Person p2 = new Person("Jerry",20);
	System.out.println(p2.getAge());
	
}

}

class Person{

private String name;
private int age;


public Person(){

// this.eat();
String info = "Person初始化时，需要考虑如下的1,2,3,4...(共40行代码)";
System.out.println(info);
}

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

public Person(int age){
	this();
	this.age = age;
	
}

public Person(String name,int age){
	this(age);
	this.name = name;
	//this.age = age;
	//Person初始化时，需要考虑如下的1,2,3,4...(共40行代码)
}

public void setName(String name){
	this.name = name;
}
public String getName(){
	return this.name;
}
public void setAge(int age){
	this.age = age;
}
public int getAge(){
	return this.age;
}

public void eat(){
	System.out.println("人吃饭");
	this.study();
}
public void study(){
	System.out.println("人学习");
}

}

super的用法

* super的理解：super 可以理解为是指向自己超(父)类对象的一个指针，而这个超类指的是离自己最近的一个父类
        * super的用法：调用属性和方法
                 1. 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用
                    父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
                 2. 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的
                    使用"super.属性"的方式，表明调用的是父类中声明的属性。
                 3. 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的
                    使用"super.方法"的方式，表明调用的是父类中被重写的方法。

                    实例：
                           class Country {
                              String name;
                              void value() {
                                 name = "China";
                              }
                            }

                          class City extends Country {
                              String name;
                              void value() {
                                    name = "Shanghai";
                                    super.value();      //调用父类的方法
                                    System.out.println(name);
                                    System.out.println(super.name);
                              }

                              public static void main(String[] args) {
                                 City c=new City();
                                 c.value();
                                 }
                          } 
                          运行结果：
                                Shanghai
                                China
                          可以看到：这里既调用了父类的方法，也调用了父类的变量。若不调用父类方法 value()，
                                   只调用父类变量 name 的话，则父类 name 值为默认值 null。
              3.引用构造方法：
                          1. 我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
                          2. "super(形参列表)"的使用，必须声明在子类构造器的首行！
                          3. 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现
                          4. 在构造器的首行，没有显式的声明"this(形参列表)"或"super(形参列表)"，则默认调用的是父类中空参的构造器：super()
                          5. 在类的多个构造器中，至少有一个类的构造器中使用了"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
                          可以看到：
                                可以用super和this分别调用父类的构造方法和本类中其他形式的构造方法。
                                例子中Chinese类第三种构造方法调用的是本类中第二种构造方法，而第二种
                                构造方法是调用父类的，因此也要先调用父类的构造方法，再调用本类中第二种，
                                最后是重写第三种构造方法。

super和this的异同

* super(参数)：调用基类中的某一个构造函数(应该为构造函数中的第一条语句)
  * this(参数)：调用本类中另一种形成的构造函数(应该为构造函数中的第一条语句)
  * super:它引用当前对象的直接父类中的成员(用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：
          super.变量名 super.成员函数据名(实参) this：它代表当前对象名(在程序中易产生二义性之处，应使用 this 来指明当前对象；
          如果函数的形参与类中的成员数据同名，这时需用 this 来指明成员变量名)
  * 调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用 super()，如果父类没有这种
    形式的构造函数，那么在编译的时候就会报错。
  * super() 和 this() 类似,区别是，super() 从子类中调用父类的构造方法，this() 在同一类内调用其它方法。
  * super() 和 this() 均需放在构造方法内第一行。
  * 尽管可以用this调用一个构造器，但却不能调用两个。
  * this 和 super 不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有 super 语句的存在，所以
    在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
  * this() 和 super() 都指的是对象，所以，均不可以在 static 环境中使用。包括：static 变量,static 方法，static 语句块。
  * 从本质上讲，this 是一个指向本对象的指针, 然而 super 是一个 Java 关键字。

   ** 原文链接：https://www.cnblogs.com/hasse/p/5023392.html**