第五章 - 初始化与清理

布满荆棘的人生 2022-05-23 08:25 170阅读 0赞

## 用构造器确保初始化 ##

初始化和清理是涉及安全的两个问题

1 用户不知道为何初始化库的构件（或者是用户必须进行初始化的其他东西）。

2 清理也是一个特殊问题，当使用完一个元素的时候，它对你也就没有影响了，所以很容易忘记，这样一来，这个元素会一直占据资源，结果就是资源（尤其是内存）会用尽。

所以引入了“构造器”概念，在创建对象时候被自动调用的特殊方法，并额外提供了“垃圾回收器”，对于不再使用的内存资源，垃圾回收器自动将其释放。

构造器采用与类名相同的名称。下面就是一个构造器的简单类

class Rock {
      Rock() { // This is the constructor
        System.out.print("Rock ");
      }
    }
    
    public class SimpleConstructor {
      public static void main(String[] args) {
        for(int i = 0; i < 10; i++)
          new Rock();
      }
    }

![70][]

在创建对象 new  Rock();时候，会为对象分配存储空间，并调用相应的构造器。这样就确保在操作对象之前，它已经恰当的初始化了。不接受任何参数的构造器叫做默认构造器。但是和其他方法一样构造器也接受参数，以便指定如何创建对象，对上述例子稍加修改，即可使构造器接受一个参数

class Rock2 {
      Rock2(int i) {
        System.out.print("Rock " + i + " ");
      }
    }
    
    public class SimpleConstructor2 {
      public static void main(String[] args) {
        for(int i = 0; i < 8; i++)
          new Rock2(i);
      }
    }

![70 1][]

有了构造器形式参数，就可以再初始化时提供实际参数。

如果类中有唯一的构造器，那么编译器不允许以其他任何方式创建对象。

## 方法重载 ##

构造器是强制重载，既然构造器的名字已经由类决定了，就只能有一个构造器名。那么想要用多种方式创建一个对象该怎么办呢？假设创建一个类，既可以用标准的方式初始化，也可以从文件里读取信息来初始化。这就需要两个构造器，一个默认构造器，一个带参数的构造器。由于都是构造器，所有他们必须有相同的名称，既类名。为了让方法名相同而参数不同必须用到方法重载。

下面的例子示范了重载的构造器和重载的方法

class Tree {
      int height;
      Tree() {
        print("默认构造器");
        height = 0;
      }
      Tree(int initialHeight) {
        height = initialHeight;
        print("带参数构造器" + height);
      }    
      void info() {
        print("重载方法1");
      }
      void info(String s) {
        print("重载方法2" + s);
      }
    
      private void print(String s) {
        System.out.println(s);
      }
    }
    
    public class Overloading {
      public static void main(String[] args) {
          new Tree();
          Tree t = new Tree(1);
          t.info();
          t.info("overloaded method");
      }    
    }

![70 2][]

## 区分重载方法    ##

要是几个方法都有相同的名字，Java如何知道你指的是哪个呢？其实很简单，每个重载的方法必须有独一无二的参数列表。 比如参数类型的差异，参数的顺序，参数的个数。但是注意的是不能用返回值来区分方法的重载。因为在调用方法的时候可能并不会关心返回值。

##  默认构造器 ##

如前所述，默认构造器就是没有参数的构造器，如果类中没有写构造器，那么编译器会自动帮助创建一个默认构造器，但是如果已经定义了一个构造器（无论是否有参数），编译器都不会帮助自动创建默认构造器了。

## this关键字 ##

如果同一个类型的两个对象，分别是a和b

class Banana {
      void peel(int i) {
      /* 此方法没有任何实现 */
      }
    }
    
    public class BananaPeel {
      public static void main(String[] args) {
        Banana a = new Banana();
        Banana b = new Banana();
        a.peel(1);
        b.peel(2);
      }
    }

在peel（）方法中，它是如何知道自己是被a还是b调用的呢？其实在编译器内部做了一些幕后工作，它暗自把“做操作对象的引用”作为第一个参数传递给了peel（）。所以上述两个方法的调用就变成了

a.peel(a,1);

b.peel(b.2);

这是内部的表现形式，但是我们不能这样写代码，并试图编译！

假设希望在方法内部获取当前对象引用，由于引用是编译器“偷偷”传入的，所以并没有标识符。但是提供了专门的关键字“this”，this只能在方法内部使用，表示“当前对象的引用”。例如需要返回当前对象的引用是，就常常可以在return里这样写

public class Leaf {
      int i = 0;
      Leaf increment() {
        i++;
        return this;
      }
      void print() {
        System.out.println("i = " + i);
      }
      public static void main(String[] args) {
        Leaf x = new Leaf();
        x.increment().increment().increment().print();
      }
      
    }

由于increment()通过this关键字返回了当前对象的引用，所以很容易在一条语句里对同一个对象执行多次操作。

this关键字对于将的当前对象传递给其他方法也很有用；

class Person {
      public void eat(Apple apple) {
        Apple peeled = apple.getPeeled();
        System.out.println("Yummy");
      }
    }
    
    class Peeler {
      static Apple peel(Apple apple) {
        // ... remove peel
        return apple; // Peeled
      }
    }
    
    class Apple {
      Apple getPeeled() { 
        return Peeler.peel(this); 
      }
    }
    
    public class PassingThis {
      public static void main(String[] args) {
        new Person().eat(new Apple());
      }
    }

##     在构造器中调用构造器 ##

可能为一个类写了多个构造方法，有时可能想在一个构造器中调用另一个构造器，以避免重复代码。可用this关键字做到这一点。

public class Flower {
      int petalCount = 0;
      String s = "initial value";
      Flower(int petals) {
        petalCount = petals;
        System.out.println("Constructor w/ int arg only, petalCount= "  + petalCount);
      }
      Flower(String ss) {
        System.out.println("Constructor w/ String arg only, s = " + ss);
        s = ss;
      }
      Flower(String s, int petals) {
        this(petals);
        this.s = s;
        System.out.println("String & int args");
      }
      Flower() {
        this("hi", 47);
        System.out.println("default constructor (no args)");
      }
      void printPetalCount() {
        System.out.println("petalCount = " + petalCount + " s = "+ s);
      }
      public static void main(String[] args) {
        Flower x = new Flower();
        x.printPetalCount();
      }
    }

![70 3][]

## static的含义 ##

了解this关键字后，就能更全面的理解static关键字了，static方法就是没有this的方法。在static方法的内部不能调用非静态方法，反过来倒是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类名来调用static方法。这实际正是static方法的主要用途。

##     成员初始化 ##

java尽力保证：所有的变量在使用前都能得到恰当的初始化。对于方法的局部变量，java以编译时错误的形式来贯彻这种保证。所以如果写

public class Test {
        public static void main(String[] args) {
            A a = new A();
            a.f();
        }
    
    }
    class A {
        public void f (){
            int i;
            ++i;
            System.out.println(i);
        }
    }

执行此代码会得到一个错误信息，因为i可能尚未初始化。当然，编译器也可以为i赋一个默认值，但是未初始化的局部变量更有可能是程序员的疏忽，所以采用默认值反而会掩盖这种失误。

要是类中的数据成员是基本类型，情况就会不一样，类的每一个基本类型数据成员都会有一个默认值，现在将上面代码稍微改一下

public class Test {
        public static void main(String[] args) {
            A a = new A();
            a.f();
        }
    
    }
    class A {
        int i;
        public void f (){
            ++i;
            System.out.println(i);
        }
    }

再次执行，就会发现上面的代码是可以正常执行的，i被赋值了默认值0。对于对象引用时，如果不进行初始化，会得到一个特殊值null。

##     初始化顺序 ##

在类的内部，变量定义的先后顺序决定了初始化的顺序。即时变量定义散布在方法定义之间，他们仍旧会在任何方法（包括构造方法）被调用之前得到初始化

class Window {
      Window(int marker) {
        System.out.println("Window(" + marker + ")");
      }
    }
    
    class House {
      Window w1 = new Window(1);
      House() {
        System.out.println("House()");
        w3 = new Window(33);
      }
      Window w2 = new Window(2);
      void f() {
        System.out.println("f()"); 
      }
      Window w3 = new Window(3);
    }
    
    public class OrderOfInitialization {
      public static void main(String[] args) {
        House h = new House();
        h.f();
      }
    }

![70 4][]

## 静态数据的初始化 ##

无论创建多少个对象，静态数据都只有一份存储区域。static关键字不能应用与局部变量，因此只能作用于域。

静态存储区域是何时初始化的，看下面的例子：

class Table {
    
      static {
        System.out.println("Table static");
      }
    
      Table() {
        System.out.println("Table()");
      }
      void f2(int marker) {
        System.out.println("f2(" + marker + ")");
      }
    }
    
    class Cupboard {
      Cupboard() {
        System.out.println("Cupboard()");
      }
    }
    
    public class StaticInitialization {
      public static void main(String[] args) {
        System.out.println("Creating new Cupboard() in main");
        new Table();//此处再次new一个对象，Table中的静态区域块中的代码是没有加载的，也就证明了静态区域块仅仅加载一次
        new Cupboard();
        table.f2(1);
      }
      static Table table = new Table();
    }

![70 5][]

从上面的例子的打印结果来看，执行顺序为先静态，然后在按照顺序执行非静态代码。而且静态区域块仅仅在初始化的时候加载一次。

##     数组初始化 ##

数组只是相同类型的，用一个表示符名称封装到一起的一个对象序列或基本类型数据序列，数组通过方括号下表操作符\[\]来定义和使用的。

要定义一个数组

int\[\] a1;

int a1\[\];

两种格式的含义是一样的，但是推荐使用第一种。

在原文中提到了一句话叫“编译器不允许指定数组的大小”，很多同学可能不理解这句话，因为我们明明可以这样定义啊 int\[\] a1 = new int\[10\];   对 ,我们是可以这样定义。 其实这句话的意思是我们不可以这样 int\[10\] a1这样来定义。这就又把我们带回了有关“引用”的问题上。    现在拥有的只是对一个数组的引用（已经为该引用创建了相应的存储空间），但还没给数组对象本身分配任何空间。为了给数组创建相应的存储空间，必须写初始化表达式。

对于数组，初始化动作可以出现在代码的任何地方。也可以用一种特殊的初始化表达式，它必须在创建数组的地方出现。这种特殊的初始化是由一对花括号括起来的值组成的，在这种情况下，存储空间的分配（等价于使用new）由编译器负责。例如：

public class ArraysOfPrimitives {
      public static void main(String[] args) {
        int[] a1 = { 1, 2, 3, 4, 5 };
        int[] a2;
        a2 = a1;
        for(int i = 0; i < a2.length; i++)
          a2[i] = a2[i] + 1;
        for(int i = 0; i < a1.length; i++)
          System.out.println("a1[" + i + "] = " + a1[i]);
      }
    }

![70 6][]

可以看到代码中给了a1的初始值，但a2却没有。本例子中a2是后面被赋给另一个数组的。由于a2和a1是相同的别名，因为通过a2所做的修改在a1中可以看到。

数组可以在定义到时候同时进行初始化

public class ArrayClassObj {
      public static void main(String[] args) {
        Integer[] a = new Integer[10];
        for(int i = 0; i < a.length; i++)
          a[i] = new Random().nextInt(100); // Autoboxing
        System.out.println(Arrays.toString(a));
      }
    }

![70 7][]

这里Integer\[\] a = new Integer\[10\]; 它还只是一个引用，并且直到通过创建新的Integet对象，并把对象赋给引用，初始化进程才算结束。

[70]: /images/20220523/106216b1931c41f5bbc542f2ec2868b9.png
[70 1]: /images/20220523/b7853c6a1dd5427fa0ea6b4618e65fa3.png
[70 2]: /images/20220523/79edfe784554434c9b063d5fda2cd257.png
[70 3]: /images/20220523/7d3380f047ee4acc81422529e3dba559.png
[70 4]: /images/20220523/2e13c0c7914644af8f2ff6fb60f95de1.png
[70 5]: /images/20220523/ef0860c573df467bae7736503a328c91.png
[70 6]: /images/20220523/8a74a1d4a0734fe994b5b41b86246939.png
[70 7]: /images/20220523/4aeec65be8214aefa13cc8423fbc566c.png