JAVA 学习日志2 构造器与垃圾收集器（Head First Java 190621）

第九章 构造器与垃圾收集器

1. 栈与堆

关于内存，我们一般会比较在乎内存中的两个区域：对象的生存空间堆（heap）和方法调用及局部变量的生存空间（stack）。

变量一般分为实例变量和局部变量。实例变量声明在类中，存在于所属的对象中。局部变量和方法的参数都是被声明在方法中，它们的生命周期只限于被放在栈上这段周期。

引用变量（‘遥控器’，起连接堆中对象功能，本身不存放）既可以是实例变量也可以为局部变量，分别会放在堆中所属对象里或者所属方法的栈里。

public class Dusk{
	int size;  //实例变量size
}

public void foo(int x){
	int i = x + 3;     //参数x及变量i，b都是局部变量
	boolean b = true;
}

// 为实例变量的引用变量
public class Cellphone{
	private Antenna ant = new Antenna();  
	// 类型为Antenna的引用变量ant被放在生存在堆中的对象Cellphone里，并对应
	// 堆中另一个对象Antenna中
}

// 为局部变量的引用变量
public class StackRef {
	public void foof(){
		Duck d = new Duck(24)；  
		//类型为Duck的引用变量b被放在存于栈中的foof方法中，对应堆中的对象Duck
	}
}

栈的工作模式是将方法堆在一起，调用方法时其会被放进栈中，其中局部变量会被放在一起，直到调用完毕后从栈中被释放出去。如果一个方法中又调用了另一个方法，则第二个方法会被放在第一个方法上面，到第二个方法结束被清除，接着运行完第一个方法，再将其清除。

2. 构造函数概念

构造函数类似方法的调用，但其并不是方法（没有返回类型），是带有new的时候会执行的程序代码。换言之，这段程序代码会在你初始一个对象时执行。

public DuckTestDrive(){
	public static void main (String[] args){
	Duck myDuck = new Duck();    //这里其实就启用了构造函数
	}
}
public  class Duck(){
}
//上面这个程序什么都不会发生，但是在你初始myDuck时，编译器已经在Duck对象中自动写入代码
public Duck(){
}

当你没有在类中写入构造函数的时候，编译器会自动帮你生成一个空的构造函数。你想定义一些功能或者加入一些值的时候，你会自己在对象中编译构造函数。一旦你介入了，编译器就不会再自动生成空的构造函数。（即使你同时还想要一个为空的构造函数，也得手动输入…?）构造函数不会被继承。

3. 构造函数初始化

有时候我们会想要初始化构造函数，这个时候我们会需要在类中建立一个或多个构造函数

public class Duck{
	int size;
	public Duck(int ducksize){
		System.out.println("Quack");
		size = ducksize;
		System.out.println("my duck's size is " + size);
	}
}
public DuckTestDrive(){
	public static void main (String[] args){
	Duck myDuck = new Duck(28);    
	}
}

输出会为

>>> Quack
>>> my duck's size is 28

但并不是所有时候都会输入duck的size，一旦忘记了程序便会出错。这时候我们可以再加入一个构造函数，用它作为没有值输入时默认值的情况。

public class Duck2{
	int size;
	public Duck2(int ducksize){
		System.out.println("Quack");
		size = ducksize;
		System.out.println("my duck's size is " + size);
	}
	public Duck2( ){             //没有值输入时会运行这个默认值构造函数
		System.out.println("Quack");
		size = 20;               //把默认size设为20
		System.out.println("my duck's size is " + size);
		}
}

在一个类中建立多个构造函数能够实现不同的功能，但需要注意的是如果类中有一个以上的构造函数，则参数一定要不一样
Ps: 如果输入是两个参数，其交换位置也当做参数不一样，是可以构造的，例如

public Duck(int size, boolean canfly){...}
public Duck(boolean canfly, int size){...}

4. 构造函数与继承

当类中有新的对象被建立时，构造函数在栈中的生成其实是一步步向上的。假设我们新建议一个类型为HIppo的对象h，Hippo h = new Hippo这行指令产生时，会调用父类的构造函数，导致Animal（）进入栈顶，而animal生成时又会调用父级构造函数，直到最上级object（）被放入栈顶。如果构造函数中有内容，执行时也是从object一路向下执行。

// 其实调用构造函数时，其内部会自动编译super（ ），表示调用父类的构造函数，一直向上延伸
public class Duck extends Animal{
	int size;
	public Duck{
		super();   //编译器自动编入
		size = new size;
	}
}

super（ ）必须在构造函数首句，如果没有人为写入，编译器会自动生成在首句

构造函数中还可以设置参数，并在父类的方法中实现

public abstract class Animal {
	private String name;
	public String getName () {
		return name;
	}
	public Animal (String theName) {
		name = theName;
	}
}
public class Hippo extends Animal {
	public Hippo (String name) {
		super(name);
	}
}
public class MakeHippo {
	public static void main (String[] args) {
		Hippo h = new Hippo("Buffy");
		System.out.println(h.getName());
	}
}

输出为

>>> Buffy

this()也是构造函数中一个重要的方法，它可以调用同一个类中的另外一个构造函数。和super（）一样，this（）也必须放在构造函数内的首句，而且一个构造函数中两者只能存一。

5. 对象及变量的“寿命”

局部变量只会存活在声明该变量的方法中。实例变量的寿命与对象相同，如果对象还活着，那么它便活着。

“life”与“scope” 是指变量还存于堆栈上时，它们就是有生命的。局部变量的范围只限于声明它的方法之内。当此方法调用别方法时，该变量依旧存活，但是不在范围内。在其他方法执行完返回时，其范围又会恢复。

只要有对象引用着，对象就活着。但是一旦失去被引用，对象就会被回收

• 引用永久性离开它的范围

public class StackRef {
	public void foof() {
		bark();
	}
	public void barf() {
		Duck d = new Duck();
	}
}

• 引用被赋值到其他对象上

public class StackRef {
	Duck d = new Duck();
	public void go() {
		d = new Duck();
	}
}

• 直接将引用设定为null

public class StackRef {
	Duck d = new Duck();
	public void go() {
		d = null;
	}
}