【TIJ4】第五章全部习题

 1 package ex0501;
 2 //[5.1]创建一个类,它包含一个未初始化的String引用.验证该引用被Java初始化成null
 3 
 4 class TestDefaultNull
 5 {
 6     public String string;
 7 }
 8 
 9 public class DefaultNull 
10 {
11     public static void main(String[] args)
12     {
13         TestDefaultNull test = new TestDefaultNull();
14         System.out.println((test.string == null));
15     }
16 }

 1 package ex0502;
 2 //[5.2]创建一个雷,它包含一个在定义时就被初始化了的String域,以及一个通过构造器初始化的String域.
 3 //这两种方式有何差异?
 4 
 5 public class ClassInitialize 
 6 {
 7     public String s1 = "defaults1";
 8     public String s2;
 9     
10     public ClassInitialize(String _s2) { s2 = _s2; }
11     public ClassInitialize() { s2 = null; }
12 }

 1 package ex050304;
 2 //[5.3]创建一个带默认构造器的类,在构造器中打印一条消息,为这个类创建一个对象.
 3 //[5.4]为前一个练习中的类添加一个重载构造器,令其接受一个字符串参数,并在构造器中把你自己的消息和接收的参数一起打印出来.
 4 public class TestConstructor 
 5 {
 6     //[5.3]
 7     public TestConstructor() { System.out.println("Success!"); }
 8     //[5.4]
 9     public TestConstructor(String s)
10     {
11         System.out.println(s);
12         System.out.println("Success!");
13     }
14     
15     public static void main(String[] args)
16     {
17         TestConstructor test1 = new TestConstructor();
18         TestConstructor test2 = new TestConstructor("another");
19         
20     }
21 }

 1 package ex050506;
 2 //[5.5]创建一个名为Dog的类,它具有重载的bark()方法.
 3 //此方法根据不同的基本数据进行重载,并根据被调用的版本,打印出不同类型的狗吠(barking)\咆哮(howling)等信息.
 4 //[5.6]修改前一个练习的程序,让两个重载方法各自接受两个类型不同的参数,但两者顺序相反,验证其是否工作
 5 
 6 class Dog
 7 {
 8     //[5.5]
 9     public void bark(double temp){ System.out.println("barking"); }
10     public void bark(int temp){ System.out.println("howling"); }
11     
12     //[5.6]
13     public void bark(double temp, int temp2){ System.out.println("barking barking"); }
14     public void bark(int temp, double temp2){ System.out.println("howling howling"); }
15 }
16 
17 public class FunctionReload 
18 {
19     public static void main(String[] args)
20     {
21         Dog dog = new Dog();
22         //[5.5]
23         dog.bark(1.0);
24         dog.bark(1);
25         //[5.6]
26         dog.bark(1.0 , 1);
27         dog.bark(1 , 1.0);
28     }
29 }

 1 package ex0507;
 2 //[5.7]穿件一个没有构造器的类,并在main()中创建其对象,用以验证编译器是否真正加入了构造器
 3 
 4 class LooksNoConstructor
 5 {
 6     public int integer;
 7     public double decimal;
 8     public String string;
 9 }
10 
11 public class TestDefaultConstrutor 
12 {
13     public static void main(String[] args)
14     {
15         LooksNoConstructor test = new LooksNoConstructor();
16     }
17 }

 1 package ex0508;
 2 //[5.8]编写具有两个方法的类,在第一个方法内调用第二个方法两次.
 3 //第一次调用时不使用this关键字,第二次调用时使用this关键字——这里只是为了验证它是起作用的。
 4 
 5 class TestThisByMethod
 6 {
 7     public void firstMethod()
 8     {
 9         System.out.println("Good day!");
10     }
11     public void secondMethod()
12     {
13         firstMethod();
14         this.firstMethod();
15     }
16 }
17 
18 
19 public class TestThis 
20 {
21     public static void main(String[] args)
22     {
23         TestThisByMethod justtry = new TestThisByMethod();
24         justtry.secondMethod();
25     }
26 }

 1 package ex0509;
 2 
 3 //[5.9]编写具有两个(重载)构造器的类,并在第一个构造器中通过this调用第二个构造器.
 4 
 5 public class ConstructorInConstructor 
 6 {
 7     //[5.3]
 8     public ConstructorInConstructor() { System.out.println("Success!"); }
 9     //[5.4]
10     public ConstructorInConstructor(String s)
11     {
12         this();
13         System.out.println(s);
14     }
15     
16     public static void main(String[] args)
17     {
18         ConstructorInConstructor test1 = new ConstructorInConstructor();
19         ConstructorInConstructor test2 = new ConstructorInConstructor("another");
20         
21     }
22 }

 1 package ex051011;
 2 //[5.10]编写具有finalize()方法的类,并在方法中打印信息.在main()中为该类创建一个对象.
 3 //试解释这个程序的行为
 4 //[5.11]修改前一个练习的程序,让你的finalize()总会被调用
 5 
 6 class HaveAFinalize
 7 {
 8     protected void finalize()
 9     {
10         System.out.println("finalize() excecuted");
11     }
12 }
13 
14 public class TestFinalize 
15 {
16     public static void main(String[] args)
17     {
18         //[5.10]
19         //如果只有一次创建对象,finalize(有很大)可能不执行
20         HaveAFinalize test = new HaveAFinalize();
21         //[5.11]
22         //要保证finalize()被调用,则需保证至少有一次垃圾清理过程,通过分配大量内存可以看到这点
23         for(int i = 0; i < 100000; ++i)
24             new HaveAFinalize();
25     }
26 }

 1 package ex0512;
 2 //[5.12]编写名为Tank的类,此类的状态可以使"满的"或者"空的".其终结条件是:对象呗清理时必须处于空状态
 3 //请编写finalize()以检验终结条件是是否成立.在main()中测试Tank可能发生的集中调试方式
 4 
 5 class Tank
 6 {
 7     private boolean state = false;
 8     
 9     public Tank() { state = true; }
10     protected void finalize()
11     {
12         if(state == true)
13             System.out.println("Warning! Still someone in the tank!");
14     }
15 }
16 
17 public class KindOfUseFinalize 
18 {
19 
20 }

 1 package ex0512;
 2 //[5.12]编写名为Tank的类,此类的状态可以使"满的"或者"空的".其终结条件是:对象呗清理时必须处于空状态
 3 //请编写finalize()以检验终结条件是是否成立.在main()中测试Tank可能发生的集中调试方式
 4 
 5 class Tank
 6 {
 7     private boolean state = false;
 8     
 9     public Tank() { state = true; }
10     protected void finalize()
11     {
12         if(state == true)
13             System.out.println("Warning! Still someone in the tank!");
14     }
15 }
16 
17 public class KindOfUseFinalize 
18 {
19 
20 }

 1 package ex0514;
 2 //[5.14]编写一个类,拥有两个静态字符串域,其中一个在定义处初始化,另一个在静态块中初始化.
 3 //现在,加入一个静态方法用以打印出两个字段值,请证明它们都会再被使用之前完成初始化动作.
 4 
 5 class ProveStaticInitializeEarlier
 6 {
 7     public static String s1 = "Good";
 8     public static String s2;
 9     
10     ProveStaticInitializeEarlier(int number)
11     {
12         System.out.println(s1 + s2 + number);
13     }
14     public static void printInfo()
15     {
16         System.out.println(s1 + s2);
17     }
18     public void notStaticMethod()
19     {
20         System.out.println("meow!");
21     }
22     static
23     {
24         s2 = "bye";
25     }
26 }
27 
28 public class StaticInitializeEarlier 
29 {
30     public static void main(String[] args)
31     {
32         ProveStaticInitializeEarlier test2 = new ProveStaticInitializeEarlier(1);
33         test2.notStaticMethod();
34     }
35     static ProveStaticInitializeEarlier test1 = new ProveStaticInitializeEarlier(2);
36 }

 1 package ex0515;
 2 //[5.15]编写一个含字符串域的类,并采用实例初始化方式进行初始化
 3 
 4 class TestInstanceInitialize
 5 {
 6     String string;
 7     {
 8         string = new String("finish");
 9         System.out.println("The object has been initialized");
10     }
11 }
12 
13 public class InstanceInitialize 
14 {
15     public static void main(String[] args)
16     {
17         TestInstanceInitialize test = new TestInstanceInitialize();
18     }
19 }

 1 package ex0516;
 2 //[5.16]创建一个String对象数据,并为每一个元素都赋值一个String
 3 //用for循环来打印该数组
 4 
 5 public class StringArray 
 6 {
 7     public static void main(String[] args)
 8     {
 9         String[] animals = {"cat", "dog", "bird", "fish", "panda"};
10         for(String a : animals)
11             System.out.println(a);
12     }
13 }

 1 package ex051718;
 2 //[5.17]创建一个类,它有一个接收一个String参数的构造器.在构造阶段,打印该参数
 3 //创建一个该类的对象的数组,但是不实际去创建对象赋值给数组.当运行程序时,注意来自对该构造器的调用总的初始化消息是否打印了出来
 4 //[5.18]通过创建对象赋值给引用数组,从而完成前一个练习
 5 class GetMessage
 6 {
 7     public GetMessage(String s)
 8     {
 9         System.out.println(s);
10     }
11 }
12 public class ObjectArray 
13 {
14     public static void main(String[] args)
15     {
16         //[5.17]如果没有[5.18]则不会打印任何信息
17         GetMessage[] group;
18         //[5.18]
19         group = new GetMessage[]
20         {
21             new GetMessage("the"),
22             new GetMessage("Great"),
23             new GetMessage("Wall"),
24         };
25     }
26 }

 1 package ex0519;
 2 //[5.19]写一个雷,它接受一个可变参数的String数组.验证你可以向该方法传递一个用逗号分隔的String列表,或是一个String[].
 3 
 4 class GetStringArgs
 5 {
 6     public GetStringArgs(String...strings)
 7     {
 8         for(String s : strings)
 9             System.out.println(s);
10     }
11 }
12 
13 public class VariableArguements 
14 {
15     public static void main(String[] args)
16     {
17         String[] sarray = {"Monday", "Tuesday", "Wenesday"};
18         GetStringArgs test = new GetStringArgs(sarray);
19         GetStringArgs test2 = new GetStringArgs("Thursday", "Friday", "Saturday", "Sunday");
20     }
21 }

 1 package ex0520;
 2 //[5.20]创建一个使用可变参数列表而不是普通的main()语法的main()
 3 //打印所产生的args数组的所有元素,并用各种不同数量的命令行参数来测试它
 4 
 5 public class MainVariableArguements 
 6 {
 7     public static void main(String...args)
 8     {
 9         for(String s : args)
10             System.out.println(s);
11     }
12 }

 1 package ex052122;
 2 //[5.21]创建一个enum,它包含纸币中最小面值的6种类型.通过values()循环并打印每一个值及其ordinal().
 3 //[5.22]在前面的例子中,为enum写一个switch语句,对于每一个case,输出该特定货币的描述
 4 
 5 enum Money
 6 {
 7     ONEDIME, FIVEDIME, ONEYUAN, FIVEYUAN, TENYUAN, TWENTYYUAN;
 8     //[5.22]
 9     public void discribe()
10     {
11         switch(this)
12         {
13         case ONEDIME:
14             System.out.println("一毛钱");break;
15         case FIVEDIME:
16             System.out.println("五毛!");break;
17         case ONEYUAN:
18             System.out.println("一块钱");break;
19         case FIVEYUAN:
20             System.out.println("五块");break;
21         case TENYUAN:
22             System.out.println("十块");break;
23         case TWENTYYUAN:
24             System.out.println("二十块");break;
25         }
26     }
27 }
28 public class TestEnumeration
29 {
30     public static void main(String[] args)
31     {
32         //[5.21]
33         for(Money s : Money.values())
34             System.out.println(s);
35         //[5.22]
36         Money test = Money.ONEDIME;
37         test.discribe();
38     }
39 }