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;

     }
 }
}