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