Java基础：初始化与清理

1、构造器

每个类都必须至少有一个构造器，如果没有显式的定义，编译器会自动为该类创建一个隐式的无参构造器（无参构造器也称为默认构造器）。

构造器没有返回值，不会返回任何东西（返回值为空和没有返回值是两码事），但是下面的语句会让人疑惑：

Object object = new Object();

实际上是new表达式返回了新建对象的引用，构造器没有返回任何东西。

2、方法的重载

方法名、方法参数表（参数数量、参数类型、参数顺序）区分了两个的方法。

改变参数顺序也可以实现方法重载，但是不推荐使用，因为不利于维护和使用。一般是利用参数数量、类型来实现方法重载。

由于基本类型能从一个“较”小的类型自动提升到一个“较大”的类型，所以当重载涉及到基本类型时，容易发生混淆。看下面的代码：

import static java.lang.System.*;

public class Overload {

    /**
     * @param args
     */
    public static void main(String[] args) {
        byte b = 1;
        char c = 1;
        short s = 1;
        int i = 1;
        long l = 1;
        float f = 1;    //f=1 没有问题，因为1是整数，可以被提升为float而不丢失精度
        //! float f = 1.0;    //f=1.0则会提示错误，因为小数默认是double。需要进行强制类型转换，或者通过 f=1.0F 明确告诉编译器我要定义一个float型数据
        double d = 1;    // d=1,提升为double，正确； d=1.0,正确。

        
        Overload ol = new Overload();
        ol.f1(1); //整数字面常量被看做是int型，所以调用f1(int i)
        ol.f1(1.0); //小数字面常量被看做是double型，所以调用f1(double i)
        
        //! ol.f2(b);    //错误，byte不会被自动提升到char
        //! c=b            //错误，byte不会被自动提升到char
        ol.f3(b);         //byte会自动提升到short，所以调用f3(short i)
        
        //首先寻找完全匹配的方法，有则调用，反之如果实际传入的数据类型小于方法声明的形参类型，实参会被就近提升，然后调用相应的方法。自动转型遵循下面规律：
        //byte < short < int < long < float < double
        //char < int < long < float < double

    }
    
    void f1(byte i) {
        out.println("f1(byte i)");
    }
    void f1(char i) {
        out.println("f1(char i)");
    }
    void f1(short i) {
        out.println("f1(short i)");
    }
    void f1(int i) {
        out.println("f1(int i)");
    }
    void f1(long i) {
        out.println("f1(long i)");
    }
    void f1(float i) {
        out.println("f1(float i)");
    }
    void f1(double i) {
        out.println("f1(double i)");
    }
    
    void f2(char i) {
        out.println("f2(char i)");
    }
    void f3(short i) {
        out.println("f3(short i)");
    }
}

注意，不能用返回值类型来区分方法

3、this

表示调用方法的当前对象的引用，只能在方法内部使用。

this对于将当前对象传递给其他方法也很有用，例如：

class Peeler {
    static Apple peel(Apple apple) {
        //...
        //...
        return apple;
    }
}

class Apple {
    Apple getPeeled() {
        return Peeler.peel(this);    //为了将自身传递给外部方法，Apple必须使用this关键字
    }
}

this的另一种用法是在一个构造器中调用另一个，但是必须位于构造器方法体的第一行。

static方法中不存在this

4、类被加载的时机

当调用类中的静态成员变量、静态方法、创建该类的对象时，即使用该类时，类才被加载。

5、初始化顺序

类被加载时，静态成员、静态块中的变量依照定义顺序完成初始化；

创建对象时，先完成静态成员、静态块中的变量的初始化，然后初始化非静态成员，最后调用构造器。

静态成员、静态块中的变量尽在类被加载时被初始化一次，之后不再被初始化。

public class Initialization {
    public static void main(String[] args) {
        Cups cups = new Cups();
        Cups cups2 = new Cups();
        Cup cup_ = Cups.cup1;
        Cup[] cup_arr = {new Cup(12),new Cup(11)};
        //! Cup cup8 = Cups.cup7;    //error, can not be seen 
    }
}

class Cup {
    public Cup(int i) {
        System.out.println("cup is "+i);
    }
    void f(int i) {
        System.out.println("f() is "+i);
    }
}

class Cups {
    static Cup cup1, cup2, cup3 = new Cup(3);
    Cup cup4 = new Cup(4), cup5;
    static {
        cup1 = new Cup(1);
        cup2 = new Cup(2);
        cup3 = new Cup(33);
        Cup cup7 = new Cup(7);        //local variable
    }
    public Cups() {
        System.out.println("Cups()");
    }
    static Cup cup6 = new Cup(6);
}
//output：
/*
cup is 3
cup is 1
cup is 2
cup is 33
cup is 7
cup is 6
cup is 4
Cups()
cup is 4
Cups()
cup is 12
cup is 11
*/

静态块中，

a、其所操作的field须是静态的

b、静态的field初始化顺序与其定义顺序一致，包括静态块中的初始化语句

c、静态块中定义的变量时局部变量，但同样是静态的。如上面的cup7。

6、数组初始化

数组属于对象，数组变量是其引用。

int [] array = new int[8];    //array是一个数组引用，它指向一个int型数组对象

三种定义数组的方式：

int [] int_arr_1 = {1,2,3};
Object [] obj_arr_2 = {new Object(), new Object()};
//这种方式下,数组的初始化必须位于数组的定义处

int [] int_arr_2 = new int[3];
for(int i = 0; i<3; i++) {
    int_arr_2[i] = i;
}
//这种定义方式在定义时为数组对象本省分配了空间，数组元素执行默认初始化，即如果是基本类型的数组，初始化为基本类型的默认初始值；如果是引用类型的数组，则初始化为空，此时在使用数组元素之前需要对数组元素进行初始化，使其指向一个实际的对象

int [] int_arr_1 = new int[]{1,2,3};
Object [] obj_arr_2; 
obj_arr_2 = new Object[]{new Object(), new Object()};
//这种初始化的位置很随意，多用与方法调用，如：

//方法定义
void test(String[] s) {//...}
//方法调用
test(new String[]{"now", "you", "see"});

下面这种方式是正确的

Integer arr = {new Integer(1), new Integer(2), 3};
//SE 5出现的auto-boxing功能

7、可变参数

public class Initialization {
    static void printArray(Object... args) {
        for (Object object : args) {
            System.out.println(object + "------" + object.getClass());
        }
    }
    
    public static void main(String[] args) {
        printArray(1, 2, 3);//自动包装
        printArray(new Integer(11),new Integer(12));
        printArray(new Integer(11),new Float(3.14));
        printArray(47,3.14f,11.11);
        printArray(new Integer[] {41,42,43,44});//提示：The argument of type Integer[] should explicitly be cast to Object[] 
                                                //for the invocation of the varargs method printArray(Object...) from 
                                                //type Initialization. It could alternatively be cast to Object for 
                                                //a varargs invocation
        printArray((Object[])new Integer[] {413,423,433,443});
        printArray();                            //可以为空        
    }
}
//output
/*
1------class java.lang.Integer
2------class java.lang.Integer
3------class java.lang.Integer
11------class java.lang.Integer
12------class java.lang.Integer
11------class java.lang.Integer
3.14------class java.lang.Float
47------class java.lang.Integer
3.14------class java.lang.Float
11.11------class java.lang.Double
41------class java.lang.Integer
42------class java.lang.Integer
43------class java.lang.Integer
44------class java.lang.Integer
413------class java.lang.Integer
423------class java.lang.Integer
433------class java.lang.Integer
443------class java.lang.Integer
*/

涉及重载时，考虑基本数据类型的提升问题

static void F(Character... args) {
    System.out.println("Character... args");
}

static void F(float f, Character... args) {
    System.out.println("Character... args");
}

public static void main(String[] args) {
    F(1,'2');
    //!F('2','2');//'2'能够被提升为float，造成歧义，编译器不知道应该调用哪个函数
}

static void F(Character c, Character... args) {
    System.out.println("Character... args");
}

static void F(float f, Character... args) {
    System.out.println("Character... args");
}

public static void main(String[] args) {
    F(1,'2');
    //F('2','2');//依旧造成歧义！！！！！！！！！！！！！！！！
}

如果改成这样就是可以的

static void F(char c, Character... args) {
    System.out.println("Character... args");
}

static void F(float f, Character... args) {
    System.out.println("Character... args");
}

public static void main(String[] args) {
    F(1,'2');
    F('2','2');//完全匹配,调用第一个F
}