JAVA构造函数

摘自：http://blog.tianya.cn/blogger/post_show.asp?BlogID=229728&PostID=9989852

初始化和清理
　　 我个人理解初始化和清理的关系就是吃饭和上厕所，正是有了初始化的对象，我们才能使用清理。但是为什么要清理呢？想象一下一个人光吃不拉，是个什么情况？：）难道我们的程序也要像吃饭一样光产生对象，而不去清理使用完毕的对象？任由我们的对象堆积如山，占用系统资源？
　　 以构造函数确保初始化的进行
　　 什么构造函数？构造函数就是一种特殊的函数，当对象产生时，他会被系统自动的调用起来，并且这个函数名称和class名相同。　　

　　 class ConstructorTest
　　 {
　　 ConstructorTest()//构造函数是没有返回值的，注意不是void的！
　　 {
　　 System.out.println("nothing!");
　　 }
　　 ConstructorTest(String s)
　　 {
　　 System.out.println(s);
　　 }
　　 public static void main(String args[])
　　 {
　　 new ConstructorTest();//当对象生成的时候，系统会自动的调用他的构造函数
　　 new ConstructorTest("hello"); //并且构造函数还可以接受引数，产生你所希望的特定的对象。假如ConstructorTest(String s)是唯一的构造函数，那么编译器不允许你以任何其他的方式开产生对象
　　 }
　　 }

　　 有的人看到这里就是要问了，为什么我的程序就根本没有定义过构造函数，但是我为什么在创建对象的时候依然可以使用他呢？

　　 例如

　　 class test
　　 {
　　 public static void main(String args[])
　　 {
　　 new test(); //没定义过任何构造函数，但是可以使用，原因就是，当你没有定义任何构造函数时，系统会自动为你定义一个不接受引数的默认构造函数
　　 }
　　 }

　　 虽然说，系统会帮你定义一个最简单的，没有引数的构造函数，但是有一点你必须记住：假如你定义了构造函数，那么系统就不会自动帮你生成一个默认构造函数，你也休想去调用这个默认的构造函数，你只能调用你自己定义的构造函数！

　　 函数的重载（overloading）
　　 其实我个人老是搞不清重载和覆写的名称，并不是我不明白他们之间的差别，而是，我觉得他们的名字太相近了，容易混淆，呵呵~我们用一句最短的话来形容重载------同名称，不同引数的函数。
　　 举个小例子，我们大家都很喜欢玩cs的吧，我们会说：大家冲a门，杀了他们。这个"杀"是什么意思？当然不是现实生活中的杀了，而是游戏中的定义。这个时候，你就可以把杀作为一个函数来看，例如　

 class person
　　 {
　　 }
　　 class cs
　　 {
　　 }
　　 class man
　　 {
　　 public void kill(person p)
　　 {
　　 System.out.println(p+" was killed!");
　　 }
　　 public void kill(cs c)
　　 {
　　 System.out.println(c+" was killed");
　　 }
　　 public static void main(String args[])
　　 {
　　 person p=new person();
　　 cs c=new cs();
　　 man m=new man();
　　 m.kill(p);
　　 m.kill(c);
　　 }
　　 }

　　 这里我们定义了2中’杀‘的的方法， 一种是杀真的人，一种是杀cs中的人，我们在游戏中喊叫‘杀啊’，我估计没人会想到你要杀真的人，大家都知道你是要杀游戏中的人物。如果你说，我要用杀cs中人物的杀的方法来杀捍匪。估计人家都会认为你是神经病。就是因为人的话即使少说几个字都是无所谓的，因为我们的人工智能会帮我们分析的，但是计算机不会这样，你必须指派一个具体的函数给编译器，于是我们就使用同名称，但是不同引数的函数，你只要在调用函数的时候传递进去相对应的对象就行，而不必写上一大堆的名字不相同的函数，来分别调用，这样一个精心挑选的名称能够帮助你自己和别人编写、阅读、分析程序，使同一个函数具有多种不同的意义

　　 在java中，构造函数是必须重载的（也就是系统自动生成默认构造函数的原因），假如你想根据自己的意愿来产生不同的对象
　　 那么，重载构造函数就是闭不可少的了　　　　

　　 class person
　　 {
　　 String sex="man";
　　 person()
　　 {
　　 System.out.println("this is a "+sex);
　　 }
　　 person(String s)
　　 {
　　 sex=s;
　　 System.out.println( "this is a "+sex );
　　 }
　　 public static void main(String args[])
　　 {
　　 new person();
　　 new person("woman");
　　 }
　　 }

　　 这里我们定义了2个构造函数，通过这2个重载的构造函数，我们可以产生不同的的person对象，一个男人，一个女人

　　 区分重载函数
　　 重载的函数具有相同的名字，那么编译器怎么能知道你调用的是那一个呢？其实很简单，聪明的人估计已经看出来了：每个重载的函数都具备一个独一无二的引数，即便是引数的顺序不同，也足以区分几个名字相同的重载函数（但是不推荐，因为这样会让你的程序难以阅读和维护）
　　 搭配基本类型进行重载
　　 因为基本类型可以自动由较小的类型转换为较大的类型，所以当使用重载机制的时候，容易产生混淆，也就是说当你有几个函数分别是void test(int i) void test(byte b) void test(short s),如果你调用test(3)的时候，你就会发现，3被视为int，而能接受int引数的函数会被唤起，而如果你就只有void test(double d)这么一个函数，你就会发现int 3自动获得提升，变为double的值，而当你传进函数的值大于函数的引数时候，你就必须使用强制转换才能调用

　　 class Myclass
　　 {
　　 static int i=100;
　　 void test(double d)
　　 {
　　 System.out.println(d);
　　 }
　　 void test(char c)
　　 {
　　 System.out.println(c);
　　 }
　　 public static void main(String args[])
　　 {
　　 Myclass p=new Myclass();
　　 p.test(i); //引数大于传递进来的值，自动转换,输出100.0
　　 p.test((char)i); //引数小于传递进来的值，强制转换,输出d
　　 }
　　 }

　　 以返回值作为重载的基准

　　 注意，java中无法以函数的返回值作为重载标准之一
　　 default构造函数
　　 default构造函数就是一种不带有任何引数的构造函数，并且他是在你没有定义任何构造函数（无论是否有引数）的时候，由系统自动生成的，如果你已经自己定义了构造函数，那么系统是不会帮你生成构造函数的，你也没办法去调用他们
　　 关键字this
　　 this的作用主要有
　　 1、在函数中使用，他所代表的是调用此函数的那个句柄（object reference）

　　 例如 class test
　　 {
　　 void method1()
　　 {
　　 System.out.println("method1");
　　 }
　　 void method2()
　　 {
　　 System.out.println("method2");
　　 }
　　 void method3()
　　 {
　　 this.method1(); //在函数中调用同一个class中的另外一个函数，其实没有必要使用this的，直接调用就行
　　 this.method2(); //编译器会自己偷偷的传入这个this句柄的
　　 System.out.println("method3");
　　 }
　　 public static void main(String args[])
　　 {
　　 test t =new test();
　　 t.method3();
　　 }
　　 }

　 我们都知道在面向对象的语言中，函数的调用大多数是要同过对象来调用的，那么这里的this是干吗的呢？其实这个this就是当前对象的句柄，你可以采取对对象句柄一样的处理方式来处理这里的this，例如

　　 class test
　　 {
　　 int i=10;
　　 void method1()
　　 {
　　 int i=20;
　　 System.out.println(i); //这里打印的是局部变量20
　　 System.out.println(this.i); //这里打印的全局变量10
　　 this.i=i; //这里把局部变量的值赋给全局变量
　　 System.out.println(this.i); //这里打印出改变后的全局变量20
　　 }
　　 public static void main(String args[])
　　 {
　　 test t = new test();
　　 t.method1();
　　 }
　　 }

　　 你可以把这里的this.i看成是test.i（只是举个例子，你要是这样写的话是编译不过去的），这样你就能明白我上面说的"你可以采取对对象句柄一样的处理方式来处理这里的this"这句话的意思了！

　　 还有一种情况也是需要明确的指出this关键字的，就是当你必须明确指出当前的对象句柄究竟是谁的时候

　　 class test
　　 {
　　 int i=0;
　　 public test go()
　　 {
　　 i++;
　　 return this;
　　 }
　　 public void show()
　　 {
　　 System.out.println(i);
　　 }
　　 public static void main(String args[])
　　 {
　　 new test().go().go().go().show();
　　 }
　　 }

　　 由于go(通过关键字this返回了当前的对象，所以我们可以轻易的在用一个对象身上执行多次操作

　　 2、在构造函数中调用构造函数
　　 也许你编写的类中，有多个构造函数，兴许他们中间有很多相同的地方，那么我们为了避免写重复的代码，可以在构造

　　 class person
　　 {
　　 person()
　　 {
　　 System.out.println("speak chinese");
　　 }
　　 person(String s)
　　 {
　　 this(); //这里调用的就是person()构造函数
　　 System.out.println("speak english");
　　 }
　　 person(int i)
　　 {
　　 //this();这个是个错误！因为只能由this调用一个构造函数！另外，调用构造函数的语句必须放在first statement in constructor
　　 this("man"); //这里调用的就是person(String s)构造函数
　　 System.out.println("we have "+i+" persons!!!");
　　 }
　　 void show()
　　 {
　　 //this();编译器不允许你在构造函数之外的任何函数内调用构造函数
　　 }
　　 public static void main(String args[])
　　 {
　　 person p=new person(10);
　　 }
　　 }

　　 static的意义

　　 在我们系统的学习了this之后，我们就应该能比较深刻全面的了解什么是static函数了。他的意思是：对于这个已经被声明为static的函数来说，你没办法在static的函数中直接调用非static的函数，因为他没有我们上面所讲的this，只能使用对象来调用非static函数。但是我们还可以使用class本身来调用他自身的static函数，不用通过任何对象。通过static，你可以想象static的函数就是java中的全局函数，他可以提供对其他static函数和static数据成员的访问。但是请大家不要大量的使用static的函数和变量，因为这样让人感觉好象不是oop的语言（因为oop的语言是使用对象来调用函数的）
　　 
　　第四章未完 欢迎关注，有什么问题，可以这样联系我
　　E-mail molmd@163.net /163.com QQ:31349283 我们可以共同学习进步！
　　欢迎访问我的blog，http://blog.csdn.com/maoerzuozuo 里面有更多学习内容！