java基础---->对象的创建过程（初始化、析构、清理)
一、成员初始化
1、方法的成员局部变量，以编译时错误保证初始化。
2、类的每一个基本类型数据成员会保证有一个初始值。
public class InitialValues {
boolean t;
char c;
byte b;
short s;
int i;
long l;
float f;
double d;
InitialValues reference;
void printInitialValues() {
System.out.println("Data type Initial value");
System.out.println("boolean " + t);
System.out.println("char " + c);
System.out.println("byte " + b);
System.out.println("short " + s);
System.out.println("int " + i);
System.out.println("long " + l);
System.out.println("float " + f);
System.out.println("double " + d);
System.out.println("reference " + reference);
}
public static void main(String[] args) {
new InitialValues().printInitialValues();
}
} /* Output:
Data type Initial value
boolean false
char
byte 0
short 0
int 0
long 0
float 0.0
double 0.0
reference null
*/
3、指定初始化：在定义变量的地方为其赋值
4、构造器初始化：在构造方法里面初始化。
在一个类里，初始化的顺序是由变量在类内的定义顺序决定的。即使变量定义大量遍布于方法定义的中间，那些变量仍会在调用任何方法之前得到初始化——在构建器调用之前。
若数据是静态的（static），那么同样的事情就会发生；如果它属于一个基本类型，而且未对其初始化，就会自动获得自己的标准基本类型初始值；如果它是指向一个对象的句柄（引用），那么除非新建一个对象，并将句柄（引用）同它连接起来，否则就会得到一个空值（NULL）。
二、静态块
静态块：使用static关键字声明的代码块，静态代码块在第一次加载类时执行，而且只执行一次，当访问类的静态属性或者方法，创建类对象，或者执行该类的main方法之前，都要加载类。可以用来为静态变量初始化。在主类中定义的静态块将优先于主方法main()执行。而且可以发现静态块优先于构造块执行.
class Cup {
Cup(int marker) {
System.out.println("Cup(" + marker + ")");
}
void f(int marker) {
System.out.println("f(" + marker + ")");
}
}
class Cups {
static Cup cup1;
static Cup cup2;
static {
cup1 = new Cup(1);
cup2 = new Cup(2);
}
Cups() {
System.out.println("Cups()");
}
}
public class ExplicitStatic {
static {
System.out.println("静态块在类加载时候执行");
}
public static void main(String[] args) {
System.out.println("Inside main()");
Cups.cup1.f(99);
}
} /*
* Output:
静态块在类加载时候执行
Inside main()
Cup(1)
Cup(2)
f(99)
*/
可以使用静态块“替代”掉main方法。
static {
System.out.println("HelloWorld!!!") ;
System.exit(1);
}
三、非静态实例初始化（构造块）
构造块：在一个类中定义的代码块，构造块会优先于构造方法执行，而且每当一个新的实例化对象产生时，都会调用构造块，会调用多次。用于初始化对象的非静态变量。
class Mug {
Mug(int marker) {
System.out.println("Mug(" + marker + ")");
}
void f(int marker) {
System.out.println("f(" + marker + ")");
}
}
public class Mugs {
Mug mug1;
Mug mug2;
{
mug1 = new Mug(1);
mug2 = new Mug(2);
System.out.println("mug1 & mug2 initialized");
}
Mugs() {
System.out.println("Mugs()");
}
Mugs(int i) {
System.out.println("Mugs(int)");
}
public static void main(String[] args) {
System.out.println("Inside main()");
new Mugs();
System.out.println("new Mugs() completed");
new Mugs(1);
System.out.println("new Mugs(1) completed");
}
} /*Output:
Inside main()
Mug(1)
Mug(2)
mug1 & mug2 initialized
Mugs()
new Mugs() completed
Mug(1)
Mug(2)
mug1 & mug2 initialized
Mugs(int)
new Mugs(1) completed
*/
四、Java对象的创建过程
4.1不涉及继承
假设有个名为Dog的类
1.当首次创建型为Dog的对象时（构造器可以看成静态方法），或者Dog类的静态方法/静态域首次被访问时，Java解释器必须查找类路径，以定位Dog.class文件。
2.然后载入Dog.class（这将创建一个Class对象），有关静态初始化的动作都会执行。因此，静态初始化只在Class对象首次加载的时候进行一次。
3.当你用newDog()创建对象的时候，首先将在堆上为Dog对象分配足够的存储空间。
4.这块存储空间会被清零，这就自动地将Dog中的所有基本类型数据设置成了默认值（对数字来说就是0，对布尔型和字符型也相同），而引用则被置成了null。
5.执行所有出现于域定义处的初始化动作。
6.执行构造器。
例子如下：
class Bowl {
Bowl(int marker) {
System.out.println("Bowl(" + marker + ")");
}
void f1(int marker) {
System.out.println("f1(" + marker + ")");
}
}
class Table {
static Bowl bowl1 = new Bowl(1);
Table() {
System.out.println("Table()");
bowl2.f1(1);
}
void f2(int marker) {
System.out.println("f2(" + marker + ")");
}
static Bowl bowl2 = new Bowl(2);
}
class Cupboard {
Bowl bowl3 = new Bowl(3);
static Bowl bowl4 = new Bowl(4);
Cupboard() {
System.out.println("Cupboard()");
bowl4.f1(2);
}
void f3(int marker) {
System.out.println("f3(" + marker + ")");
}
static Bowl bowl5 = new Bowl(5);
}
public class StaticInitialization {
public static void main(String[] args) {
System.out.println("Creating new Cupboard() in main");
new Cupboard();
System.out.println("Creating new Cupboard() in main");
new Cupboard();
table.f2(1);
cupboard.f3(1);
}
static Table table = new Table();
static Cupboard cupboard = new Cupboard();
} /* Output:
Bowl(1)
Bowl(2)
Table()
f1(1)
Bowl(4)
Bowl(5)
Bowl(3)
Cupboard()
f1(2)
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f1(2)
Creating new Cupboard() in main
Bowl(3)
Cupboard()
f1(2)
f2(1)
f3(1)
*/
4.2涉及了继承的情况：
class Insect {
private int i = 9;
protected int j;
Insect() {
System.out.println("i = " + i + ", j = " + j);
j = 39;
}
private static int x1 = printInit("static Insect.x1 initialized");
static int printInit(String s) {
System.out.println(s);
return 47;
}
}
public class Beetle extends Insect {
private int k = printInit("Beetle.k initialized");
public Beetle() {
System.out.println("k = " + k);
System.out.println("j = " + j);
}
private static int x2 = printInit("static Beetle.x2 initialized");
public static void main(String[] args) {
System.out.println("Beetle constructor");
Beetle b = new Beetle();
}
} /* Output:
static Insect.x1 initialized
static Beetle.x2 initialized
Beetle constructor
i = 9, j = 0
Beetle.k initialized
k = 47
j = 39
*/
假设有个名为Cartoon的类，继承自Drawing，Drawing又继承自Art
class Art {
static {System.out.println("Art 的静态块");}
Art() {
System.out.println("Art constructor");
}
}
class Drawing extends Art {
static {System.out.println("Drawing的静态块");}
Drawing() {
System.out.println("Drawing constructor");
}
}
public class Cartoon extends Drawing {
static {System.out.println("Cartoon的静态块");}
public Cartoon() {
System.out.println("Cartoon constructor");
}
public static void main(String[] args) {
Cartoon x = new Cartoon();
}
}
/*Output:
Art 的静态块
Drawing的静态块
Cartoon的静态块
Art constructor
Drawing constructor
Cartoon constructor
*/
1.当首次创建型为Cartoon的对象时，Java解释器查找类路径，定位Cartoon.class文件。
2.Java解释器会根据Cartoon.class定位其基类Drawing.class、再根据Drawing.class定位到基类Art.class文件，有关静态初始化的动作从基类到子类依次执行。
3.当你用new Cartoon()创建对象的时候，首先将在堆上为Cartoon对象（包括其基类Drawing和Art中的域）分配足够的存储空间。
4.这块存储空间会被清零，这就自动地将Cartoon中的所有基本类型数据（包括其基类Drawing和Art中的）设置成了默认值（对数字来说就是0，对布尔型和字符型也相同），而引用（包括其基类Drawing和Art中的）则被置成了null。
5.执行基类Art中所有出现于域定义处的初始化动作。
6.执行基类Art构造器。
7.执行基类Drawing中所有出现于域定义处的初始化动作。
8.执行基类Drawing构造器。
9.执行子类Cartoon中所有出现于域定义处的初始化动作。
10.执行子类Cartoon构造器。
即：class是从子类到基类依次查找，有关静态初始化的动作从基类到子类依次执行。
在为所创建对象的存储空间清零后,找到继承链中最上层的基类,执行a、b两步：
a.执行其出现在域定义处的初始化动作
b.然后再执行其构造器
然后从基类到子类依次执行这两步操作。
五、析构函数finalize（）
5.1 finalize()方法
一旦垃圾回收期准备释放对象所占的存储空间，首先调用其finalize()方法
1、 对象可能不被垃圾回收
只要程序没有濒临存储空间用完的那一刻，对象占用的空间就总也得不到释放。如果程序执行结束，垃圾回收器一直没有释放你创建的对象的存储空间，则随着程序退出，那些资源也会交还给操作系统。因为垃圾回收本身也要开销，如果不使用它，那就不用支付这部分开销了。
2、 垃圾回收并不等于析构，垃圾回收器不能替代析构函数（如在finalize（）加入擦擦屏幕图像的功能）
3、 垃圾回收只与对象占用的内存有关。如可以通过finalize释放通过native方法获得的内存。
class Order {
protectedvoid finalize() throws Throwable {
super.finalize();
System.out.println("调用析构方法");
}
}
publicclass TestFinalize {
publicstatic void main(String[] args) {
Order order =new Order();
order = null;
new Order();
System.gc(); // 会打印
for (int i = 0; i < 100; i++) {// 不会输出，因为内存没用完垃圾回收器不起作用，当改成i<10000000时候会打印，
Order order1 =new Order();
}
}
}
/*
* Output调用析构方法调用析构方法
*/
1、只有内存用完了，垃圾回收器起作用，才会调用finalize()方法
Order order =new Order();System.gc();如果内存没用完，它是不会浪费时间去执行垃圾回收区回复内存的。
也不会调用finalize（）方法
2、手动调用System.gc() 除非指向堆空间的引用为0，才会调用finalize（）方法
order =null; System.gc()
new Order(); System.gc()
5.2、Finalize可能的使用方式：
用于对象总结条件的验证
class Book {
boolean checkedOut =false;
Book(boolean checkOut) {
checkedOut = checkOut;
}
void checkIn() {
checkedOut = false;
}
protectedvoid finalize() {
if (checkedOut)
System.out.println("Error: checked out");
// Normally, you'll also do this:
// super.finalize(); // Call the base-class version
}
}
public class TerminationCondition {
public static void main(String[] args) {
Book novel = new Book(true);
// Proper cleanup:
novel.checkIn();
// Drop the reference, forget to clean up:
new Book(true);
// Force garbage collection & finalization:
System.gc();
}
}/* Output:
Error: checked out
*/
5.3编写自己的清理方法
一旦涉及到垃圾回收，能够信赖的事情就不多了。垃圾回收器可能永远无法调用，即使被调用，他也可能以任何他想要的顺序来回收对象。最好的办法是出了内存外，不能依靠垃圾回收去做任何事。如果需要清理，最好编写自己的清理方法，但不要使用finalize（）。
class Shape {
Shape(int i) {
System.out.println("Shape constructor");
}
void dispose() {
System.out.println("Shape dispose");
}
}
class Circle extends Shape {
Circle(int i) {
super(i);
System.out.println("Drawing Circle");
}
void dispose() {
System.out.println("Erasing Circle");
super.dispose();
}
}
class Triangle extends Shape {
Triangle(int i) {
super(i);
System.out.println("Drawing Triangle");
}
void dispose() {
System.out.println("Erasing Triangle");
super.dispose();
}
}
class Line extends Shape {
private int start, end;
Line(int start, int end) {
super(start);
this.start = start;
this.end = end;
System.out.println("Drawing Line: " + start + ", " + end);
}
void dispose() {
System.out.println("Erasing Line: " + start + ", " + end);
super.dispose();
}
}
public class CADSystem extends Shape {
private Circle c;
private Triangle t;
private Line[] lines = new Line[3];
public CADSystem(int i) {
super(i + 1);
for (int j = 0; j < lines.length; j++)
lines[j] = new Line(j, j * j);
c = new Circle(1);
t = new Triangle(1);
System.out.println("Combined constructor");
}
public void dispose() {
System.out.println("CADSystem.dispose()");
// The order of cleanup is the reverse
// of the order of initialization:
t.dispose();
c.dispose();
for (int i = lines.length - 1; i >= 0; i--)
lines[i].dispose();
super.dispose();
}
public static void main(String[] args) {
CADSystem x = new CADSystem(47);
try {
// Code and exception handling...
} finally {
x.dispose();
}
}
} /* Output:
Shape constructor
Shape constructor
Drawing Line: 0, 0
Shape constructor
Drawing Line: 1, 1
Shape constructor
Drawing Line: 2, 4
Shape constructor
Drawing Circle
Shape constructor
Drawing Triangle
Combined constructor
CADSystem.dispose()
Erasing Triangle
Shape dispose
Erasing Circle
Shape dispose
Erasing Line: 2, 4
Shape dispose
Erasing Line: 1, 1
Shape dispose
Erasing Line: 0, 0
Shape dispose
Shape dispose
*/
5.4 对象被共享时，清理时使用引用计数判断
成员对象中存在一个或多个对象共享的情况，必须使用引用计数来跟踪访问着共享对象的对象数量
class Shared {
private int refcount = 0;
private static long counter = 0;
private final long id = counter++;
public Shared() {
System.out.println("Creating " + this);
}
public void addRef() {
refcount++;
}
protected void dispose() {
if (--refcount == 0)
System.out.println("Disposing " + this);
}
public String toString() {
return "Shared " + id;
}
}
class Composing {
private Shared shared;
private static long counter = 0;
private final long id = counter++;
public Composing(Shared shared) {
System.out.println("Creating " + this);
this.shared = shared;
this.shared.addRef();
}
protected void dispose() {
System.out.println("disposing " + this);
shared.dispose();
}
public String toString() {
return "Composing " + id;
}
}
public class ReferenceCounting {
public static void main(String[] args) {
Shared shared = new Shared();
Composing[] composing = { new Composing(shared), new Composing(shared),
new Composing(shared), new Composing(shared),
new Composing(shared) };
for (Composing c : composing)
c.dispose();
}
}
/*Output:
Creating Shared 0
Creating Composing 0
Creating Composing 1
Creating Composing 2
Creating Composing 3
Creating Composing 4
disposing Composing 0
disposing Composing 1
disposing Composing 2
disposing Composing 3
disposing Composing 4
Disposing Shared 0
*/
