初始化与清理

最新推荐文章于 2021-09-22 10:30:07 发布

csdn1428208016

最新推荐文章于 2021-09-22 10:30:07 发布

阅读量421

点赞数

分类专栏： Java 文章标签： Java 初始化清理垃圾回收器

本文链接：https://blog.csdn.net/csdn1428208016/article/details/83044552

版权

Java 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

初始化与清理

用构造器确保初始化
构造器与方法的重载
构造器中调用构造器
构造器初始化
成员初始化
清理：终结处理和垃圾回收
垃圾回收器如何工作

用构造器确保初始化

在Java中，通过提供构造器，类的设计者可确保每个对象都会得到初始化。创建对象时，如果其类具有构造器，Java就会在用户有能力操作对象之前自动调用相应的构造器，从而保证了初始化的进行。
构造器的命名现在有两个问题：第一，所取的任何名字都可能与类的某个成员名称相冲突，第二，调用构造器是编译器的责任，所以必须让编译器知道应该调用哪个方法。C++语言中采用的解决方案看来最简单且更符合逻辑，所以在Java中也采用了这种方案：即构造器采用与类相同的名称。考虑到在初始化期间要自动调用构造器，这种做法就顺理成章了。

在使用new关键字创建对象时，将会为对象分配存储空间，并调用相应的构造器。这就确保了在你能操作对象之前，它已经被恰当地初始化了。

请注意，由于构造器的名称必须与类名完全相同，所以“每个方法首字母小写”的编码风格并不适用于构造器。

不接受任何参数的构造器叫做默认构造器，Java文档中通常使用术语无参构造器。但是和其他方法一样，构造器也能带有形式参数，以便指定如何创建对象。

public class Test {

	public Test() {
		System.out.println("调用了无参构造器");
	}
	
	public Test(String str){
		System.out.println("调用了有参构造器,参数是："+str);
	}
	
	public static void main(String[] args) {
		new Test();
	}//输出：调用了无参构造器
}

构造器是一种特殊类型的方法，因为它没有返回值。这与返回值为空（void）明显不同。对于空返回值，尽管方法本身不会自动返回什么，但仍可选择让它返回别的东西。构造器则不会返回任何东西，你别无选择（new表达式确实返回了对新建对象的引用，但构造器本身并没有任何返回值）。假如构造器具有返回值，并且允许人们自行选择返回类型，那么势必得让编译器知道该如何处理此返回值。

构造器与方法的重载

在Java里，构造器是强制重载方法名的另一个原因，既然构造器的名字已经由类名所决定，就只能有一个构造器名，那么要想用多种方式创建一个对象该怎么办呢?假设你要创建一个类，既可以用标准方式进行初始化，也可以从文件里读取信息来初始化,这就需要两个构造器，一个默认认构造器，另一个取字符串作为形式參数一该字符串表示初始化对象所需的文件名称，由于都是构造器，所以它们必须有相同的名字，即类名，为了让方法名相同而形式参数不同的构造器同时存在，必须用到方法重載。上面的例子展示了构造器的重载

尽管方法重裁是构造器所必需的，但它亦可应用于其他方法，且用法同样方便，下面的例子将展示方法的重载。

public class Test {

	public static void printTest(){
		System.out.println("printTest()方法");
	}
	
	public static void printTest(String str){
		System.out.println("printTest(String str)方法,参数是："+str);
	}
	
	public static void main(String[] args) {
		Test.printTest("1");
	}//输出：printTest(String str)方法,参数是：1
}

注意

区分方法重载，每个重载的方法都必须有一个独一无二的参数类型列表（数量的不同或参数类型的不同）。
涉及基本类型的重载，基本类型能从一个“较小”的类型自动提升至一个“较大”的类型。当参数为常数值5时，将被当作int值处理，所以如果有某个重载方法接受int型参数，它就会被调用。至于其他情况，如果传入的数据类型（实际参数类型）小于方法中声明的形式参数类型，实际数据类型就会被提升。char型略有不同，如果无法找到恰好接受char参数的方法，就会把char直接提升至int型。如果传入的实际参数较大，就得通过类型转换来执行窄化转换。如果不这样做，编译器就会报错。
以返回值区分重载方法是行不通的。

构造器中调用构造器

可能一个类写了多个构造器，有时可能想在一个构造器中调用另一个构造器，以避免重复代码。可用this关键字做到这一点。

通常写this的时候,都是指“这个对象”或者“当前对象”，而且它本身表示对当前对象的引用。在构造器中，如果为this添加了参数列表，那么就有了不同的含义。这将产生对符合此容数列表的某个构造器的明确调用；这样，调用其他构造器就有了直接的途径。

public class SuperTest {

	public SuperTest() {
		System.out.print("调用SuperTest()构造器,");
	}
}

public class Test extends SuperTest{
	
	public int s = 1;

	public Test(int s){
		this(s+"");
		System.out.print("调用Test(int i)构造器");
		System.out.println(this.s);
	}
	public Test(String str){
		super();
		System.out.print("调用Test(String str)构造器");
	}

	public static void main(String[] args) {
		new Test(1);
	}
	/**
	 * 输出：
	 * 调用SuperTest()构造器
	 * 调用Test(String str)构造器
	 * 调用Test(int i)构造器
	 * 1
	 * */
}

this关键字
构造器Test(int i)表明：尽管可以用this调用一个构造器，但却不能调用两个。此外，必须将构造器调用置于最起始处，否则编译器会报错。这个例子也展示了this的一种用法。
由于参数s的名称和数据成员s的名字相同，所以会产生歧义。使用this来代表数据成员就能解决这个问题。在Java程序代码中经常出现这种写法。这是this的另一种用法。
this关键字只能在方法内部使用，表示对“调用方法的那个对象”的引用。this的用法和其他对象引用并无不同。但要注意，如果在方法内部调用同一个类的另一个方法，就不必使用this，直接调用即可。当前方法中的this引用会自动应用于同一类中的其他方法。
static关键字
了解this关健字之后，就能更全面地理解static（静态）方法的含义。 static方法就是没有static的方法。在static方法的内部不能调用非静态方法，反过来倒是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。它很像全局方法。Java中禁止使用全局方法，但你在类中置入static方法就可以访问其他static方法和static域。

构造器初始化

可以用构造器来进行初始化。在运行时刻，可以调用方法或执行某些动作来确定初値，这为编程带来了更大的灵活性。但要牢记：无法阻止自动初始化的进行，它将在构造器被调用之前发生。因此,假如使用下述代码：

public class Counter{
	int i;
	public Counter(){
		i = 7;
	}
}

那么i首先会被置0，然后变成7。对于所有基本类型和对象引用，包括在定义时已经指定初值的变量，这种情况都是成立的。因此，编译器不会强制你一定要在构造器的某个地方或在使用它们之前对元素进行初始化——因为初始化早已得到了保证。

变量初始化顺序
在类的内部，变量定义的先后顺序决定了初始化的顺序。即使变量定文散布于方法定义之间，它们仍旧会在任何方法（包括构造器）被调用之前得到初始化。
静态数据的初始化
无论创建多少个对象，静态数据都只占用一份存储区域。static关键字不能应用于局部变量，因此它只能作用于域。如果一个域是静态的基本类型域，且也没有对它进行初始化，那么它就会获得基本类型的标准初值;如果它是一个对象引用，那么它的默认初始化值就是null。
显式的静态初始化
Java允许将多个静态初始化动作组织成一个特殊的“静态子句”(有时也叫做“静态块”)。就像下面这样：

public class Counter{
	int i;
	static{
		i = 7;
	}
}

尽管上面的代码看起来像个方法，但它实际只是一段跟在static关键字后面的代码。与其他静态初始化动作一样，这段代码仅执行一次：当首次生成这个类的一个对象时，或者首次访问属于那个类的静态数据成员时(即便从未生成过那个类的对象)。

非静态实例初始化
Java中也有被称为实例初始化的类似语法，用来初始化每一个对象的非静态变量。例如:

public class Test2 {

	public Test2() {
		System.out.println("调用Test2()构造器");
	}
}

public class Test {
	
	public Test(){
		System.out.println("调用Test()构造器");
	}
	
	Test2 t2;
	
	{
		t2 = new Test2();
	}
	
	public static void main(String[] args) {
		new Test();
	}
	/**
	 * 输出：
	 * 调用Test2()构造器
	 * 调用Test()构造器
	 * */
}

看起来它与静态初始化子句一模一样，只不过少了static关键字。这种话法对手支持“匿名内部类”的初始化是必须的，但是它也使得你可以保证无论调用了哪个显式构造器，某些操作都会发生。从输出中可以看到实例初始化子句是在构造器之前执行的。

对象的创建过程
初始化的顺序是先静态对象（如果它们尚未因前面的对象创建过程而被初始化），而后是非静态对象。总结一下对象的创建过程，假设有个名为Dog的类：
1.即使没有显式地使用static关键字，构造器实际上也是静态方法。因此，当首次创建类型为Dog的对象时（构造器可以看成静态方法），或者Dog类的静态方法/静态域首次被访问时，Java解释器必须査找类路径,以定位Dog.class文件。
2.然后载入Dog.class文件，有关静态初始化的所有动作都会执行。因此，静态初始化只在Class对象首次加载的时候进行一次。
3.当用new Dog()创建对象的时候，首先将在堆上为Dog对象分配足够的存储空间。
4.这块存储空间会被清零，这就自动地将Dog对象中的所有基本类型数据都设置成了默认值（对数字来说就是0，对字符型也相同，布尔型为false），而引用则被设置成了null。
5.执行所有出现于字段定义处的初始化动作。
6.执行构造器。这可能会牵涉到很多动作，尤其是涉及继承的时候。

成员初始化

Java尽力保证：所有变量在使用前都能得到恰当的初始化对于方法的局部变量Java以编译时错误的形式来贯彻这种保证。所以如果写成：

void f(){
	int i;
	i++;	//Error - i not initialized
}

就会得到一条错误，消息告诉你i可能未初始化。

指定初始值
如果想为某个变量赋初值，该怎么做呢？有一种很直接的方法就是在定义类成员变量的地方为其赋值。以下代码片段修改:

void f(){
	int i = 1;
	i++;
}

也可以用同样的方法初始化非基本类型的对象。

class Dog{}

public class Animal(){
	Dog d = new Dog();
}

清理：终结处理和垃圾回收

程序员都了解初始化的重要性，但常常会忘记同样也重要的清理工作。毕竟，谁需要清理一个int呢？但在使用程序库时，把一个对象用完后就“弃之不顾”的做法并非总是安全的。当然，Java有垃圾回收器负责回收无用对象占据的内存资源。但也有特殊情况：假定你的对象（并非使用new）获得了一块“特殊”的内存区域，由于垃圾回收器只知道释放那些经由new分配的内存，所以它不知道该如何释放该对象的这块“特殊”内存。为了应对这种情况，Java允许在类中定义一个名为finalize()的方法。它的工作原理“假定”是这样的：一旦垃圾回收器准备好释放对象占用的存储空间，将首先调用其finalize()方法，并且在下一次垃圾回收动作发生时，才会真正回收对象占用的内存。所以要是你打算用finalize()，就能在垃圾回收时刻做一些重要的清理工作。

这里有一个潜在的编程陷阱，因为有些程序员（特別是C++程序员）刚开始可能会误把finalize()当作C++中的行构函数（c++中销毁对象必须用到这个函数）。所以有必要明确区分一下：在C++中，对象一定会被销毁（如果程序中没有缺陷的话），而Java里的对象却并非总是被垃圾回收。或者换句话说：

1.对象可能不被垃圾回收

2.垃圾回收并不等于“折构”

牢记这些，就能远离困扰。这意味着在你不再需要某个对象之前，如果必须执行某些动作，那么你得自己去做。Java并未提供“析构函数”或相似的概念，要做类似的清理工作，就必须自己动手创建一个执行清理工作的普通方法。

也许你会发现, 只要程序没有濒临存储空间用完的那一刻，对象占用的空间就总也得不到释放。如果程序执行结束并且垃圾回收器一直都没有释放你创建的任何对象的存储空间，则随着程序的退出，那些资源也会全部交还给操作系统。这个策略是恰当的，因为垃圾回收本身也有开销，要是不使用它，那就不用支付这部分开销了。

1.finalize()的用途何在

此时，读者已经明白了不该将finalize()作为通用的清理方法。那么,finalize()的真正用途是什么呢？这引出了要记住的第三点：

3.垃圾回收只与内存有关。

也就是说，使用垃圾回收器的唯一原因是为了回收程序不再使用的内存。所以对于垃圾回收有关的任何行为来说（尤其是finalize()方法），它们也必须同内存及其回收有关。

但这是否意味着要是对象中含有其他对象，finalize()就应该明确释放那些对象呢？不，无论对象是如何创建的，垃圾回收器都会负责释放对象占据的所有内存。这就将对finalize()的需求限制到一种特殊情況，即通过某种创建对象方式以外的方式为对象分配了存储空间。不过，我们也看到了，Java中一切皆为对象，那这种特殊情况是怎么回事呢？

看来之所以要有finalize()，是由于在分配内存时可能采用了类似C语言中的做法，而非Java 中的通常做法。这种情况主要发生在使用“本地方法”的情况下，本地方法是一种在Java中调用非Java代码的方式（关手本地方法的讨论见Java编程思想电子版第2版，在www.MindView.net网站上有收录）。本地方法目前只支持C和C++，但它们可以调用其它语言写的代码，所以实际上可以调用任何代码。

至此，我们或许已经明白了不要过多地使用finalize()的道理了。对，它确实不是进行普通的清理工作的合适场所。那么，普通的清理工作应该在哪里执行呢？

2.你必须实施清理

要清理一个对象，用户必须在需要清理的时刻调用执行清理动作的方法。这听起来似乎很简单。在Java中，垃圾同收器会帮助你释放使用new创建对象的存储空间。记住，无论是“垃圾回收”还是“终结”，都不保证一定会发生。如果Java虚拟机（JVM）并未面临内存耗尽的情形，它是不会浪费时间去执行垃圾回收以恢复内存的。

3.终结条件

通常，不能指望finalize()，必须创建其他的“清理方法，并且明确地调用它们。看来，finalize()只能存在于程序员很难用到的一些晦涩用法里了。不过，finalize()还有一个有趣的用法，它并不依赖于每次都要对finalize()进行调用，这就是对象终结条件（这个术语是由Bill Venners和Bruce Eckel发明）的验证。

当对某个对象不再感兴趣——也就是它可以被清理了，这个对象应该处于某种状态，使它占用的内存可以被安全地解放。例如，要是对象代表了一个打开的文件，在对象被回收前程序员应该关闭这个文件。只要对象中存在没有被适当清理的部分，程序就存在很隐海的缺陷。finalize()可以用来最终发现这种情况——尽管它并不总是会被调用。如果某次finalize()的动作使得缺陷被发现，那么就可据此找出问题所在——这才是人们真正关心的。以下是个简单的例子，示范了finalize()可能的使用方式：

class Book{
	boolean checkedOut = false;
	Book(boolean checkOut){
		checkedOut = checkOut;
	}
	
	void checkIn(){
		checkedOut = false;
	}

	protected void finalize(){
		if(checkedOut){
			System.out.print("Error:checked out");
			//super.finalize();
		}
	}
}

class Test{
	public static void main(String[] args){
		Book b = new Book(true);
		b.checkIn();
		new Book(true);
		System.gc();
	}
	//输出：Error:checked out
}

本例的终结条件是：所有的Book对象在被当作垃圾回收前都应该被签入（checkin）。但在main()方法中，由于程序员的错误，有一本书未被签入。要是没有finalize()来验证终结条件，将很难发现这种缺陷。

注意，System.gc()用于强制进行终结动作。即使不这么做，通过重复地执行程序（假设程序将分配大量的存储空间而导致垃圾回收动作的执行），最终也能找出错误的Book对象。

你应该总是假设基类版本的finalize()也要做某些重要的事情，因此要使用super来调用它，就像在Book.finalize()中看到的那样。在本例中它被注释掉了。

垃圾回收器如何工作

在以前所用过的程序语言中，在堆上分配对象的代价十分高昂, 因此我们自然会觉得Java中所有对象(基本类型除外)都在堆上分配的方式也非常高昂。然而，垃圾回收器对于提高对象的创建速度，却具有明显的效果。听起来很奇怪——存储空间的释放竞然会影响存储空间的分配，但这确实是某些Java虚拟机的工作方式。这也意味着，Java从堆分配空间的速度，可以和其他语言从堆栈上分配空间的速度相媲美。

在某些Java虚拟机中，堆地的实现，打个比方：它就像一个传送带，每分配一个新对象，它就往前移动一格。这意味着对象存储空间的分配速度非常快。Java的“堆指针”只是简单地移动到尚未分配的区域，其效率比得上C++在堆栈上分配空同的效率。当然，实际过程中在簿记工作方面还有少量额外开销，但比不上査找可用空间开销大。

Java中的堆未必完全像传送带那样工作。要真是那样的话,势必会导致频繁的内存页面调度——将其移进移出硬盘。因此会显得需要拥有比实际需要更多的内存。页面调度会显著地影响性能，最终，在创建了足够多的对象之后，内存资源将耗尽。其中的秘密在于垃圾回收器的介入。当它工作时，将一面回收空间，一面使堆中的对象紧凑排列，这样“堆指针”就可以很容易移动到更靠近传送带的开始处，也就尽量避免了页面错误。通过垃圾回收器对对象重新排列，实现了一种高速的、有无限空间可供分配的堆模型。

要想更好地理解java中的垃圾回收，先了解其他系统中的拉圾回收机制将会很有帮助。引用记数是一种简单但速度很慢的垃圾回收技术。每个对象都含有一个引用记数器，当有引用连接至对象时，引用计数加1。当引用离开作用域或被置为null时，引用计数减1。虽然管理引用记数的开销不大，但这项开销在整个程序生命周期中将持续发生。垃圾回收器会在含有全部对象的列表上遍历，当发现某个对象的引用计数为0时，就释放其占用的空间（但是，引用记数模式经常会在记数值变为0时立即释放对象）。这种方法有个缺陷，如果对象之间存在循坏引用，可能会出现“对象应该被回收，但引用计数却不为零”的情况。对垃圾回收器而言，定位这样的交互自引用的对象组所需的工作量极大。引用记数常用来说明垃圾收集的工作方式，但似乎从未被应用于任何一种Java虚拟机实现中。

在一些更快的模式中，垃圾回收器并非基于引用记数技术。它们依据的思想是：对任何“活”的对象，一定能最终追溯到其存活在堆栈或静态存储区之中的引用。这个引用链条可能会穿过数个对象层次。由此，如果从堆栈和静态存储区开始，遍历所有的引用，就能找到所有“活”的对象。对于发现的每个引用，必须追踪它所引用的对象，然后是此对象包含的所有引用，如此反复进行，直到“根源与堆栈和静态存储区的引用”所形成的网络全部被访问为止。你所访问过的对象必须都是“活”的。注意，这就解决了“交互自引用的对象组”的问题——这种现象根本不会被发现，因此也就自动回收了。

停止一复制(stop-and-copy)

在这种方式下，Java虚拟机将采用一种自适应的垃圾回收技术。至于如何处理找到的存活对象，取决于不同的Java虚拟机实现。有一种做法名为停止一复制（stop-and-copy）。显然这意味着，先暂停程序的运行（所以它不属于后台回收模式），然后将所有存活的对象从当前堆复制到另一个堆，没有被复制的全部都是拉圾。当对象被复制到新堆时，它们是一个挨着一个的，所以新堆保持紧凑排列，然后就可以按前述方法简单、直接地分配新空间了。

当把对象从一处搬到另一处时，所有指向它的那些引用都必须修正。位于堆或或静态存储区的引用可以直接被修正，但可能还有其他指向这些对象的引用，它们在遍历的过程中才能被找到（可以想像成有个表格，将旧地址映射至新地址）。

对于这种所谓的“复制式回收器”而言，效率会降低，这有两个原因。首先，得有两个堆，然后得在这两个分离的堆之间来回捣腾，从而得维护比实际需要多一倍的空间。某些Java虚拟机对此问题的处理方式是，按需从堆中分配几块较大的内存，复制动作发生在这些大块内存之间。

第二个问题在于复制。程序进入稳、定状态之后，可能只会产生少量垃扱，甚至没有垃圾。尽管如此，复制式回收器仍然会将所有内存自一处复制到另一处，这很浪费。为了避免这种情形，一些Java虚拟机会进行检査：要是没有新垃圾产生，就会转换到另一种工作模式（即“自适应”）。这种模式称为标记一清扫(mark-md-sweep)，Sun公司早期版本的Java虚拟机使用了这种技术。对一般用途而言，“标记一清扫”方式速度相当慢，但是当你知道只会产生少量垃圾甚至不会产生垃圾时,它的速度就很快了。

标记一清扫(mark-md-sweep)

“标记一清扫所依据的思路同样是从堆栈和静态存储区出发，遍历所有的引用，进而找出所有存活的对象。每当它找到一个存活对象，就会给对象设一个标记，这个过程中不会回收任何对象。只有全部标记工作完成的时候，清理动作才会开始。在清理过程中，没有标记的对象将被释放，不会发生任何复制动作。所以剩下的堆空间是不连续的，垃圾回收器要是希望得到连续空间的话，就得重新整理剩下的对象。

“停止一复制”的意思是这种垃圾回收动作不是在后台进行的；相反，垃圾回收动作发生的同时，程序将会被暂停。在Sun公司的文档中会发现，许多参考文献将垃圾回收视为低优先级的后台进程，但事实上垃圾回收器在Sun公司早期版本的Java虚拟机中并非以这种方式实现的。当可用内存数量较低时，Sun版本的垃圾回收器会暂停运行程序，同样，“标记一清扫”工作也必须在程序暂停的情况下才能运行。

自适应的垃圾回收机制

如前文所述，在这里所讨论的Java虚拟机中，内存分配以较大的“块”为単位。如果对象较大，它会占用单独的块。严格来说，“停止一复制”要求在释放旧有对象之前，必须先把所有存活对象从旧堆复制到新堆，这将导致大量内存复制行为。有了块之后，垃圾回收器在回收的时候就可以往废弃的块里拷贝对象了。每个块都用相应的代数（generation count）来记录它是否还存活。通常，如果块在某处被引用，其代数会增加；垃圾回收器将对上次回收动作之后新分配的块进行整理。这对处理大量短命的临时对象很有帮助。垃圾回收器会定期进行完整的清理动作——大型对象仍然不会被复制（只是其代数会增加），内含小型对象的那些块则被复制并整理。Java虚拟机会进行监视，如果所有对象都很稳定，垃圾回收器的效率降低的话，就切换到“标记一清扫”方式；同样，Java虚拟机会跟踪“标记一清扫”的效果，要是堆空间出现很多碎片，就会切换回“停止一复制”方式。这就是“自适应”技术，你可以给它个啰嗦的称呼：“自适应的、分代的、停止一复制、标记一精扫”式垃圾回收器。

即时编译技术（Just-In-Time,JIT）

Java虚拟机中有许多附加技术用以提升速度。尤其是与加载器操作有关的，被称为“即时”(J,-n-Tirne, JIT)编译器的技术。这种技术可以把程序全部或部分翻译成本地机器码（这本来是Java虚拟机的工作），程序运行速度因此得以提升。当需要装载某个类（通常是在为该类创建第一个对象）时，编译器会先找到其.class文件，然后将该类的字节码装入内存。此时，有两种方案可供选择。一种是就让即时编译器编译所有代码。但这种做法有两个缺陷：这种加载动作散落在整个程序生命周期内，累加起来要花更多时问；并且会增加可执行代码的长度（字节码要比即时编译器展开后的本地机器码小很多），这将导致页面调度，从而降低程序速度。另一种做法称为惰性评估（lazy evaluation），意思是及时编译器只在必要的时候才编译代码。这样，从不会被执行的代码也许就压根不会被JIT所编译。新版JDK中的Java HotSpot技术就采用了类似方法，代码每次被执行的时候都会做一些优化，所以执行的次数越多，它的速度就越快。

本文来源《Java编程思想（第四版）》

csdn1428208016

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
初始化与清理

初始化与清理用构造器确保初始化构造器与方法的重载构造器中调用构造器static的含义成员初始化构造器初始化数组初始化清理：终结处理和垃圾回收垃圾回收器如何工作用构造器确保初始化在Java中，通过提供构造器，类的设计者可确保每个对象都会得到初始化。创建对象时，如果其类具有构造器，Java就会在用户有能力操作对象之前自动调用相应的构造器，从而保证了初始化的进行。构造器的命名现在有两个问题：第一，...
复制链接

扫一扫

专栏目录