Thinking in Java习题心得

[在构造函数中调用构造函数]

class Foo
{
    public Foo()
    {
        this("Default");
    }

    public Foo(String s)
    {
        System.out.println(s);
    }
}

public class Main
{

    public static void main(String[] args)
    {
        Foo f = new Foo();
        Foo g = new Foo("Param");
    }
}

 

[该死的gc]

在Java中垃圾收集是不能被强迫立即执行的。调用System.gc()或Runtime.gc()静态方法不能保证垃圾收集器的立即执行，因为，也许存在着更高优先级的线程。

[两种初始化的区别]

class T
{
    String s0 = "good", s1;

    public T()
    {
        s1 = "morning";
    }

    public String toString()
    {
        return s0 + " " + s1;
    }
}

public class Main
{
    public static void main(String[] args)
    {
        T t = new T();
        System.out.println(t);
    }
}

 

s0和s1均被初始化了，但是它们的区别是什么？那就是：s0首先就被初始化为"good",而s1先被初始化为null，然后再被赋值为"morning"。

[static型初始化的两个注意]

形如

class Cups
{
    static Cup c1;
    static Cup c2;

    static
    {
        c1 = new Cup(1);
        c2 = new Cup(2);
    }
}

叫做static明确初始化。这种初始化有两个注意的地方：

class Cups
{
    static Cup c1;
    static Cup c2;

    static
    {
        c1 = new Cup(1);
        c2 = new Cup(2);
    }
}

叫做static明确初始化。这种初始化有两个注意的地方：

(1) 这种初始化仅会被执行一次。

(2) 执行的时间为首次产生class对象的时候，或者为首次访问该class的static成员的时候

[实体初始化]

对于non-static型的变量，Java也提供了类似static型初始化的语法。

public class Main
{

    String s;

    {
        s = "good morning!";

        System.out.println("initialized.");
    }

    Main()
    {
        System.out.println("constructor.");
    }

    public static void main(String[] args)
    {
        System.out.println("entry.");
        Main m = new Main ();
    }
}

 

该程序输出：

 

 

entry.
initialized.
constructor.

执行顺序一目了然。

[继承构造函数]

如果一个类继承自某个基类，而又没有默认构造函数的话，系统会自动添加一个默认构造函数，这个默认构造函数调用基类的构造函数，比如

class A
{
    A() {}
}

class B extends A
{
    // 在这里会默认添加：
    // B() { super(); }
}

这个和C++略有不同，C++中构造函数是不能被继承的。

其实，这个技术的实际情况是：Java编译器会自动在derived class构造函数中插入对base class构造函数的调用动作。

[缓式初始化]

其实也不算什么技术了，就是一种提高性能的方法。

对一个对象初始化有三种方式：

(1) 在对象定义的地方初始化。
(2) 在类的构造函数中。
(3) 在实际需要用到该对象的地方。

其中方式(3)就叫做缓式初始化（lazy init）。

class A
{
    String _s;
    A(String s)
    {
        _s = s;
    }

    public String toString()
    {
        return _s;
    }
}

class B
{
    A a;
   
    public String toString()
    {
        a = new A("hello, world");  // lazy init
        return a.toString();
    }
}

public class Main
{
    public static void main(String[] args)
    {
        B b = new B();
        System.out.println(b);
    }
}

 

[再议清理]

[再议清理]

垃圾清理这东西没准儿。所以：如果你希望发生清理动作，请自行撰写清理用的函数。

比如

class A
{
    void cleanup()
    {
        // 添加清理
    }
}

class B extends A
{
    void clearup()
    {
        // 添加清理
        super.cleanup();
    }
}

public class Main
{
    public static void main(String[] args)
    {
        B b = new B();
        try
        {
            // 代码和异常处理
        }
        finally
        {
            b.cleanup();
        }
    }
}

class A
{
    void cleanup()
    {
        // 添加清理
    }
}

class B extends A
{
    void clearup()
    {
        // 添加清理
        super.cleanup();
    }
}

public class Main
{
    public static void main(String[] args)
    {
        B b = new B();
        try
        {
            // 代码和异常处理
        }
        finally
        {
            b.cleanup();
        }
    }
}

如果一个类继承自某个基类，而又没有默认构造函数的话，系统会自动添加一个默认构造函数，这个默认构造函数调用基类的构造函数，比如

class A
{
    A() {}
}

class B extends A
{
    // 在这里会默认添加：
    // B() { super(); }
}

这个和C++略有不同，C++中构造函数是不能被继承的。

其实，这个技术的实际情况是：Java编译器会自动在derived class构造函数中插入对base class构造函数的调用动作。

[缓式初始化]

其实也不算什么技术了，就是一种提高性能的方法。

对一个对象初始化有三种方式：

(1) 在对象定义的地方初始化。
(2) 在类的构造函数中。
(3) 在实际需要用到该对象的地方。

其中方式(3)就叫做缓式初始化（lazy init）。

class A
{
    String _s;
    A(String s)
    {
        _s = s;
    }

    public String toString()
    {
        return _s;
    }
}

class B
{
    A a;
   
    public String toString()
    {
        a = new A("hello, world");  // lazy init
        return a.toString();
    }
}

public class Main
{
    public static void main(String[] args)
    {
        B b = new B();
        System.out.println(b);
    }
}

 

[再议清理]

[再议清理]

垃圾清理这东西没准儿。所以：如果你希望发生清理动作，请自行撰写清理用的函数。

比如

class A
{
    void cleanup()
    {
        // 添加清理
    }
}

class B extends A
{
    void clearup()
    {
        // 添加清理
        super.cleanup();
    }
}

public class Main
{
    public static void main(String[] args)
    {
        B b = new B();
        try
        {
            // 代码和异常处理
        }
        finally
        {
            b.cleanup();
        }
    }
}

class A
{
    void cleanup()
    {
        // 添加清理
    }
}

class B extends A
{
    void clearup()
    {
        // 添加清理
        super.cleanup();
    }
}

public class Main
{
    public static void main(String[] args)
    {
        B b = new B();
        try
        {
            // 代码和异常处理
        }
        finally
        {
            b.cleanup();
        }
    }
}