this 关键字
1)this 关键字只能在方法内部使用,表示对“调用方法的那个对象”的引用。
2)可以用this 调用一个构造器,但不能用相同的方法调用两个构造器。例如:
Flower(int petals) { petalCount = petals; print("Constructor w/ int arg only, petalCount= " + petalCount); } Flower(String ss) { print("Constructor w/ String arg only, s = " + ss); s = ss; } Flower(String s, int petals) { this(petals); // ! this(s); // Can't call two! this.s = s; // Another use of "this" print("String & int args"); }
除构造器之外,编译器禁止在其他任何方法中调用构造器。例如:
void printPetalCount() { // ! this(11); // Not inside non-constructor! print("petalCount = " + petalCount + " s = " + s); }
构造器初始化
1)在类的内部,变量定义的先后顺序决定了初始化的顺序。
2)static关键字不能应用于局部变量,它只能作用于域。
3)初始化的顺序是先“静态”,(如果它们尚未因前面的对象创建过程而被初始化),后“非静态”。
4)对象的创建过程会很有帮助。假设有个名为 Dog 的类:
1. 当首次创建类型为 Dog 的对象时(构造器可以看成静态方法),或者Dog 类的静态方法/静态域首次被访问时,Java 解释器必须查找类路径,以定位Dog.class 文件。
2. 然后载入 Dog.class(这将创建一个Class 对象),有关静态初始化的动作都会执行。因此,静态初始化只在Class 对象首次加载的时候进行一次。
3. 当用 new Dog( )创建对象的时候,首先将在堆上为Dog 对象分配足够的存储空间。
4. 这块存储空间会被清零,这就自动地将Dog 中的所有基本类型数据设置成了默认值(对数字来说就是0,对布尔型和字符型也相同),而引用则被设置成了null。
5. 执行所有出现于域定义处的初始化动作。
6. 执行构造器。这可能会牵涉到很多动作,尤其是涉及继承的时候。
数组初始化
1)编译器不允许你指定数组的大小。
2)数组的三种初始化方法,以及注意事项。
/** * 数组的三种初始化方式,数组在定义时不可以指定数组的大小 * */ class ArrayTest { /** * 第一种,在定义时进行初始化。 这种形式的初始化只可以在定义处使用。 * */ Integer[] integer0 = { 1, 2, 3 }; /** * 第二种,在new对象时初始化。 这种形式的初始化不可以指定数组的大小 * */ Integer[] integer1 = new Integer[] { 1, 2, 3 }; /** * 第三种,利用循环逐一初始化。 这种形式的初始化必须指定数组的大小。 在这种方式下,如果数组存储的数据类型是基本数据类型, * 在数组通过new完成初始化后,所有的数组元素被初始化为该类型的默认值; 如果数组存储的是对象,则所有的数组元素被初始化为null。 * */ Integer[] integer2 = new Integer[3]; { for (int i = 0; i < integer2.length; i++) { integer2[i] = i; } } }
3)数组和可变参数列表
对于参数个数和参数类型 未知的场合,可以使用数组的第二种初始化方法来产生一个可变参数列表,例如:
class A { } public class VarArgs { static void printArray(Object[] args) { for (Object obj : args) System.out.print(obj + " "); System.out.println(); } public static void main(String[] args) { printArray(new Object[] { new Integer(47), new Float(3.14), new Double(11.11) }); printArray(new Object[] { "one", "two", "three" }); printArray(new Object[] { new A(), new A(), new A() }); } }
而在java5中,可以像下面这样定义可变参数列表:
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: printArray(new Integer[] { 1, 2, 3, 4 }); printArray(); // Empty list is OK } }
有了可变参数列表,你就不用显示地编写 数组语法了,当你指定参数时,编译器会为你填充数组,你获取的仍旧是一个数组。注意程序的倒数第二行,可变参数列表也可以接受一个数组作为参数。
可变参数列表使得重载过程变得复杂:
public class OverloadingVarargs { static void f(Character... args) { System.out.print("first"); for (Character c : args) System.out.print(" " + c); System.out.println(); } static void f(Integer... args) { System.out.print("second"); for (Integer i : args) System.out.print(" " + i); System.out.println(); } static void f(Long... args) { System.out.println("third"); } public static void main(String[] args) { f('a', 'b', 'c'); f(1); f(2, 1); f(0); f(0L); // ! f(); // Won't compile -- ambiguous } }
在不使用参数调用f()时,编译器无法知道应该调用哪个方法。你可能会通过在某个方法中添加一个非可变参数来解决该问题:
public class OverloadingVarargs2 { static void f(float i, Character... args) { System.out.println("first"); } static void f(Character... args) { System.out.print("second"); } public static void main(String[] args) { f(1, 'a'); // f('a', 'b'); //Won't compile -- ambiguous } }
如果你给这两个方法都添加一个非可变参数,就可以解决问题了:
public class OverloadingVarargs3 { static void f(float i, Character... args) { System.out.println("first"); } static void f(char c, Character... args) { System.out.println("second"); } public static void main(String[] args) { f(1, 'a'); f('a', 'b'); } }
你应该总是只在重载方法的一个版本上使用可变参数列表,或者压根就不使用它。