读Java编程思想随笔の初始化与清理

　　初始化和清理正式涉及安全的两个问题。

　　如果用户不知道如何初始化库的构件(或者用户必须初始化的其他东西)，更是如此。清理也是一个特殊问题，当使用完一个元素时，它对你也就不会有什么影响，所以很容易把它忘记。这样一来，这个元素占用的资源就会一直得不到释放，结果是资源用尽。

　　用构造器确保初始化

　　在Java中，通过提供构造器，类的设计者可确保每个对象都会得到初始化。创建对象时，如果其类具有构造器，Java就会在用户有能力操作对象之前自动调用相应的构造器，从而保证了初始化的进行。

　　现在创建对象时：new Rock();

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

　　不接受任何参数的构造器叫做默认构造器，Java文档中的术语是无参构造器，但是默认构造器在Java出现之前已经使用许多年了，所以我仍旧倾向于使用它。但是和其他方法一样，构造器也能带有形式参数，以便指定如何创建对象。

　　默认构造器

public class NoSynthesis {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Bird2 b1 = new Bird2(1);
        Bird2 b2 = new Bird2(2.8);
        Bird2 b1 = new Bird2();//no default
    }    
}
class Bird2{
    Bird2 (int i) {}
    Bird2 (double d) {}
}

　　要是你这样写：

　　new Bird2()

　　编译器就会报错：没有找到匹配的构造器。这就好比，要是你没有提供任何构造器，编译器会认为“你需要一个构造器，让我给你制造一个吧”；但假如你已经写了一个构造器，编译器则会认为“啊，你已经写了一个构造器，所以你知道你在做什么；你是可以省略了默认构造器”。

　　this关键字

public class Leaf {
    int i = 0;
    Leaf increment (){
        i++;
        return this;
    }
    void print(){
        System.out.println("i="+i);
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Leaf x = new Leaf();
        x.increment().increment().increment().print();
    }
//    i=3

}

　　由于increment（）通过this关键字返回了对当前对象的引用，所以很容易在一条语句里对同一个对象执行多次操作。

　　this关键字对于当前对象传递给其他方法也很有用。

public class PassingThis {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new Person().eat(new Apple());
    }
}
class Person {
    public void eat(Apple apple){
        Apple peeled = apple.getPeeled();
        System.out.println("Yummy");
    }
}
class Peeler{
    static Apple peel (Apple apple){
        return apple;
    }
}
class Apple {
    Apple getPeeled(){
        return Peeler.peel(this);
    }
}
//Yummy

　　Apple需要调用Peeler.peel()方法，他是一个外部的工具方法，将执行由于某种原因而必须放在apple外部的操作（也许是因为该外部方法要应用于许多不同的类，而你却不想重复这些代码）。为了将自身传递给外部方法，apple必须使用this关键字。

　　static

　　static方法是没有this的方法。在static方法的内部不能调用非静态方法，反过来倒是可以。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static的用途，它很像全局方法。Java中禁止使用全局方法，但你在类中置于static方法就可以访问其他static方法和static域。

　　清理 终结处理和垃圾回收

　　Java有垃圾回收器负责回收无用对象占据的内存资源。但也有特殊情况，假定你的对象并非使用new获得一块特殊的内存区域，由于垃圾回收器只知道回收那些使用new分配的内存，所以它不知道该如何释放对象这块“特殊”的内存。为了应对这种情况，Java允许在类中定义一个名为finalize()方法。它的工作原理“假定”是这样的，一旦垃圾回收器准备好释放对象占用的存储空间，将首先调用finalize()，并且下一次垃圾回收动作发生时，才能真正释放内存。

　　垃圾回收本身就有内存开销

　　垃圾回收期如何工作

　　垃圾回收器对于提高对象的创建速度，却具有明显的效果。听起来很奇怪，存储空间的释放竟然会影响存储空间的分配，但这确实是某些Java虚拟机的工作方式。

　　当它工作时，将一面回收空间，一面使堆中的对象紧凑排列，这样堆指针就可以很容易移动到更靠近传送带的开始处，也就尽量避免了页面错误。通过垃圾回收器对对象的重新排列，实现了一种高速的，有无限空间可供分配的堆模型。

　　静态数据的初始化

　　无论创建多少个对象，静态数据都只占用一份存储区域。static关键字不能用于局部变量，因此它只能作用于域。如果一个域是静态的基本类型域，且也没有对它进行初始化，那么它就会获得基本类型的标准初值；如果它是一个对象的引用，那么它的默认初始化值就是null。

public class StaticInitialization {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("create new Cupboard () in main");
        new Cupboard ();
        System.out.println("create new Cupboard () in main");
        new Cupboard ();
        table.f2(1);
        cupboard.f3(1);
        
    }
    static Table table = new Table ();
    static Cupboard cupboard = new Cupboard ();

}
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);
}


/*
 * Bowl(1)
 * Bowl(2)
 * Table ()
 * f1(1)
 * Bowl(4)
 * Bowl(5)
 * Bowl(3)
 * Cupboard ()
 * f1(2)
 * create new Cupboard () in main                
 * Bowl(3)
 * Cupboard ()
 * f1(2)
 * create new Cupboard () in main
 * Bowl(3)
 * Cupboard ()
 * f1(2)
 * f2(1)
 * f3(1)
 * */
/*1、普通变量初始化优先于静态变量初始化*/
/*2、静态变量初始化只会被执行一次*/

　　显式的静态初始化

public class ExplicitStatic {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("inside main()");
        Cups.cup1.f(99);
    }

}
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()");
    }
}
//inside main()
//Cup(1)
//Cup(2)
//f(99)

　　数组初始化

　　int [] a1 = {1,2,3,4,5}

　　那么，为什么还要在没有数组的时候定义一个数组引用呢？

　　int [] a2

　　在Java中可以将一个数组赋值给另一个数组，所以可以这样：

　　a2 = a1

　　其实真正做的只是复制了一个引用

public class ArraysOfPrimitives {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int [] a1 = {1,2,3,4,5};
        int [] a2 ;
        a2 = a1;
        for (int i = 0; i < a2.length; i++) {
            a2 [i] +=1;
        }
        for (int i = 0; i < a1.length; i++) {
            System.out.println("a1["+i+"]="+a1[i]);
        }
    }
    /**
     * a1[0]=2
     * a1[1]=3
     * a1[2]=4
     * a1[3]=5
     * a1[4]=6
     */
}

　　可变参数列表

　　Object... args

　　String... args

　　Character... args

　　int... args

　　...

　　...

　　可传多个参数，也可不传参数

public class OptionalTrailingArguments {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //f(1,"one");
        //f(1,"one","two");
        //f(0);
        g(0);
        g(1,"one");
        f(2,"one","two");
    }
    static void f (int required,String... trailing) {
        System.out.println("required"+required+"\t");
        for (int i = 0; i < trailing.length; i++) {
            System.out.println(trailing[i]+ "");
        }
        System.out.println();
    }
    static void g (Object... trailing){
        for (int i = 0; i < trailing.length; i++) {
            System.out.println(trailing[i]+ "");
        }
    }

}
//0
//1
//one
//required2    
//one
//two

　　枚举类型

package com.hhl.initialization.enums;
public enum Spiciness {
    NOT,MILD,MEDIUM,HOT,FLAMING
}

package com.hhl.initialization.enums;
public class SimpleEnumUse {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Spiciness s = Spiciness.HOT;
        System.out.println(s);//HOT
    }

}

　　ordinal()方法可返回某个特定enum常量的声明顺序，以及static values()方法返回由这些常量值构成的数组：

public class EnumOrder {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        for (Spiciness s : Spiciness.values()) {
            System.out.println(s+",ordinal:"+s.ordinal());
        }
    }
//    NOT,ordinal:0
//    MILD,ordinal:1
//    MEDIUM,ordinal:2
//    HOT,ordinal:3
//    FLAMING,ordinal:4

}

　　enum有一个特别使用的特性，即它可以和switch语句有完美的配合：

public class Burrito {
    Spiciness s;
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Burrito plain = new Burrito(Spiciness.HOT),
                greenChile = new Burrito(Spiciness.MEDIUM),
                jalapeno = new Burrito(Spiciness.HOT);
        plain.describe ();
        greenChile.describe ();
        jalapeno.describe ();
    }
    public Burrito (Spiciness s) {
        this.s = s;
    }
    void describe () {
        System.out.print("this is burrito");
        switch (s) {
        case NOT: System.out.println(" not spicy at all");break;
        case MILD: 
        case MEDIUM: System.out.println(" a little hot");break;
        case HOT: 
        case FLAMING:
        default: System.out.println(" maybe too hot");
        }
    }
//    this is burrito maybe too hot
//    this is burrito a little hot
//    this is burrito maybe too hot

}