Java编程思想第四版第七章练习

练习1:创建一个简单的类。第二个类中，将一个引用定义为第一个类的对象。运用惰性初始化来实例化 这个对象

public class Exercise7_1 {       public static void main(String[] args) {        Second second  = new Second("Init String");        second.chenked();        System.out.println(second.getSimple());        second.chenked();        System.out.println(second);        second.setSimple("New String");        System.out.println(second);    }}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 chenked() {        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);    } }

练习2：从Detergent中继承产生一个新的类。覆盖scrub()并添加一个名为sterilize()的新方法。

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 {      // Change a method:      public void scrub() {        append(" Detergent.scrub()");        super.scrub(); // Call base-class version      }      // Add methods to the interface:      public void foam() { append(" foam()"); }      // Test the new class:      public static void main(String[] args) {        Detergent x = new Detergent();        x.dilute();        x.apply();        x.scrub();        x.foam();        System.out.println(x);        System.out.println("Testing base class:");        Cleanser.main(args);      }     } 

public class Exercise7_2 {     public static void main(String[] args) {        NewDetergent newDetergent = new NewDetergent();        newDetergent.dilute();        newDetergent.scrub();        newDetergent.sterilize();        System.out.println(newDetergent);    }}class NewDetergent extends Detergent{    public void scrub() {        append("new Detergent.scrub");        super.scrub();    }    public void sterilize() {        append("sterilize");    }}

练习3：证明前面两句话（即使你不为Cartoon创建构造器，编译器也为会你合成一个默认的构造器，该构造器将调用基类的构造器）

public class Exercise7_3 {    public static void main(String[] args) {        new CartoonWithDefCtor();    }}class Art{    Art(){        System.out.println("Art constructor");    }}class Drawing extends Art{    Drawing(){        System.out.println("Drawing Contructor");    }}class CartoonWithDefCtor extends Drawing{//  public CartoonWithDefCtor() {//      System.out.println("CartoonWithDefCtor Contructor");//  }}

练习4：证明基类构造器总是会被调用，在导出类构造器之前被调用。

public class Exercise7_4 {    public static void main(String[] args) {          new Derived2();    }}class Base1{    public Base1() {        System.out.println("Base1");    }}class Derived1 extends Base1{    public Derived1() {        System.out.println("Derived");    }}class Derived2 extends Derived1{    public Derived2() {        System.out.println("Derived2");    }}

练习5：创建两个带有默认构造器（空参数列表）的类A和类B。从A中继承产生一个名为C的新，并在C内创建一个B类的成员。不要给C编写构造器。创建一个C类的对象并观察其结果。

public class Exercise7_5 {     public static void main(String[] args) {          new C();    }}class A{    public A() {        System.out.println("A");    }}class B{    public B() {        System.out.println("B");    }}class C extends A{    B b = new B();}

练习6：用Chess证明前面两名话

    class Game {      Game(int i) {      System.out.println("Game constructor");      }    }    class BoardGame extends Game {      BoardGame(int i) {        super(i);        System.out.println("BoardGame constructor");      }    }       public class Exercise7_6 extends BoardGame {      Exercise7_6() {        super(11);        System.out.println("Chess constructor");      }      public static void main(String[] args) {        Exercise7_6 x = new Exercise7_6();      }    } 

练习7：修改练习5，使A和B以带参数的构造器取代默认的构造器。为C写一个构造器，并在其中执行所有初始化。

public class Exercise7_7 {    public static void main(String[] args) {        new C(1);    }}class A{    public A(int i) {        System.out.println("A");    }}class B{    public B(String s) {        System.out.println(s);    }}class C extends A{    public C(int i) {        super(i);        B b = new B("s");     }}

练习8：创建一个基类，它仅有一个非默认构造器；再创建一个导出类，它带有默认构造器和非默认构造器。在导出类的构造器中调用基类的构造器。

public class Exercise7_8 {    public static void main(String[] args) {        new DerivedTwoContructors();        new DerivedTwoContructors(74);    }}class BaseNonDefault{    public BaseNonDefault(int i) {    }}class DerivedTwoContructors extends BaseNonDefault{    public DerivedTwoContructors() {        super(47);    }    public DerivedTwoContructors(int i) {        super(i);    }}

练习9：创建一个Root类，令其含有名为Component1、Component 2、Component3的类的各一个实例（这些也由你写）。从Root中派生一个类Stem，也含有上述各“组成部分”。所有的类都应带有可打印出类的相关信息的默认构造器

public class Exercise7_9 {   public static void main(String[] args) {      new Stem();}}class Root{Component1 c1  = new Component1();Component2 c2  = new Component2();Component3 c3  = new Component3();    public Root() {    System.out.println("Root");    }}class Stem extends Root{    Component1 c1  = new Component1();    Component2 c2  = new Component2();    Component3 c3  = new Component3();    public Stem() {    System.out.println("Stem");    }    }    class Component1{    public Component1() {    System.out.println("Component1");    }}    class Component2{    public Component2() {    System.out.println("Component2");    }}    class Component3{    public Component3() {    System.out.println("Component3");    }}

练习10：修改练习9，使每个类都仅具有非默认的构造器。

public class Exercise7_10 {       public static void main(String[] args) {          new Stem2(1);    }    }    class Root2{    Componentb1 c1  = new Componentb1();    Componentb2 c2  = new Componentb2();    Componentb3 c3  = new Componentb3();        public Root2(int i) {        System.out.println("Root"+i);        }    }    class Stem2 extends Root2{        Componentb1 c1  = new Componentb1();        Componentb2 c2  = new Componentb2();        Componentb3 c3  = new Componentb3();        public Stem2(int i) {            super(i);            System.out.println("Stem2"+i);        }        }        class Componentb1{        public Componentb1() {        System.out.println("Component1");        }    }        class Componentb2{        public Componentb2() {        System.out.println("Component2");        }    }        class Componentb3{        public Componentb3() {        System.out.println("Component3");        }    }

练习11: 修改Detergent.java。让它使用代理。

public class Exercise7_11 {    public static void main(String[] args) {        DetergentDelegation delegation = new DetergentDelegation();        delegation.append("Detergent");        System.out.println(delegation);    }}class Cleanser2 {      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; }    }class DetergentDelegation{    private Cleanser2 c = new Cleanser2();      public void append(String a) { c.append(a);}      public void dilute() {c.dilute(); }      public void apply() { c.apply(); }      public void scrub() { c.scrub(); }      public String toString() { return c.toString(); }}

//Detergent.Javaclass 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 {      // Change a method:      public void scrub() {        append(" Detergent.scrub()");        super.scrub(); // Call base-class version      }      // Add methods to the interface:      public void foam() { append(" foam()"); }      // Test the new class:      public static void main(String[] args) {        Detergent x = new Detergent();        x.dilute();        x.apply();        x.scrub();        x.foam();        System.out.println(x);        System.out.println("Testing base class:");        Cleanser.main(args);      }     } 

练习12：将一个适当的dispose()方法的层次结构添加到练习9的所有类中。

public class Exercise7_12 {     public static void main(String[] args) {         new Stemc().dispose();    }}class Rootc{Componentc1 c1  = new Componentc1();Componentc2 c2  = new Componentc2();Componentc3 c3  = new Componentc3();    public Rootc() {    System.out.println("Root");    }    public void dispose() {        System.out.println("Rootc.dispose()");        c1.dispose();        c2.dispose();        c3.dispose();    }}class Stemc extends Rootc{    Componentc1 c1  = new Componentc1();    Componentc2 c2  = new Componentc2();    Componentc3 c3  = new Componentc3();    public Stemc() {    System.out.println("Stem");    }    public void dispose() {        System.out.println("Rootc.dispose()");        c1.dispose();        c2.dispose();        c3.dispose();        super.dispose();    }    }    class Componentc1{    public Componentc1() {    System.out.println("Component1");    }    public void dispose() {        System.out.println("Componentc1.dispose()");    }}    class Componentc2{    public Componentc2() {    System.out.println("Component2");       }    public void dispose() {        System.out.println("Componentc2.dispose()");    }}    class Componentc3{    public Componentc3() {    System.out.println("Component3");      }    public void dispose() {        System.out.println("Componentc3.dispose()");        }    }

练习13: 创建一个类，它应带有一个被重载了三次的方法。继承产生一个新类，并添加一个该方法的新的重载定义，展示这四个方法在导出类中都是可以使用的。

public class Exercise7_13 {     public static void main(String[] args) {        MoreOverloads moreOverloads = new MoreOverloads();        moreOverloads.f(1);        moreOverloads.f(1.1);        moreOverloads.f('c');        moreOverloads.f("Hello");    }}class ThreeOverLoads{    public void f(int i) {        System.out.println("f(int i)");    }    public void f(double d) {        System.out.println("f(double d)");    }    public void f(char c) {        System.out.println("f(char c)");    }}class MoreOverloads extends ThreeOverLoads{    public void f(String s) {        System.out.println("f(string s)");    }}

练习14：在Car.java中给Engine添加一个service(),并在main()中调用该方法。

public class Exercise7_14 {    public static void main(String[] args) {                Car car = new Car();                car.left.window.rollup();                car.wheel[0].inflate(72);                car.engine.Service();    }}class Engine {      public void start() {}      public void rev() {}      public void stop() {}      public void Service() {          System.out.println("Engine.Service");      }    }    class Wheel {      public void inflate(int psi) {}    }    class Window {      public void rollup() {}      public void rolldown() {}    }    class Door {      public Window window = new Window();      public void open() {}      public void close() {}    } class Car {      public Engine engine = new Engine();      public Wheel[] wheel = new Wheel[4];      public Door        left = new Door(),        right = new Door(); // 2-door      public Car() {        for(int i = 0; i < 4; i++)          wheel[i] = new Wheel();      }    }  

练习15： 在包中编写一个类，类应具备一个protected方法。在包外部，试着调用protede方法并解释其结果。然后，从你的类中继承产生一个类，并从该导出类的方法内部调用该protected方法

练习16：创建一个名为Amphibian的类，由此继承产生一个成为Frog的类，在基类中设置适当的方法，在main（）中，创建一个Frog向上转型至Amphibian， 然后说明所有方法都可工作。

public class Exercise7_16 {      public static void main(String[] args) {          Amphibian amphibian = new Frog();          amphibian.moveInWater();          amphibian.moveInLand();    }} class Amphibian{     public void moveInWater() {         System.out.println("moveInWater");     }     public void moveInLand() {         System.out.println("moveInLand");     } } class Frog extends Amphibian{ }

练习17：修改练习16，使Frog覆盖基类中方法的定义。请留心main中都发生了什么

public class Exercise7_17 {      public static void main(String[] args) {          Amphibian2 amphibian = new Frog2();          amphibian.moveInWater();          amphibian.moveInLand();    }}class Amphibian2{     public void moveInWater() {         System.out.println("moveInWater");     }     public void moveInLand() {         System.out.println("moveInLand");     }}class Frog2 extends Amphibian2{     public void moveInWater() {         System.out.println("Frog.moveInWater");     }     public void moveInLand() {         System.out.println("Frog.moveInLand");     }}

练习18：创建一个含有static final域和final域的类，说明二者间的区别。

    public class Exercise7_18 {          public static void main(String[] args) {             System.out.println("First Object");             System.out.println(new WithFinalFields());             System.out.println("Second Object");             System.out.println(new WithFinalFields());        }    }class SelfCounter{    private static int count;    private int id = count++;    public String toString(){        return "Selfcounter"+id;    }}class WithFinalFields{    final SelfCounter selfCounter = new SelfCounter();    static final SelfCounter s = new SelfCounter();    public String toString(){        return "selfcounter = "+selfCounter+" \ns = "+s;    }}

练习19 ： 创建一个含有指向某对象的空白final引用类。在所有构造器内部都执行空白final的初始化操作。说明Java确保final在使用前必须初始化，且一旦被初始化即无法改变

public class Exercise7_19 {    public static void main(String[] args) {    WithFInalBlankField field = new WithFInalBlankField(10);        System.out.println(field.geti());    }}class WithFInalBlankField{    private final Integer i;    public WithFInalBlankField(int i1) {        i = new Integer(i1);    }    public Integer geti() {//      if(i==null) {//          i= new Integer(47);//      }        return i;    }}

练习20：展示@Override注解可以解决本节中的问题

class WithFinals {      // Identical to "private" alone:     private final void f() { System.out.println("WithFinals.f()"); }      // Also automatically "final":      private void g() { System.out.println("WithFinals.g()"); }    }    class OverridingPrivate extends WithFinals {      private final void f() {          System.out.println("OverridingPrivate.f()");      }      private void g() {          System.out.println("OverridingPrivate.g()");      }    }    class OverridingPrivate2 extends OverridingPrivate {      public final void f() {          System.out.println("OverridingPrivate2.f()");      }      public void g() {          System.out.println("OverridingPrivate2.g()");      }    }    public class FinalOverridingIllusion {      public static void main(String[] args) {      OverridingPrivate2 op2 = new OverridingPrivate2();        op2.f();        op2.g();        // You can upcast:        OverridingPrivate op = op2;        // But you can't call the methods:        //! op.f();        //! op.g();        // Same here:        WithFinals wf = op2;        //! wf.f();        //! wf.g();      }    }

public class Exercise7_20 {   public static void main(String[] args) {       OverridingPrivate20 oPrivate = new OverridingPrivate20();             //  oPrivate.f();       //  oPrivate.g();}}class OverridingPrivate20 extends WithFinals{    @Override private final void f() {        System.out.println("OverridingPrivate.f()");    }    @Override private  void g() {        System.out.println("OverridingPrivate.g()");    }}class OverridingPrivate30 extends OverridingPrivate20{    @Override public  void f() {        System.out.println("OverridingPrivate2.f()");    }    @Override public  void g() {        System.out.println("OverridingPrivate2.g()");    }}

练习21：创建一个但final方法的类。由此继承产生一个类并尝试覆盖该方法

public class Exercise7_21 extends WithFinalMethod{//   void f() {//     //   }   public static void main(String[] args) {}}class WithFinalMethod{    final void f() {    }}

练习22： 创建一个final类并试着继承它

public class Exercise7_22 extends FinalClass {    public static void main(String[] args) {    }}final class FinalClass{}

练习23： 请证明加载类的动作仅发生一次。证明该类的第一个实体的创建者或者对static成员的访问都有可能引起加载

public class Exercise7_23 {     public static void main(String[] args) {        System.out.println("Calling static member");        LoadTest.staticMember();        System.out.println("Creating an object");        new LoadTest();    }}class LoadTest{    static{        System.out.println("Loading loadTest");    }    static void staticMember() {};}

练习24：在Beetle.java中，从Beetle类继承产生一个具体类型的“甲壳虫”。其形式与现有类相同，跟踪并解释其输出结果

public class Exercise7_24 {        public static void main(String[] args) {            new JapaneseBeetle();        }    }    class JapaneseBeetle extends Beetle{         int m = printInit("JapaneseBeetle.m.initilized");        public JapaneseBeetle() {            System.out.println("m = "+m);            System.out.println("j = "+j);        }        static int x3 = printInit("static JapansesBeetle.x3 initlized");    }

//Beetle.javaclass Insect {      private int i = 9;      protected int j;      Insect() {        System.out.println("i = " + i + ", j = " + j);        j = 39;      }      private static int x1 =        printInit("static Insect.x1 initialized");      static int printInit(String s) {          System.out.println(s);        return 47;      }    }    public class Beetle extends Insect {      private int k = printInit("Beetle.k initialized");      public Beetle() {          System.out.println("k = " + k);          System.out.println("j = " + j);      }      private static int x2 =        printInit("static Beetle.x2 initialized");      public static void main(String[] args) {          System.out.println("Beetle constructor");        Beetle b = new Beetle();      }    } /* Output:    static Insect.x1 initialized    static Beetle.x2 initialized    Beetle constructor    i = 9, j = 0    Beetle.k initialized    k = 47    j = 39    *///:~