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

练习1：创建一个类，它包含一个未初始化的String引用。验证该引用被Java初始化成了null。

public class Exercise5_1 {    String s;    public static void main(String[] args) {        Exercise5_1 exercise5_1 = new Exercise5_1();        System.out.println("s = "+exercise5_1.s);    }}

练习2：创建一个类，它包含一个在定义时就被初始化了的String域，以及另一个通过构造器初始化的String域。这两种方式有何差异。

public class Exercise5_2 {       String s1 ="Initialized at definition";       String s2;    public Exercise5_2(String s) {        s2 = s;    }    public static void main(String[] args) {        Exercise5_2 exercise5_2 = new Exercise5_2("Initialized at constructor");        System.out.println("s1 = "+exercise5_2.s1);        System.out.println("s2 = "+exercise5_2.s2);     }}

练习3：创建一个带默认构造器（即无参构造器）的类，在构造器中打印一条消息。为这个类创建一个对象。

public class Exercise5_3 {    public Exercise5_3() {        System.out.println("Default Constructor");    }    public static void main(String[] args) {        new Exercise5_3();    }}

练习4：为前一个练习中的类添加一个重载构造器，令其接受一个字符参数，并在构造器中把你自己的信息和接受的参数一起打印出来。

public class Exercise5_4 {    public Exercise5_4() {        System.out.println("Default Constructor");     }    public Exercise5_4(String s) {        System.out.println(s);     }    public static void main(String[] args) {        new Exercise5_4();        new Exercise5_4("OverLoaded");    }}

练习5：创建一个名为Dog的类，它具有重载的bark（）方法。此方法应根据不同的基本数据类型进行重载，并根据被调用的版本，打印出不同类型的狗吠（barking）、咆哮（howling）等信息，编写main（）来调用所有不同版本的方法。

public class Exercise5_5 {     public static void main(String[] args) {        Dog dog = new Dog();        dog.bark();        dog.bark(1);    }} class Dog{     public void bark() {         System.out.println("barking");     }     public void bark(int i) {         System.out.println("howling");     } }

练习6：修改前一个练习的程序，让两个重载方法各自接受两个类型的不同的参数，但二者顺序相反。验证其是否工作。

public class Exercise5_6 {  public static void main(String[] args) {    Dog2 dog = new Dog2();    dog.bark(1, 1.1);    dog.bark(1.1, 1);}}class Dog2{     public void bark(int i,double d) {         System.out.println("barking");     }     public void bark(double d,int i) {         System.out.println("howling");     }}

练习7：创建一个没有构造器的类，并在main（）中创建其对象，用以验证编译器是否真的自动加入了默认构造器。

public class Exercise5_7 {    public static void main(String[] args) {        new Exercise5_7();    }}

练习8：编写具有两个方法的类，在第一个方法内调用第二个方法两次：第一次调用时不使用this关键字，第二次调用时使用this关键字————这里只是为了验证它是起作用的，你不应该在实践中使用这种方法。

public class Exercise5_8 {      public void a() {          b();          this.b();      }      public void b() {          System.out.println("b()");      }      public static void main(String[] args) {        new Exercise5_8().a();    }}

练习9：编写两个（重载）构造器的类，并在第一个构造器中,通过this调用第二个构造器。

public class Exercise5_9 {    public Exercise5_9(int i) {        System.out.println(i);    }    public Exercise5_9() {        this(1);    }    public static void main(String[] args) {        new Exercise5_9();    }}

练习10：编写具有finalize（）方法的类，并在方法中打印消息，在main（）中为该类创建一个对象，试解释这个程序的行为。

public class Exercise5_10 {    protected void finalize() {      System.out.println("finalize");   }    public static void main(String[] args) {        new Exercise5_10();    }}

练习11：修改前一个练习的程序,让你的finalize（）总会被调用。

public class Exercise5_11 {    protected void finalize() {          System.out.println("finalize");       }    public static void main(String[] args) {        new Exercise5_11();        System.gc();        System.runFinalization();    }}

练习12：（4）编写名为Tank的类，此类的状态可以是“满的”或“空的”。其终结条件是：对象被清理时必须处于空状态。 * 请编写finalize（）以检验终结条件是否成立，在main（）中测试Tank可能发生的几种使用方式

public class Exercise5_12 {    public static void main(String[] args) {        new Tank().empry();        new Tank();        System.gc();        System.runFinalization();    }}   class Tank{     static int counter;     int id = counter++;     boolean full;     public Tank() {         System.out.println("Tank"+id+" created");         full = true;     }     void empry() {         full = false;     }    protected void finalize() {        if(full) {            System.out.println("Error: Tank"+id+" must be empty at cleanup");        }else {            System.out.println("Tank"+id+" cleaned up Ok");        }    }}

练习13：验证前面段落中的语句

public class Exercise5_13 {    public static void main(String[] args) {        System.out.println("Inside main");        Cups.cup1.f(99);    }    static Cups cups1 = new Cups();    static Cups cups2 = new Cups();}class Cup{    Cup(int marker){        System.out.println("Cup("+marker+")");    }    void f(int marker) {        System.out.println("f("+marker+")");    }}class Cups{    static Cup cup1;    static Cup cup2;    static {        cup1 = new Cup(1);        cup2 = new Cup(2);    }    Cups(){        System.out.println("Cups");    }}

练习14：编写一个类，拥有两个静态字符串域，其中一个在定义处初始化，另一个在静态块中初始化。现在，加入一个静态方法用以打印出两个字段值。请证明它们都会在被使用之前完成初始化动作。

public class Exercise5_14 {            static String s1 = "s1";            static String s2 ;            static {                s2 ="s2";            }            public Exercise5_14() {                System.out.println(s1);                System.out.println(s2);            }            public static void main(String[] args) {                new Exercise5_14();            }}

练习15：编写一个含有字符串域的类，并采用实例初始化方式进行初始化。

public class Exercise5_15 {   String s;   {       s = "s1";   }   public Exercise5_15() {    System.out.println(s);   }   public Exercise5_15(int i) {        System.out.println(s);       }   public static void main(String[] args) {    new Exercise5_15();    new Exercise5_15(1);}}

练习16：创建一个String对象数据，并为每一个元素都赋值一个String。用for循环来打印该数组。

public class Exercise5_16 {    public static void main(String[] args) {        String s[] = new String[4];        s[0] = "These" ;        s[1] = "are" ;        s[2] = "some" ;        s[3] = "strings" ;        for (int i = 0; i < s.length; i++) {            System.out.println(s[i]);        }    }}

练习17：创建一个类，它有一个接受一个String参数的构造器。在构造阶段，打印该参数。创建一个该类的对象引用数组，但是不实际去创建对象赋值给该数组。当运行程序时，请注意来自对该构造器的调用中的初始化消息是否打印了出来

public class Exercise5_17 {    Exercise5_17(String s){        System.out.println(s);    }    Exercise5_17 []e1 = new Exercise5_17[5];    public static void main(String[] args) {        Exercise5_17 []e = new Exercise5_17[5];    }}

练习18：通过创建对象赋值给引用数组，从而完成前一个练习。

public class Exercise5_18 {      Exercise5_18(String s){            System.out.println(s);        }        public static void main(String[] args) {            Exercise5_18 []e = new Exercise5_18[5];            for (int i = 0; i < e.length; i++) {                e[i] = new Exercise5_18(Integer.toString(i));            }        }}

练习19：写一个类，他接受一个可变参数的String数组，验证你可以向该方法传递一个用逗号分隔的String列表，或是一个String[]。

public class Exercise5_19 {   public Exercise5_19(String...s) {       for (int i = 0; i < s.length; i++) {        System.out.println(s[i]);    }   }   public static void main(String[] args) {       String[]s = {"Hello","World"};    new Exercise5_19(s);}}

练习20：创建一个使用可变参数列表而不是普通的main()语法的main()。打印所产生的args数组的所有元素，并用各种不同数量的命令行参数来测试它。

public class Exercise5_20 {     public static void main(String...args) {        for (int i = 0; i < args.length; i++) {            System.out.println(args[i]);        }    }}

练习21：创建一个enum，它包含纸币中最小面值的6种类型。通过values()循环并打印每一个值及其ordinal（）

enum e{    ONE,TWO,FIVE,TEN,TWENTY,FIFTY}public class Exercise5_21 {    public static void main(String[] args) {        for(e e:e.values()) {            System.out.println(e+" "+e.ordinal());        }    }}

练习22：在前面的例子中，为enum写一个switch语句，对于每一个case，输出该特定货币的描述。

public class Exercise5_22 {      public static void main(String[] args) {        for(e e:e.values()) {            describe(e);        }    } static void describe( e e){     System.out.print(e+" has a portrait of ");     switch(e) {     case ONE:         System.out.println("George Washington");         break;     case TWO:         System.out.println("Thomas Jefferson");         break;     case FIVE:         System.out.println("Abraham Lincoln");         break;     case TEN:         System.out.println("Alexander Hamilton");         break;     case TWENTY:         System.out.println("Andrew Jackson");         break;     case FIFTY:         System.out.println("U.S. Grant");         break;     } }}