第4章 初始化和清理
我个人理解初始化和清理的关系就是吃饭和上厕所，正是有了初始化的对象，我们才能使用清理。但是为什么要清理呢？想象一下一个人光吃不拉，是个什么情况？：）难道我们的程序也要像吃饭一样光产生对象，而不去清理使用完毕的对象？任由我们的对象堆积如山，占用系统资源？
以构造函数确保初始化的进行
什么构造函数？构造函数就是一种特殊的函数，当对象产生时，他会被系统自动的调用起来，并且这个函数名称和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 [email protected] /163.com QQ:31349283 我们可以共同学习进步！
欢迎访问我的blog，http://blog.csdn.com/maoerzuozuo 里面有更多学习内容！
本文地址：http://com.8s8s.com/it/it15993.htm