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。让它使用代理。

扫描二维码关注公众号，回复： 1950977 查看本文章

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.Java
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);
      } 
    }

练习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.java
class 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
    *///:~

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

猜你喜欢