首页 > 代码库 > Java 初始化

Java 初始化

默认域初始化
  1. 如果在构造器中没有显示地给域赋予初值,那么就会被自动赋予默认值:数值为0,布尔值为false,对象引用为null。
无参数构造器

很多类都包含一个无参数的构造函数,对象由无参数构造函数创建时,其状态会设置为适当的默认值。例如,如下是Employee的无参数构造函数:

  1. pubilc Employee() {
  2. name = ""
  3. salary = 0;
  4. hireDay = new Date();
  5. }
  1. 如果编写一个类时没有编写构造器, 那么系统就会提供一个无参数的构造器。这个构造器将所有的实例域设置为默认值。于是,实例域中的数值型数据设置为0、布尔型数据设置为false,所有对象引用将设置为null。
  2. 如果类中至少提供了一个构造器,但是没有提供无参数的构造器,则在构造对象如果没有提供参数就会被视为不合法。
显示域初始化(指定初始化)

由于类的构造器方法可以重载,所以可以采用多种形式设置类的实例域的初始状态。确保不管怎么调用构造器,每个实例域都可以被设置为一个有意义的数初值。这是一种很好的设计习惯。 
可以在类的定义中,直接将一个值付给任何域。例如:

  1. class A{}
  2. Class Employee {
  3. private String name = "";
  4. private A a = new A();
  5. }

在执行构造器之前先执行赋值操作。当一个类的所有构造器都希望把相同的值赋给某个特定的实例域时,这种方式特别有用。 
初始值不一定是常量。在下面这个例子中,可以调用方法对域进行初始化。Employee类中每个雇员都有一个id域。可以使用下列方式进行初始化:

  1. class Employee{
  2. private static int nextId;
  3. private int id = assignId();
  4. private static int assignId() {
  5. int r = nextId();
  6. nextId++;
  7. return r;
  8. }
  9. }

这个方法也可带有参数,但这些参数必须是已经初始化的了。因此,可以这样写:

  1. public class MethodInit {
  2. int i = f();
  3. int j = g(i);
  4. int f() {return 11;}
  5. int g(int n ) {return n* 10;}

但像下面这样就不对了:

  1. public class MethodInit{
  2. int j = g(i); //Illegal forward reference
  3. int i = f();
  4. int f() {return 11;}
  5. int g(int n) {return n * 1
初始化块

前面已经讲过两种初始化数据域的方法:

  • 在构造器中设置值
  • 在声明中初始化 
    实际上,Java中还有第三种机制,称为初始化块。在一个类的生命中,可以包含多个代码块。只要构造类的对象,这些块就会被执行。例如:
  1. class Employee{
  2. private static int nextId;
  3. private int id;
  4. private String name;
  5. private double salary;
  6. //object initialization block
  7. {
  8. id = nextId;
  9. nextId++;
  10. }
  11. public Employee(String n, dobule s) {
  12. name = n;
  13. salary = s;
  14. }
  15. public Employee(){
  16. name = "";
  17. salary = 0;
  18. }
  19. }

在这个示例中,无论使用哪个构造器构造对象,id域都在对象初始化块中被初始化。首先运行初始化块,然后才运行构造器的主体部分。

this

假设你希望在方法的内部获得对当前对象的引用,就可以使用this关键字。this关键字只能在方法的内部使用,表示对“调用这个方法的那个对象”的引用。this的用法和其他对应引用并无不同。只要注意,如果在方法内部调用同一个类的另一个方法,就不必使用this,直接调用即可。

只有当需要明确指出对当前对象的引用时,才需要使用this关键字。例如,当需要返回对当前对象的引用时,就常常需要在return语句里这样写:

  1. public class Leaf{
  2. int i = 0;
  3. Leaf increment() {
  4. i++:
  5. return this;
  6. }
  7. }
  8. public static void main(String[] args) {
  9. Leaf x = new Leaf();
  10. x.increment().increment().increment();
  11. }

由于increment()通过this关键字返回了对当前对象的引用,所以很容易在一条语句中对同一个对象进行多次操作。 
this关键字对于将对于将当前对象传递给其他对象也很有用:

  1. Class Person{
  2. public void eat(Apple apple) {
  3. Apple peeled = apple.getPeeled();
  4. System.out.println("Yummy");
  5. }
  6. }
  7. class Peeler {
  8. static Apple peel(Apple apple) {
  9. //... remove peel
  10. return apple; //Peeled
  11. }
  12. }
  13. class Apple{
  14. Apple getPeeled() {return Peeler.peel(this);}
  15. }
  16. public class PassingThis {
  17. public static void main(Strings[] args) {
  18. new Person.eat(new Apple));
  19. }
  20. }
参数名

构造器的的参数名和引用如下所示:

  1. Class Employee{
  2. private String name;
  3. private double salary;
  4. public Employee(String name , double salary) {
  5. this.name = name;
  6. this.salary = salary;
  7. }
  8. }

它基于这样一个事实:参数变量用同样的名字将实例域屏蔽起来。例如,如果将参数命名为salary,salary将引用这个参数,而不是实例域。但是,可以采用this的形式访问实例域。

调用另一个构造器

如果构造器的第一个句子形如(this…),这个构造器将调用同一个类的另一个构造器。下面是一个典型的例子:

  1. public Employee() {
  2. //calls Employee(String, double)
  3. this("Employee #" + nextId, s);
  4. nextId++;
  5. }

尽管可以用this调用另一个构造器,但却不能同时调用两个。此外,必须将构造器调用置于方法最起始处,否则编译器会报警。

静态域初始化
  1. 如果一个域是静态的基本类型域,且没有对它进行初始化,那么它就会获得基本类型的标准初值;如果它是一个对象引用,那么它的默认初始值就是null。
  2. 如果想在定义处进行初始化,采取的方法与非静态数据没什么不同
  1. Class A{
  2. private static B b = new B();
  3. }

3.也可以用使用指定初始化,不过要在初始化块的外面加 static关键字

  1. class Cup{
  2. Cup(int marker) {
  3. }
  4. }
  5. class Cups{
  6. static Cup cup1;
  7. static Cup cup2;
  8. static {
  9. cup1 = new Cup(1);
  10. cup2 = new Cup(2);
  11. }
  12. Cup() {
  13. print("Cups()");
  14. }
  15. }
  16. public class ExplicitStatic {
  17. public static void main(Strings[] args) {
  18. print("Inside main()");
  19. Cups.cup1.f(99);
  20. }
  21. static Cups cups1 = new Cups();
  22. static Cups cups2 = new Cups();
  23. }

无论是通过标为(1)的那行代码访问静态的cup1对象,还是把标为(1)的行注释掉,让它去运行标为(2)的那行代码(即解除标为(2)的行的注释),Cups的静态初始化动作都会得到执行。如果把标为(1)和(2)的行同时注释掉,Cups的静态初始化动作就不会进行。此外,激活一行还是两行标为(2)的代码(即解除注释)都无关紧要,静态初始化动作只进行一次。

Java 初始化