第四,五章　控制,初始化与清理

执行流程

While{}do 和do{}while

do{}while(flag) 至少会执行一次，而while(flag){} do 会根据条件判断
for
//这是一个无线循环

for(;;){
}

逗号操作符 可以用逗号分割一系列的语句，语句会独立，他们的类型必须相同.
标签: 用于迭代语句中（唯一的使用场景）例如:

public class ConditionTest {
    public static void main(String[] args) {
        out:
        for (int x = 0; x < 100; x++) {
            inner:
            for (; x < 4; x++) {
                if (x == 3) {
                    break inner;
                }
                System.out.println("inner" + x);
            }
            System.out.println(x);
            if (x == 4) {
                break out;
            }
        }
    }
}
//---output
inner0
inner1
inner2
3
4

Process finished with exit code 0

5.1构造函数确保初始化

注意，因为构造函数必须和类名一致，所以每个方法首字母小写的规则不适合构造函数.构造器是一种特殊的方法，因为他没有返回值．
区分重载的方法只能是参数类型不同，或者参数数量不同．不能通过返回值不同来区分重载．

5.3默认构造器

如果类中没有写任何构造器，编译器会自动生成一个无参构造器，如果类中包含任何参数的构造器，编译器是不会生成无参构造器．（因为这时候编译器会认为你是故意不需要默认构造器）

5.4this关键字

构造器中调用构造器.可以用this,表示符合参数条件的构造函数．
Static 的含义:
因为static 意思就是不没有this对象，所以他不能调用其他非静态方法．因为他无法向对象发送消息，只有对象才能发消息．但是可以通过传引用参数，让引用参数去调用他自身的方法.如果在代码中大量出现static方法，就需要重新考虑自己的设计了．

5.5清理：终结处理和回收

对于某些对象可能不是调用new 获取了一块特殊空间，由于垃圾回收器只知道回收new 分配的内存，所以对这部分特殊的空间，垃圾回收器是无法释放的．这个时候类可以override　finalize(),Object在回收前会触发，垃圾回收器会调用对象的　finalize(),在下次回收的时候便可以真正释放．所以可以在finalize()里做一些清理工作．

需要明白：
　１．对象可能不被垃圾回收
　２．垃圾回收并不等于析构

所以finalize()　里面的做的清理工作，有可能在你离开界面的时候不被调用，也有可能在这一时刻被调用．如果需要很严格的确保离开界面被释放对象，需要手动创建一个执行清理的方法.

5.5.1 finalize　用途何在？

不应该将finalize 作为通用的清理方法.

记住:垃圾回收只与内存有关．

一般在调用其他非java代码创建的对象，java垃圾回收器无法释放内存，比如　调用　本地jni /c/c++ 调用了malloc　系列分配的存储空间，除非调用了free() 函数，否则存储空间将无法得到释放，从而造成内存泄露．当然free()是ｃ/c++的函数，需要用本地方法调用.
可以通过在finalize(){ }做一些对象测试，看看某些很难跟踪的成员有没有及时在该对象释放前做变动．通常是解决一些疑难问题．

java内存回收的方案：＂自适应，分代，mark-copy,mark-sweep＂的　自适应，就是会自动检视当前堆空间处于什么状态，如果是所有对象都相对稳定，垃圾回收器效率比较低，就切换到mark-sweep(标记－清除),如果碎片比较多，自动切换到Copying(停止－复制);分代在新生代　采用停止－复制算法，在老年代　采用mark-sweep算法．

jvm中有一些提升速度的附加技术．有一种叫JIT(just-in-time)这个技术可以把程序全部或者部分翻译成本地机器码， 代替JVM的工作(这部分工作本来是JVM来操作的)．虚拟机要执行某个类的代码，先加载class 文件，然后装进内存中．在这部的时候按理需要进行把程序翻译成本地机器码执行．通过采用JIT技术　可以使用惰性评估(lazy evaluation)在必要时才编译代码，从而可以使得部分不会被执行的代码无需编译，达到提高运行速度．Java hotSpot用到了这技术．

5.6成员初始化

java在成员变量中会进行默认初始化，但是在局部函数里面是不会自动默认初始化变量的，如果在局部函数中需要用到没有初始化的局部变量，编译器是无法编译通过的．
在给变量赋值的时候可以直接把函数值赋予变量，也可以把已经存在的变量当做参数，传给函数，再次赋值给其他变量．但是如果是通过调用函数并且传递另一个变量作为参数时，需要确保该参数的初始化要在调用之前．

public class IniteTest {
    int i = f();
    int j = g(i);
    private int f() {
        return 0;
    }
    private int g(int g) {
        return g;
    }
    public static void main(String[] args) {
    }
}

如果需要用到的变量在需要调用函数之后则无法正常编译．

public class IniteTest {
    int j = g(i);
    int i = f();
    private int f() {
        return 0;
    }
    private int g(int g) {
        return g;
    }
    public static void main(String[] args) {
    }
}
//output
IniteTest.java:9: 错误: 非法前向引用
  int j = g(i);
            ^
１个错误

5.7构造器初始化

成员变量自动初始化，会在构造器初始化变量之前发生．
在类内部，变量的定义顺序决定了初始化的顺序.(也就是说变量初始化顺序只跟，变量在类中定义的顺序有关，变量初始化，会优先构造函数里面调用，而方法的定义只有在第一次调用是才会被初始化)

/**
 * Created by leon on 17-12-13.
 */
class Window {
    public Window(int seq) {
        System.out.println("window" + seq);
    }
}
class House {
    Window w1 = new Window(1);     //---①
    void f() {
        System.out.println("f()");　//---⑤
    }
    House() {
        System.out.println("开始进入构造函数");
        w3 = new Window(3);         //---④
    }
    Window w2 = new Window(2);     //---②
    Window w3 = new Window(3);     //---③
}
public class inilationOrder {
    public static void main(String[] args) {
        House house = new House();
        house.f();
    }
}

//output---
window1
window2
window3
开始进入构造函数
window3
f()

5.7.2静态数据的初始化

无论创建多少个对象，静态数据都只占一份存储区域．就是在方法区，不是在垃圾回收器的堆中．static 不能应用与局部变量，他只能作用于域．因为局部变量是存放在栈中．

/**
 * Created by leon on 17-12-13.
 */
class Bowl {
    Bowl(int marker) {
        System.out.println("Bowl " + marker);
    }
    void f1(int marker) {
        System.out.println("f1 maker" + marker);
    }
}
class Table {
    static Bowl bowl = new Bowl(1);
    Table() {
        System.out.println("Table　构造函数");
        bowl2.f1(1);
    }
    void f2(int maker) {
        System.out.println("f2 maker" + maker);
    }
    static Bowl bowl2 = new Bowl(2);
}
class Cupboad {
    Bowl bowl3 = new Bowl(3);
    static Bowl bowl4 = new Bowl(4);
    Cupboad() {
        System.out.println("Cupboad构造函数");
        bowl4.f1(2);
    }
    void f3(int maker) {
        System.out.println("f3 maker" + maker);
    }
    static Bowl bowl5 = new Bowl(5);
}
public class StaticInitionTest {
    public static void main(String[] args) {
        new Cupboad();
        new Cupboad();
        table.f2(1);
        cupboad.f3(1);
    }
    static Table table = new Table();
    static Cupboad cupboad = new Cupboad();
}
//output---
Bowl 1
Bowl 2
Table　构造函数
f1 maker1
Bowl 4
Bowl 5
Bowl 3
Cupboad构造函数
f1 maker2
Bowl 3
Cupboad构造函数
f1 maker2
Bowl 3
Cupboad构造函数
f1 maker2
f2 maker1
f3 maker1

结果说明　：
1.静态成员变量不论创建多少个实例，都只会创建一次．静态变量不会再次被初始化
2.静态变量的初始化顺序要优先非静态成员变量的顺序
3.构造函数的顺序在成员变量之后

5.7.3 显示静态初始化(静态块/静态子句)

静态块看起来想一个方法，实际上是只是一段跟在　static　　后面的代码，和其他静态化变量的初始化动作一样，这段代码只执行一次．①在首次生成这个对象时，②或则首次访问属于那个类的静态数据成员时.事实证明，只要调用一个类的任意一个静态变量，其他的所有的静态变量都会被初始化，包括静态块里面的．

class BlockBowl {
    BlockBowl(int marker) {
        System.out.println("Bowl " + marker);
    }
    void f1(int marker) {
        System.out.println("f1 maker" + marker);
    }
}
class BlockTable {
    static BlockBowl bowl;
    static BlockBowl bowl2;
    static {
        bowl = new BlockBowl(1);
        bowl2 = new BlockBowl(2);
    }
    BlockTable() {
        System.out.println("Table　构造函数");
        bowl2.f1(1);
    }
    void f2(int maker) {
        System.out.println("f2 maker" + maker);
    }
    BlockBowl bowl3 = new BlockBowl(3);
}
public class StaticBlockTest {
    public static void main(String[] args) {
        System.out.print(BlockTable.bowl);
    }
}
//output-----
Bowl 1
Bowl 2
tinking_in_java.BlockBow

5.8数组初始化

int [] a;
int a[];都可以
为什么不能写成　int a[3] ? 因为在定义区只是申明了一个变量，作为一个数组的引用,没有给他本身分配任何空间．
数组有３中初始化方式:

int a1[] = {1, 2, 3};
int a2[] = new int[]{1, 2, 3};
int a3[] = new int[3];
// int[] arr=new int[3]{1,2,3}  这是不合语法的,因为 int[3] 的意思是分配3个空间大小，
// 同时把所有的值都赋０,而{1,2,3}又是直接赋值　．这两种意义上冲突了．所以语法规定不能这么同时赋值
float[][][] ratings = new float[9][][];
//只需要能确定ratings 数据的长度就可以

5.9枚举类型

eunm　看起来像一个新的数据类型，其实是一个类．java.lang.Enum