Thinking in Java 第四版完整版 第七章练习题 复用类

Thinking in Java 第四版完整版 第七章练习题，记录一下(jdk1.8.0)

1.

/**
 * 练习1：创建一个简单的类。在第二个类中，将一个引用定义为第一个类
 * 的对象。运用惰性初始化来实例化这个对象。
 * @author admin11
 * @date 2018年3月21日
 */

class Simple {
    String s;
    public Simple(String si) {
        s = si;
    }

    public String toString() {
        return s;
    }

    public void setString(String sNew) {
        s = sNew;
    }
}

class Second {
    Simple simple;
    String s;

    public Second(String si) {
        s = si;
    }

    public void check() {
        if(simple == null) {
            System.out.println("not initialized");
        } else {
            System.out.println("initialized");
        }
    }

    private Simple lazy() {
        if(simple == null) {
            System.out.println("Creating Simple");
            simple = new Simple(s);
        }
        return simple;
    }

    public Simple getSimple() {
        return lazy();
    }

    public String toString() {
        return lazy().toString();
    }

    public void setSimple(String sNew) {
        lazy().setString(sNew);
    }
}

public class Exercise701 {
   
   

    public static void main(String[] args) {
        Second second = new Second("Init String");
        second.check();
        System.out.println(second.getSimple());
        second.check();
        System.out.println(second);
        second.setSimple("New String");
        System.out.println(second);
    }
}

2.

class Cleanser {
    private String s = "Cleanser ";
    public void append(String a) {
        s += a;
    }

    public void dilute() {
        append("dilute() ");
    }

    public void apply() {
        append("apply() ");
    }

    public void scrub() {
        append("scrub() ");
    }

    public String toString() {
        return s;
    }

    public static void main(String[] args) {
        Cleanser x = new Cleanser();
        x.dilute();
        x.apply();
        x.scrub();
        System.out.println(x);
    }
}

public class Detergent extends Cleanser{
   
   

    @Override
    public void scrub() {
        append("Detergent.scrub()");
        super.scrub();
    }

    public void foam() {
        append("foam()");
    }

    public static void main(String[] args) {
        Detergent x = new Detergent();
        x.dilute();
        x.apply();
        x.scrub();
        x.foam();
        System.out.println(x);
        Cleanser.main(args);
    }
}

/**
 * 练习2：从Detergent中继承产生一个新的类。覆盖scrub()
 * 并添加一个名为sterilize()的新方法。
 * @author admin11
 * @date 2018年3月21日
 */
public class Exercise702 extends Detergent{
   
   

    @Override
    public void scrub() {
        append("Exercise702.scrub()");
    }

    public void sterilize() {
        append("Exercise702.sterilize()");
    }

    public static void main(String[] args) {
        Exercise702 e = new Exercise702();
        e.dilute();
        e.apply();
        e.scrub();
        e.sterilize();
        System.out.println(e);
    }
}

3.

class Art {
    Art() {
        System.out.println("Art constructor");
    }
}

class Drawing extends Art {
    Drawing() {
        System.out.println("Drawing constructor");
    }
}

public class Cartoon extends Drawing {
   
   

    public Cartoon() {
        System.out.println("Cartoon constructor");
    }

    public static void main(String[] args) {
        Cartoon x = new Cartoon();
    }
}

/**
 * 练习3：证明前面这句话。
 * @author admin11
 * @date 2018年3月22日
 */
public class Exercise703 extends Drawing{
   
   

    /*即使你不为Cartoon()创建构造器，编译器也会为你合成一个
     * 默认的构造器，该构造器将调用基类的构造器。*/
    public static void main(String[] args) {
        Exercise703 e = new Exercise703();
    }
}

4.

/**
 * 练习4：证明基类构造器：(a)总是会被调用；
 * (b)在导出类构造器之前被调用。
 * @author admin11
 * @date 2018年3月22日
 */

class Base1 {
    public Base1() {
        System.out.println("Base1");
    }
}

class Derived1 extends Base1 {
    public Derived1() {
        System.out.println("Derived1");
    }
}

class Derived2 extends Derived1 {
    public Derived2() {
        System.out.println("Deriv