Java编程思想ch5 初始化和清理

5.1 用构造器初始化

    new 类名() 将创建和初始化，绑在一起。

5.2 方法重载

5.4 this关键字

class Banana{void peel(int i)}{}
public class BananaPeel{
    public static void main(String[] args){
        Banana a = new Banana(),b = new Banana();
        a.peel(1);
        b.peel(2);
        /*
            只有一个peel，编译器是通过下面方式知道谁调用方法。
            编译器将“所操作对象的引用”作为第一个参数传递给peel()，
            变成Banana.peel(a,1);
                Banana.peel(b,2);
                所以方法内部有一个对象的引用，用this来指代。
                this关键字只能在方法内部使用，表示对“调用方法的那个对象”的引用。
        */
        }
    }
   在非静态方法内部可以直接调用该类的其他方法，会自动将this传入。
    因为调用该非静态方法的时候已经传入了对象的引用。

5.4.2 static的含义

static方法就是没有this传入的方法。在static方法内部不能直接调用非静态方法，即不能像非静态方法一样直接调用该类的非静态方法，因为没有传入对象。（但可以通过传递一个对象引用，用该引用来调用非静态方法）。

5.7 构造器初始化

无法阻止自动初始化的进行。

    public class Counter{
        int i;
        Counter(){i=7;}
    }
    // i先被初始化为0；再赋值为7；

5.7.1 初始化顺序

变量定义即使散落方法定义间，仍旧会在任何方法（包括构造器）被调用之前得到初始化。

package Cha5;
import static tools.Print.print;
/**
 * Created by YL on 2017/9/7.
 */
class Window {
    Window(int marker){print("Window("+marker+")");}
}
class House{
    Window w1 = new Window(1);
    House(){
        print("House()");
        w3 = new Window(33);
    }
    Window w2 = new Window(2);
    void f(){print("f()");}
    Window w3 = new Window(3);
}

public class OrderOfInitialization{
    public static void main(String[] args){
        House h = new House();
        h.f();
    }
}

静态数据的初始化

没有显示写出，但构造方法也是静态的。

调用静态方法和静态域都要先加载这个类。
非静态方法和域因为要通过对象来调用，在用构造器时，因为构造器是静态，已经加载了类。

static 关键字不能用于局部变量，只能作用于域。局部变量是无法成为类的一部分的。

一个静态域，没有初始化：基本类型获得默认值；对象引用为null。

package Cha5;
import static tools.Print.print;

class Bowl{
    Bowl(int marker){
        print("Bowl("+marker+")");
    }
    void f1(int marker){
        print("f1("+marker+")");
    }
}

class Table{
    static Bowl bowl1 = new Bowl(1);
    Table(){
        print("Table()");
        bowl2.f1(1);
    }
    void f2(int marker){
        print("f2("+marker+")");
    }
    static Bowl bowl2 = new Bowl(2);
}

class Cupboard{
    Bowl bowl3 = new Bowl(3);
    static Bowl bowl4 = new Bowl(4);
    Cupboard(){
        print("Cupboard");
        bowl4.f1(2);

    }
    void f3(int marker){
        print("f3("+marker+")");
    }
    static Bowl bowl = new Bowl(5);
}

public class StaticInitialization {
    public static void main(String[] args) {
        print("Creating new Cupboard() in main");
        new Cupboard();
        print("Creating new Cupboard() in main");
        new Cupboard();
        table.f2(1);
        cupboard.f3(1);
    }
    static Table table = new Table();
    static Cupboard cupboard = new Cupboard();
}

output：

/*程序由主函数开始执行，先初始化main函数所在类的变量，table和cupboard。初始化table要调用table构造函数，在此之前，要先初始化Table中静态变量bowl1和bowl2，打印输出的前两行。
初始化顺序是先静态变量，后“非静态”变量。*/

    Bowl(1)
    Bowl(2)
    // Table的构造函数
    Table()
    f1(1)
    // Cupboard类的静态变量初始化。 
    Bowl(4)
    Bowl(5)
    // 非静态变量后初始化。
    Bowl(3)
    //Cupboard构造方法。
    Cupboard
    f1(2)
    // main函数
    Creating new Cupboard() in main
    // 每创建一个对象，就会创建一份非静态成员变量。
    //所以，会执行Cupboard的第一句 Bowl bowl3 = new Bowl(3);
    Bowl(3)
    Cupboard
    f1(2)
    Creating new Cupboard() in main
    Bowl(3)
    Cupboard
    f1(2)
    f2(1)
    f3(1)

5.7.3 显示的静态初始化

静态块–这段代码只执行一次：当首次生成这个类的一个对象时，或者首次访问那个类的静态数据成员时（即便从未生成那个类的对象）。

package Cha5;
import static tools.Print.print;

class Cup{
    Cup(int marker){
        print("Cup("+marker+")");
    }
    void f(int marker){
        print("f("+marker+")");
    }
}

class Cups{
    static Cup cup1;
    static Cup cup2;
    static{
        cup1 = new Cup(1);
        cup2 = new Cup(2);
    }
    Cups(){
        print("Cups()");
    }
}
public class ExplicitStatic {
    public static void main(String[] args) {
        print("Inside main()");
        Cups.cup1.f(99);
    }
}
Output:
    // main函数打印
    Inside main()
    // 调用Cups的静态成员变量cup1，会加载这个类。先初始化静态变量和执行静态代码块。
    // 打印Cup(1);
    Cup(1)
    Cup(2)
    f(99)

5.7.4 非静态实例初始化

package Cha5;
import static tools.Print.print;

class Mug{
    Mug(int marker){
        print("Mug("+marker+")");
    }
    void f(int marker){
        print("f("+marker+")");
    }
}

public class Mugs {
    Mug mug1;
    Mug mug2;
    // 没有static，每次新建一个Mugs对象，
    // 都会执行一次，因为每个对象都有自己的域。
    {
        mug1 = new Mug(1);
        mug2 = new Mug(2);
        print("mug1 & mug2 initialized");
    }
    Mugs(){
       print("Mugs()");
    }
    Mugs(int i){
        print("Mugs(int)");
    }
    public static void main(String[] args){
        print("Inside main()");
        new Mugs();
        print("new Mugs() completed");
        new Mugs(1);
        print("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

5.8 数组初始化

int[] a 和 int a[] 都是合理的。

// 只能用于方法定义处

Integer[] a = {new Integer(1), new Integer(2), 3,};

// 可以用于任何地方

Integer[] a = new Integer[] {new Integer(1), new Integer(2), 3,};

5.9 枚举类型

package Cha5;

enum Spiciness{
NOT,MILD,MEDIUM,HOT,FLAMING
}

public class Burrito {
Spiciness degree;
public Burrito(Spiciness degree){
    this.degree = degree;
}
public void dedcribe(){
System.out.print("This burrito is");
    switch(degree){
        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");
    }
}

public static void main(String[] args) {
    Burrito
    plain = new Burrito(Spiciness.NOT);
    Burrito greenChile = new Burrito(Spiciness.MEDIUM);
    Burrito jalapeno = new Burrito(Spiciness.HOT);
    plain.dedcribe();
    greenChile.dedcribe();
    jalapeno.dedcribe();
}

}
This burrito isnot spicy at all
This burrito isa little hot
This burrito ismaybe too hot