java构造器与this,super关键字介绍
在Java与C语言的编程中，必须对创建的对象进行对象初始化，Java采用C++所引入的构造器对对象进行初始化，这是一个在创建对象时被自动调用的特殊方法。
注意：构造器的名称必须与类名完全相同
class Constructor{ //cover from Mr.Summer
Constructor(){ //this is a constructor.
System.out.println("Constructor");}
}
public class Text{
public static void main(String[] args){
for(int i=0;i<3;i++)
new Constructor();}
}/*Output: Constructor Constructor Constructor*/在创建对象时：
new Constructor( )；
将会为对象自动分配存储空间，并调用对应的构造器，这样就能确保在使用之前已经初始化了。
构造器有两种：
①不含任何参数的构造器，即默认构造器；
②含有参数的构造器，如下所示：
class Constructor2{
Constructor2(int i){
System.out.println("Constructor "+i+" "); }
}
public class Text2{
public static void main(String[] args){
for(int i=0;i<3;i++)
new Constructor2(i);}
}/*Output: Constructor 0 Constructor 1 Constructor 2*/构造器的重载：
前面已经说明了构造器的名称必须与类名相同，如果想用多种方式创建一个对象该怎么办？假设你创建一个类，既可以用标准方式进行初始化，又可以从文件中读取所需要的信息来初始化，这就需要两个构造器：一个默认构造器，一个带变量的构造器。这就必须用到构造器的重载。
下面这个例子同时示范了重载的构造器和重载的方法：
class Tree{ //cover from Thinking in Java
int height;
Tree(){
System.out.println("Planting a seedling");
height = 0;}
Tree(int i){
height = i;
System.out.println("Creating new Tree that is " + height + " feet tall");}
void info(){
System.out.println("Tree is " + height + " feet tall");}
void info(String s){
System.out.println(s+":Tree is " + height + " feet tall");}
}
public class Test{
public static void main(String[] args){
for(int i = 0 ; i < 3 ; i++) {
Tree t = new Tree(i);
t.info();
t.info("overloaded method");}
new Tree();
}
}/*Output
Creating new Tree that is 0 feet tall
Tree is 0 feet tall
overloaded method:Tree is 0 feet tall
Creating new Tree that is 1 feet tall
Tree is 1 feet tall
overloaded method:Tree is 1 feet tall
Creating new Tree that is 2 feet tall
Tree is 2 feet tall
overloaded method:Tree is 2 feet tall
Planting a seedling*/
重载构造器还能够通过参数进行区分，规则很简单，因为在Java中，任何重载的方法都必须有一个独一无二的参数类型列表，例如：
Tree（int，string）与Tree（string，int）是两个不同的重载构造器
this 在构造器中的用法
public class Money{
int i = 0;
String s = "hello";
Money(int i){
System.out.println("you have "+i+" dollar.");}
Money(String ss){
System.out.println(ss+" ,nice to meet you.");
s = ss;}
Money(String s,int i){
this(i);
this.s=s;
System.out.println("go Money(String s,int i)");}
Money(){
this("hi" , 10);
System.out.println("go Money( )");}
public static void main(String[] args){
Money m = new Money();}
}/*Output
you have 10 dollar.
Go Money(String s, int i)
Go Money( )*/主函数中创建一个对象，对象首先调用Money（）函数，因为Money（）函数中的this( " hi " , " 10 " )是指向Money(s , i )类型的构造器，在该构造器中又有一个指向Money（i）类型的构造器，所以先执行Money（i），再执行Money(s , i )，最后执行Money（）。
this再这里的的用法就是明确指向某个构造器，方便调用
super 在构造器中的用法
super( )函数在构造器中的调用指的是在子类中调用父类的构造器函数。this则不同，this不能用于子类调用父类的构造器，只能调用同一个类中的构造器。
class Super {
Super(String a){
System.out.println("参数为a的构造器");
}
Super() {
System.out.println("empty 参数");
}
public static class classa extends Super{
classa() {
super();
}
classa(String a){
super(a);
}
}
public static void main(String[] args) {
classa a = new classa();
a=new classa();
a=new classa("a");
}
}/*empty 参数
empty 参数
参数为a的构造器*/
可以看到在classa中调用 super( )与super(a) 两个构造器,在创建classa对象时调用classa（），classa（）又使用super（）调用父类中无参数构造器Super( )，同样的classa（"a"）则利用super（a）调用父类中的Super(String a)构造器。
初始化的顺序是先静态（static）对象，再非静态对象，只是初始化，并不执行静态函数！