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

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

public class Ja7_1{
    First f;
    First getFirst(){
        if(f==null){
            System.out.println("A Index Was Created");
            f=new First();
        }
        return f;//"return" can't be put into a "if{}".
    }
    public static void main(String[] args){
        Ja7_1 s=new Ja7_1();
        System.out.println(s.getFirst());
    }
}
class First{
    public String toString(){return "I am indexed";} //can't lose "public"
}
class Second{

}

在Ja7_1类中，首先定义了First类的一个引用f，而后只有在main()方法调用getFirst()方法时, f才会被实例化。为了观察方便，在First类中写了toString()方法，当打印First类的对象时，会默认输出“I am indexed”。

值得注意的是：toString()方法一定要设成public。同时getFirst()中的return语句一定要在if语句之外。

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

import static net.mindview.util.Print.*;

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();
    print(x);
  }
}	

class Detergent extends Cleanser {
  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();
    print(x);
    print("Testing base class:");
    Cleanser.main(args);
  }	
} 

public class Ja7_2 extends Detergent{
    public void scrub(){
        append("Ja7_2.scrub()");
         super.scrub();
    }
    public void sterilize(){
            append("sterilize()");
    }
    public static void main(String[] args){
        Ja7_2 x=new Ja7_2();
        x.dilute();
        x.apply();
        x.scrub();
        x.foam();
        x.sterilize();
        print(x);
        print("Testing base class:");
        Detergent.main(args);
    }
}

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

import static net.mindview.util.Print.*;
class A{
    public /*void*/ A(){
        print("A{}");
    }
}
class B{
    public /*void*/ B(){
        print("B{}");
    }
}
class C extends A{
    B b=new B();
    /*public  C(){
        print("C{}");
    }*/
}
public class Ja7_2_1{
    public static void main(String[] args){
        C c=new C();
    }
}

PS：为了自动调用A和B的构造器时能有print()输出，则A()和B()方法的返回值不能是“void”，应该缺省。

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

import static net.mindview.util.Print.*;
class Root{
    Component1 c1=new Component1();
    Component2 c2=new Component2();
    Component3 c3=new Component3();
    public Root(){
    print("root");
    }
}
class Component1{
    public Component1(){
    print("c1");
    }
}
class Component2{
    public Component2(){
    print("c2");
    }
}
class Component3{
    public Component3(){
    print("c3");
    }
}
class Stem extends Root{
    Component1 c1=new Component1();
    Component2 c2=new Component2();
    Component3 c3=new Component3();
    public Stem(){
    print("stem");
    }
}
public class Ja7_2_9{
    public static void main(String[] args){
        Stem st=new Stem();
    }
}
/*output:
c1
c2
c3
root
c1
c2
c3
stem
 * */