北冥有鱼 记录生活点滴，分享学习心得

Java

Java编程思想学习笔记（六）

第五章 初始化与清理(2)

Posted by YuChen on October 12, 2017

1.成员初始化

  • Java尽力保证：所有变量在使用前都能得到恰当的初始化。
  • 对于方法的局部变量，Java以编译时错误的形式来贯彻这种保证。
  • 对于类的成员变量：
Data type Initial value
boolean false
char 值为0，输出为空白
byte 0
short 0
int 0
long 0
float 0.0
double 0.0
对象引用 null

2.定义时初始化

  • 最直接的办法：在定义类成员变量的地方为其赋值(在C++里不能这样做)。
    • 上述方法同样适用于非基本类型的对象，如下：
1
2
3
4
5
6
7
8
9
10
11
12

	class Depth{
		//...
	}

	public class Measurement{
		Depth d = new Depth();
		int i = f();
		int j = g(i);
		int f(){return 11;}
		int g(int n){return n*10;}
		//...
	}

注意：
1.若是没有为d指定初始值就尝试使用它，会出现运行时错误，产生异常。
2.也可以通过调用某个方法来提供初值。
3.上述初始化方法的限制：所定义类的每个对象都会具有相同的初值，不灵活。

3.构造器初始化

  • 可以使用构造器进行初始化。在运行时，可以调用方法或执行某些动作来确定初值，这为编程带来了更大的灵活性。 
    1
2
3
4
5
6
7

    //: initialization/Counter.java
package initialization; /* Added by Eclipse.py */
public class Counter {
int i;
Counter() { i = 7; }
// ...
} ///:~

    注意:
    无法阻止字段初始化的进行，它将在构造器被调用前发生。（上述，i首先被置为0，然后变成7。）对于所有基本类型和对象引用，包含定义时已经指定初值的变量，这种情况都成立。

  • 对象创建的过程总结如下： 对象创建过程
    注意:
    1.初始化的顺序是先静态对象（若它们尚未因前面的对象创建过程而被初始化），而后是”非静态”对象。
    2.调用一个类的静态方法或访问一个类的静态域，会导致其所有的静态成员变量都会初始化（若它们尚未因前面的对象创建过程而被初始化），但是”非静态”成员变量不会被创建（”非静态”对象只有使用new操作时才会被创建）。
    3.调用一个类的静态方法时，会先初始化所有静态成员变量，再执行该静态函数。

示例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

package io.github.wzzju;
import static io.github.wzzju.util.Print.*;

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

public class StaticInitialization {
  public static void main(String[] args) {
    print("Creating new Bowl in main");
    new Bowl(66);
//    new StaticInitialization();
  }
  static Bowl bowl1 = new Bowl(1);
  Bowl bowl3 = new Bowl(33);
  static Bowl bowl2 = new Bowl(2);
}/*output:
Bowl(1)
Bowl(2)
Creating new Bowl in main
Bowl(66)
*/

程序运行时，先初始化bowl1，再初始化bowl2，而bowl3不会被初始化，因为程序启动仅仅调用了静态函数main，没有使用new创建该类。最后执行main函数中的语句。将// new StaticInitialization();行的注释去掉，运行结果如下：

1
2
3
4
5
6
7

/*output:
Bowl(1)
Bowl(2)
Creating new Bowl in main
Bowl(66)
Bowl(33)//bowl3被初始化
*/

从上述结果亦可以看出，若类中的静态对象因前面的对象创建过程（或对静态函数/静态域的访问过程）而被初始化，则不会被再次初始化。

  • 显示的静态初始化
    静态子句(静态块)如下： 
    1
2
3
4
5
6
7
8
9
10

    //: initialization/Spoon.java
package initialization; /* Added by Eclipse.py */
public class Spoon {
static int i;
static double d;
static {
  i = 47;
  d = 3.6;
}
} ///:~

    与其他静态初始化动作一样，这段代码仅执行一次：当首次生成这个类的一个对象时，或者首次访问属于这个类的静态数据成员时（即便从未生成过那个类的对象）。

  • 非静态实例初始化
    以下模式用于初始化每个对象的非静态变量： 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

    public class Mugs {
Mug mug1;
Mug mug2;
{
  mug1 = new Mug(1);
  mug2 = new Mug(2);
  print("mug1 & mug2 initialized");
}
Mugs() {
  print("Mugs()");
}
Mugs(int i) {
  print("Mugs(int)");
}
}

    上述模式可以保证无论调用哪个显示构造器，某些操作都会发生（{}内的初始化操作）。实例初始化子句是在构造器之前执行的。

4.数组初始化

  • int[] a1;或int a1[];定义了一个数组的引用。在定义的时候不允许指定数组的大小。
  • 对于数组，初始化动作可以出现在代码的任何地方，但也可以使用一种特殊的初始化表达方式，它必须在创建数组的地方出现。如：int[] a1 = {1,2,3,4};。
  • 数组元素下标从0开始，最大下标数是length-1。
  • 在Java中，一旦对数组的访问下标过界，就会出现运行时错误（即异常）。
  • 可以直接用new在数组里创建元素。尽管创建的是基本类型数组。new仍然可以工作（不能用new创建单个的基本类型）。
  • 如果可能，尽量在数组定义的同时进行初始化，如int[] a = new int[10];(第一种初始化方法，不灵活，只能用于定义处)。
    注意：使用第一种方法初始化之后，每个数组元素都被初始化为类型所对应的零值(若为非基本类型的数组，则每个数组元素值为null，此时要对每个数组元素使用new操作赋值)。
    第二种数组初始化方法： 
    1
2
3
4
5

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

    第三种初始化方法：

    1
2
3
4
5

      Integer[] b = new Integer[]{
    new Integer(1),
    new Integer(2),
    3, // Autoboxing
  };

    在第二、第三种初始化方法中，初始化列表的最后一个逗号都是可选的。

5.可变参数列表

形式如下：

1
2
3

static void print(Object... args){}  

static void print(int required,String... args){}

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class A {}
public class NewVarArgs {
  static void printArray(Object... args) {
    for(Object obj : args)
      System.out.print(obj + " ");
    System.out.println();
  }
  public static void main(String[] args) {
    // Can take individual elements:
    printArray(new Integer(47), new Float(3.14),
      new Double(11.11));
    printArray(47, 3.14F, 11.11);
    printArray("one", "two", "three");
    printArray(new A(), new A(), new A());
    // Or an array:<1>
    printArray((Object[])new Integer[]{ 1, 2, 3, 4 });
    printArray(); // Empty list is OK
  }
} /* Output: (75% match)
47 3.14 11.11
47 3.14 11.11
one two three
A@1bab50a A@c3c749 A@150bd4d
1 2 3 4
*///:~

说明：

  • 编译器会将可变参数转换为一个数组。所有在代码中可以使用foreach来迭代可变参数。若传递来的实参已经是一个数组，则编译器不会再执行转换。若传递来的实参不只一个数组（两个以上），则编译器会将其转换为数组的数组。 在上例中，<1>处若换成printArray((Object[])new Integer[]{ 1, 2, 3, 4 },(Object[])new Integer[]{ 6, 7, 8, 9 });，则会对应输出[Ljava.lang.Integer;@70dea4e [Ljava.lang.Integer;@5c647e05 （输出中[表示这是一个后面紧随的类型的数组）。
  • 在可变参数列表中可以使用任何类型的参数，包括基本类型。 如：static void f(Character... args)、static void f(int... args)等。
  • 作者的建议：可变参数列表使得重载变得很复杂，故而：我们应该总是只在重载方法的一个版本上使用可变参数列表，或在重载时压根不使用它。

6.枚举类型–enum

使用方法示例：

1
2
3
4
5
6
7
8
9
10
11

public enum Spiciness {
  NOT, MILD, MEDIUM, HOT, FLAMING
}
public class SimpleEnumUse {
  public static void main(String[] args) {
    Spiciness howHot = Spiciness.MEDIUM;
    System.out.println(howHot);
  }
} /* Output:
MEDIUM
*///:~

在创建enum时，编译器会自动添加一些有用的特性，如，会创建toString()方法，以便可以方便的显示某个enum实例的名称，如上例输出。编译器还会创建ordinal()和static values()方法，使用如下：

1
2
3
4
5
6
7
8
9
10
11
12

public class EnumOrder {
  public static void main(String[] args) {
    for(Spiciness s : Spiciness.values())
      System.out.println(s + ", ordinal " + s.ordinal());
  }
} /* Output:
NOT, ordinal 0
MILD, ordinal 1
MEDIUM, ordinal 2
HOT, ordinal 3
FLAMING, ordinal 4
*///:~

ordinal():表示每个特定的enum常量的声明顺序，是一个整数。
static values():按照enum常量的声明顺序，产生由这些常量值构成的数组。

  • enum的一个特别实用的特性，即可以在switch语句内使用： 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

    public class Burrito {
Spiciness degree;
public Burrito(Spiciness degree) { this.degree = degree;}
public void describe() {
  System.out.print("This burrito is ");
  switch(degree) {
    //不能写成case Spiciness.NOT：...
    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),
    greenChile = new Burrito(Spiciness.MEDIUM),
    jalapeno = new Burrito(Spiciness.HOT);
  plain.describe();
  greenChile.describe();
  jalapeno.describe();
}
} /* Output:
This burrito is not spicy at all.
This burrito is a little hot.
This burrito is maybe too hot.
*///:~
目录

更多文章