[Java] super，this 的区别及构造方法的使用

1、构造方法的使用

类有一个特殊的成员方法叫做构造方法，它的作用是创建对象并初始化成员变量。在创建对象时，会自动调用类的构造方法。

JAVA中构造方法必须与该类具有相同的名字，并且没有方法的返回类型（包括没有void）。另外，构造方法一般都应用public 类型来说明，这样才能在程序的任意位置创建类的实例—对象。

每个类至少有一个构造方法。如果不写一个构造方法，JAVA将提供一个默认的，该构造方法没有参数，而且方法体为空。

注意：如果一个类中已经定义了构造方法则系统不再提供默认的构造方法

public class Hello {
int id;
String username;
String password;
public Hello(int id) {
this.id = id;
System.out.println("构造函数1:id="+ id);
}
public Hello(int i,String username,String password) {
//此时，i这个局部变量没有和成员变量重名，所以不用指定
this.username = username;
this.password = password;
System.out.println("构造函数2：username=" username " password=" password);
}
public Hello() {
//用this调用上面的构造函数，必须上面有定义下面才能使用
this(5,"hualang","123456");
}
public static void main(String args[]) {
Hello hello1 = new Hello(3);
Hello hello2 = new Hello(4,"loulijun","666666");
Hello hello3 = new Hello();
}
}

输出结果：

构造函数1: id=3
构造函数2: username=loulijun password=666666
构造函数2: username=hualang password=123456

2、super，this的区别及使用

JAVA的this关键字只能用于方法体内，JAVA虚拟机（JVM）会给这个对象分配一个引用自身的指针，这个指针的名字就是this，因此，this只能在类中的非静态方法中使用，静态方法和静态的代码块中不能使用this，比如main方法中是不能使用this的，并且this只和特定的对象关联，而不和类关联，同一个类中的的不同对象有不同的this。

注意：函数参数或者函数中的局部变量和成员变量同名的话，成员变量被屏蔽，此时要访问成员变量则需要使用

“this.成员变量”的方式引用成员成员变量，如果没有同名的情况下，可以直接使用。

public class ThisTest {
private int number;
private String username;
private String password;
final private int x = 6;
public ThisTest(int number) {
this.number = number;
}
public ThisTest(int number, String username, String password) {
//成员变量和参数同名，成员变量被屏蔽，用“this.成员变量”的方式访问成员变量
this.number = number;
this.username = username;
this.password = password;
}
public ThisTest() {
this(1,"通过this调用另一个构造方法（ 3个参数）","111111");
}
public ThisTest(String name) {
this( 2,name,"通过this调用另一个构造方法");
}

public void test() {
//局部变量与成员变量同名，成员变量被屏蔽，用"this.成员变量"的方式访问成员变量
int x;
x = this.x  6;
System.out.println("局部变量x=" x);
System.out.println("成员变量this.x=" this.x);
}

public void showMessage(ThisTest t) {
System.out.println("-----------------------");
System.out.println(t.number);
System.out.println(t.username);
System.out.println(t.password);
System.out.println("-----------------------");
test();//可以使用this.test()调用
}
public static void main(String args[]) {
ThisTest t1 = new ThisTest();
ThisTest t2  = new ThisTest("loulijun");
t showMessage(t1);
t showMessage(t2 );
}
}

运行结果如下：

1
通过this调用另一个构造方法（3个参数）
111111
-----------------------
局部变量x=12
成员变量this.x=6
-----------------------
2
loulijun
通过this调用另一个构造方法
-----------------------
局部变量x=12
成员变量this.x=6

运行结果分析：

main函数中首先创建两个ThisTest对象，t1、t2，然后调用用着两个对象调用showMessage()方法，并且将自己作为参数传递给showMessage()，比如t1.showMessage(t1)：这个方法会以这个对象调用number,username,password，以及test()方法，从而打印出数据

super的使用及说明

super和this作用类似，使被屏蔽的成员变量或者成员方法课件，或者说用来引用被屏蔽的成员变量和成员方法。

不过super是用在子类中，目的是访问直接父类中被屏蔽的成员，注意是直接父类（类之上最近的超类）。

1、在使用super的时候，一般尽可能的使用private私有化

2、子类构造方法调用父类的构造方法一般用super(参数列表)的方式调用，参数不是必须的。同时还要注意，super(参数列表)这条语句只能用在子类构造方法体中的第一行

3、当子类方法中的局部变量或者子类的成员变量与父类成员变量同名时，也就是子类局部变量覆盖父类成员变量时，用

“super.成员变量名”来引用父类的成员变量。当然，如果父类的成员变量没有被覆盖，也可以用”super.成员变量名”来引用父类成员变量，不过这是不必要的

4、当子类的成员方法覆盖了父类的成员方法时，也就是子类和父类有完全相同的方法定义（但方法体可以不同），此时，用”super.方法名（参数列表）”的方式访问父类的方法

父类 Father.java

public class Father {
public String v = "父类Father";
public String x = "父类的成员变量";

public Father() {
System.out.println("Father无参构造方法被调用");
}
public Father(String v) {
this.v = "Father有参构造方法被调用";
}
public void showMessage() {
System.out.println("Father的showMessage()方法被调用");
}
public static void main(String args[]) {
//自动生成存根方法
}
}

子类Son.java

public class Son extends Father {
public String v = "子类Son";
public Son() {
//调用父类的构造方法，且只能放在第一行
super();
System.out.println("Son的无参构造方法被调用");
}
public Son(String str) {
super(str);
System.out.println("Son的有参构造方法被调用");
}
//覆盖了父类的成员方法showMessage()
public void showMessage() {
System.out.println("Son的showMessage()方法被调用");
}

public void test() {
String v = "局
4000
部变量v覆盖了成员变量v和超类变量v";

System.out.println("---------------------------");
System.out.println("子类局部变量v=" v);
System.out.println("子类成员变量v=" this.v);
System.out.println("父类成员变量v=" super.v);
System.out.println("子类继承而来的超类成员变量x=" x);
System.out.println("超类成员变量x=" super.x);
System.out.println("---------------------------");
showMessage();//调用子类的showMessage()方法
this.showMessage();//调用子类的showMessage()方法
super.showMessage();//调用父类的showMessage()方法
}

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

运行Son.java，结果如下：

Father无参构造方法被调用
Son的无参构造方法被调用
---------------------------
子类局部变量v=局部变量v覆盖了成员变量v和超类变量v
子类成员变量v=子类Son
父类成员变量v=父类Father
子类继承而来的超类成员变量x=父类的成员变量
超类成员变量x=父类的成员变量
---------------------------
Son的showMessage()方法被调用
Son的showMessage()方法被调用
Father的showMessage()方法被调用