【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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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();
    }
}