【TIJ4】第五章全部习题

第五章习题

5.1

 package ex0501;
 //[5.1]创建一个类,它包含一个未初始化的String引用.验证该引用被Java初始化成null

 class TestDefaultNull
 {
     public String string;
 }

 public class DefaultNull
 {
     public static void main(String[] args)
     {
         TestDefaultNull test = new TestDefaultNull();
         System.out.println((test.string == null));
     }
 }

5.1

5.2

 package ex0502;
 //[5.2]创建一个雷,它包含一个在定义时就被初始化了的String域,以及一个通过构造器初始化的String域.
 //这两种方式有何差异?

 public class ClassInitialize
 {
     public String s1 = "defaults1";
     public String s2;

     public ClassInitialize(String _s2) { s2 = _s2; }
     public ClassInitialize() { s2 = null; }
 }

5.2

5.3-5.4

 package ex050304;
 //[5.3]创建一个带默认构造器的类,在构造器中打印一条消息,为这个类创建一个对象.
 //[5.4]为前一个练习中的类添加一个重载构造器,令其接受一个字符串参数,并在构造器中把你自己的消息和接收的参数一起打印出来.
 public class TestConstructor
 {
     //[5.3]
     public TestConstructor() { System.out.println("Success!"); }
     //[5.4]
     public TestConstructor(String s)
     {
         System.out.println(s);
         System.out.println("Success!");
     }

     public static void main(String[] args)
     {
         TestConstructor test1 = new TestConstructor();
         TestConstructor test2 = new TestConstructor("another");

     }
 }

5.3-5.4

5.5-5.6

 package ex050506;
 //[5.5]创建一个名为Dog的类,它具有重载的bark()方法.
 //此方法根据不同的基本数据进行重载,并根据被调用的版本,打印出不同类型的狗吠(barking)\咆哮(howling)等信息.
 //[5.6]修改前一个练习的程序,让两个重载方法各自接受两个类型不同的参数,但两者顺序相反,验证其是否工作

 class Dog
 {
     //[5.5]
     public void bark(double temp){ System.out.println("barking"); }
     public void bark(int temp){ System.out.println("howling"); }

     //[5.6]
     public void bark(double temp, int temp2){ System.out.println("barking barking"); }
     public void bark(int temp, double temp2){ System.out.println("howling howling"); }
 }

 public class FunctionReload
 {
     public static void main(String[] args)
     {
         Dog dog = new Dog();
         //[5.5]
         dog.bark(1.0);
         dog.bark(1);
         //[5.6]
         dog.bark(1.0 , 1);
         dog.bark(1 , 1.0);
     }
 }

5.5-5.6

5.7

 package ex0507;
 //[5.7]穿件一个没有构造器的类,并在main()中创建其对象,用以验证编译器是否真正加入了构造器

 class LooksNoConstructor
 {
     public int integer;
     public double decimal;
     public String string;
 }

 public class TestDefaultConstrutor
 {
     public static void main(String[] args)
     {
         LooksNoConstructor test = new LooksNoConstructor();
     }
 }

5.7

5.8

 package ex0508;
 //[5.8]编写具有两个方法的类,在第一个方法内调用第二个方法两次.
 //第一次调用时不使用this关键字,第二次调用时使用this关键字——这里只是为了验证它是起作用的。

 class TestThisByMethod
 {
     public void firstMethod()
     {
         System.out.println("Good day!");
     }
     public void secondMethod()
     {
         firstMethod();
         this.firstMethod();
     }
 }

 public class TestThis
 {
     public static void main(String[] args)
     {
         TestThisByMethod justtry = new TestThisByMethod();
         justtry.secondMethod();
     }
 }

5.8

5.9

 package ex0509;

 //[5.9]编写具有两个(重载)构造器的类,并在第一个构造器中通过this调用第二个构造器.

 public class ConstructorInConstructor
 {
     //[5.3]
     public ConstructorInConstructor() { System.out.println("Success!"); }
     //[5.4]
     public ConstructorInConstructor(String s)
     {
         this();
         System.out.println(s);
     }

     public static void main(String[] args)
     {
         ConstructorInConstructor test1 = new ConstructorInConstructor();
         ConstructorInConstructor test2 = new ConstructorInConstructor("another");

     }
 }

5.9

5.10-5.11

 package ex051011;
 //[5.10]编写具有finalize()方法的类,并在方法中打印信息.在main()中为该类创建一个对象.
 //试解释这个程序的行为
 //[5.11]修改前一个练习的程序,让你的finalize()总会被调用

 class HaveAFinalize
 {
     protected void finalize()
     {
         System.out.println("finalize() excecuted");
     }
 }

 public class TestFinalize
 {
     public static void main(String[] args)
     {
         //[5.10]
         //如果只有一次创建对象,finalize(有很大)可能不执行
         HaveAFinalize test = new HaveAFinalize();
         //[5.11]
         //要保证finalize()被调用,则需保证至少有一次垃圾清理过程,通过分配大量内存可以看到这点
         for(int i = 0; i < 100000; ++i)
             new HaveAFinalize();
     }
 }

5.10-5.11

5.12

 package ex0512;
 //[5.12]编写名为Tank的类,此类的状态可以使"满的"或者"空的".其终结条件是:对象呗清理时必须处于空状态
 //请编写finalize()以检验终结条件是是否成立.在main()中测试Tank可能发生的集中调试方式

 class Tank
 {
     private boolean state = false;

     public Tank() { state = true; }
     protected void finalize()
     {
         if(state == true)
             System.out.println("Warning! Still someone in the tank!");
     }
 }

 public class KindOfUseFinalize
 {

 }

5.12

5.13

 package ex0512;
 //[5.12]编写名为Tank的类,此类的状态可以使"满的"或者"空的".其终结条件是:对象呗清理时必须处于空状态
 //请编写finalize()以检验终结条件是是否成立.在main()中测试Tank可能发生的集中调试方式

 class Tank
 {
     private boolean state = false;

     public Tank() { state = true; }
     protected void finalize()
     {
         if(state == true)
             System.out.println("Warning! Still someone in the tank!");
     }
 }

 public class KindOfUseFinalize
 {

 }

5.13

5.14

 package ex0514;
 //[5.14]编写一个类,拥有两个静态字符串域,其中一个在定义处初始化,另一个在静态块中初始化.
 //现在,加入一个静态方法用以打印出两个字段值,请证明它们都会再被使用之前完成初始化动作.

 class ProveStaticInitializeEarlier
 {
     public static String s1 = "Good";
     public static String s2;

     ProveStaticInitializeEarlier(int number)
     {
         System.out.println(s1 + s2 + number);
     }
     public static void printInfo()
     {
         System.out.println(s1 + s2);
     }
     public void notStaticMethod()
     {
         System.out.println("meow!");
     }
     static
     {
         s2 = "bye";
     }
 }

 public class StaticInitializeEarlier
 {
     public static void main(String[] args)
     {
         ProveStaticInitializeEarlier test2 = new ProveStaticInitializeEarlier(1);
         test2.notStaticMethod();
     }
     static ProveStaticInitializeEarlier test1 = new ProveStaticInitializeEarlier(2);
 }

5.14

5.15

 package ex0515;
 //[5.15]编写一个含字符串域的类,并采用实例初始化方式进行初始化

 class TestInstanceInitialize
 {
     String string;
     {
         string = new String("finish");
         System.out.println("The object has been initialized");
     }
 }

 public class InstanceInitialize
 {
     public static void main(String[] args)
     {
         TestInstanceInitialize test = new TestInstanceInitialize();
     }
 }

5.15

5.16

 package ex0516;
 //[5.16]创建一个String对象数据,并为每一个元素都赋值一个String
 //用for循环来打印该数组

 public class StringArray
 {
     public static void main(String[] args)
     {
         String[] animals = {"cat", "dog", "bird", "fish", "panda"};
         for(String a : animals)
             System.out.println(a);
     }
 }

5.16

5.17-5.18

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

5.17-5.18

5.19

 package ex0519;
 //[5.19]写一个雷,它接受一个可变参数的String数组.验证你可以向该方法传递一个用逗号分隔的String列表,或是一个String[].

 class GetStringArgs
 {
     public GetStringArgs(String...strings)
     {
         for(String s : strings)
             System.out.println(s);
     }
 }

 public class VariableArguements
 {
     public static void main(String[] args)
     {
         String[] sarray = {"Monday", "Tuesday", "Wenesday"};
         GetStringArgs test = new GetStringArgs(sarray);
         GetStringArgs test2 = new GetStringArgs("Thursday", "Friday", "Saturday", "Sunday");
     }
 }

5.19

5.20

 package ex0520;
 //[5.20]创建一个使用可变参数列表而不是普通的main()语法的main()
 //打印所产生的args数组的所有元素,并用各种不同数量的命令行参数来测试它

 public class MainVariableArguements
 {
     public static void main(String...args)
     {
         for(String s : args)
             System.out.println(s);
     }
 }

5.20

5.21-5.22

 package ex052122;
 //[5.21]创建一个enum,它包含纸币中最小面值的6种类型.通过values()循环并打印每一个值及其ordinal().
 //[5.22]在前面的例子中,为enum写一个switch语句,对于每一个case,输出该特定货币的描述

 enum Money
 {
     ONEDIME, FIVEDIME, ONEYUAN, FIVEYUAN, TENYUAN, TWENTYYUAN;
     //[5.22]
     public void discribe()
     {
         switch(this)
         {
         case ONEDIME:
             System.out.println("一毛钱");break;
         case FIVEDIME:
             System.out.println("五毛!");break;
         case ONEYUAN:
             System.out.println("一块钱");break;
         case FIVEYUAN:
             System.out.println("五块");break;
         case TENYUAN:
             System.out.println("十块");break;
         case TWENTYYUAN:
             System.out.println("二十块");break;
         }
     }
 }
 public class TestEnumeration
 {
     public static void main(String[] args)
     {
         //[5.21]
         for(Money s : Money.values())
             System.out.println(s);
         //[5.22]
         Money test = Money.ONEDIME;
         test.discribe();
     }
 }

5.21-5.22