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 valueboolean        falsechar       byte           0short          0int            0long           0float          0.0double         0.0reference      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 initializedMugs()new Mugs() completedMug(1)Mug(2)mug1 & mug2 initializedMugs(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 mainBowl(3)Cupboard()f1(2)Creating new Cupboard() in mainBowl(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 initializedstatic Beetle.x2 initializedBeetle constructori = 9, j = 0Beetle.k initializedk = 47j = 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 constructorDrawing constructorCartoon 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 constructorShape constructorDrawing Line: 0, 0Shape constructorDrawing Line: 1, 1Shape constructorDrawing Line: 2, 4Shape constructorDrawing CircleShape constructorDrawing TriangleCombined constructorCADSystem.dispose()Erasing TriangleShape disposeErasing CircleShape disposeErasing Line: 2, 4Shape disposeErasing Line: 1, 1Shape disposeErasing Line: 0, 0Shape disposeShape 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 0Creating Composing 0Creating Composing 1Creating Composing 2Creating Composing 3Creating Composing 4disposing Composing 0disposing Composing 1disposing Composing 2disposing Composing 3disposing Composing 4Disposing Shared 0*/