Thinking in Java 第五章习题（初始化）

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

class Test{
    String s;
}
public class Initialization {
    public static void main(String[] args) {
        Test t=new Test();
        System.out.println("s=: "+t.s);
    }
}

s=: null

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

class Test{
        String s1;
        String s2="haha";
        String s3;
        Test(){
            s3="hehe";
        }
    }
    public class Initialization {
        public static void main(String[] args) {
            Test t=new Test();
            System.out.println("s1= "+t.s1);
            System.out.println("s2= "+t.s2);
            System.out.println("s3= "+t.s3);
        }
    }

结果：初始化效果相同，成员变量定义初始化定义时确定构造初始化构造时确定

s1= null
s2= haha
s3= hehe

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

class Test{
    Test(){
        System.out.println("this is a Test");
    }
}
public class Initialization {

    public static void main(String[] args) {
        Test t=new Test();
    }
}

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

class Test{
    Test(){
        System.out.println("this is a Test");
    }
    Test(String s){
        System.out.println("Test: "+s);
    }
}
public class Initialization {
    public static void main(String[] args) {
        Test t=new Test("hello");
    }
}

结果：

Test: hello

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

class Dog{
    Dog(){
        System.out.println("wang wang wang");
    }
    Dog(String s){
        System.out.println(s);
    }
    Dog(int i){
        System.out.println("howling"+i);
    }
}
/**
 * Initialization
 */
public class Initialization {

    public static void main(String[] args) {
        Dog d=new Dog();
        Dog d2=new Dog("hello");
        Dog d3=new Dog(5);
    }
}

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

class Dog{
    Dog(){
        System.out.println("wang wang wang");
    }
    Dog(int i,String s){
        System.out.println(s+" "+i);
    }
}
/**
 * Initialization
 */
public class Initialization {

    public static void main(String[] args) {

        Dog d2=new Dog("hello",5);
    }
}

结果：String不能转成int，int不能转成String

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

class Test{
    public void method1(){
        System.out.println("this is method 1.");
    }
    public void method2(){
        this.method1();
    }
}
public class Initialization {
    public static void main(String[] args) {
        Test t=new Test();
        t.method2();
    }
}

class Test{
    Test(int i){
        System.out.println("this is "+i);
    }
    Test(int i,String s){
        this(i);
        System.out.println("this is "+s);
    }
}
public class Initialization {

    public static void main(String[] args) {
        Test t=new Test(1,"hello");
    }
}

结果

this is 1
this is hello

练习9：显示静态初始化 ，静态初始化在首次调用类时执行

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()");
    }
}
/**
 * Initialization
 */
public class Initialization {

    public static void main(String[] args) {
        System.out.println("inside main");
        Cups.cup1.f(99);
    }
}

输出结果如下：

inside main
Cup(1)
Cup(2)
f(99)

练习十：定义初始化和静态块初始化

class Something{
    String s;
    Something(String str){
        this.s=str;
        System.out.println("this is "+str);
    }
    public String toString(){
        return s;
    }
}
class Girl{
    static Something name=new Something("lili ");
    static Something favor;
    static{
        favor=new Something("sing dance");
    }
    public String toString(){
        return name+"loves "+favor;
    }
}
/**
 * chushihua
 */
public class chushihua {

     public static void main(String[] args) {
         Girl girl = new Girl();
        System.out.println(girl);
     }
}

结果：（toString，并不是你以为的驼峰and pengyouquan）

this is lili
this is sing dance
lili loves sing dance

练习十一：非静态示例初始化, 为了支持匿名内部类.

class Something{
    String s;
    Something(String str){
        this.s=str;
        System.out.println("this is "+str);
    }
    public String toString(){
        return s;
    }
}
class Girl{
    Something girl;
    Something boy;
    {
        girl=new Something("xuxiaoyi");
        boy=new Something("liwenhao");
    }
    public String toString(){
        return boy+" loves "+girl;
    }
}
/**
 * StaticIni
 */
public class StaticIni {
    public static void main(String[] args) {
        Girl girl=new Girl();
        System.out.println(girl);
    }
}

练习十二：String 数组

public class StringArrays {

    public static void main(String[] args) {
        int num=5;
        String[] sa=new String[num];
        for(int i=0;i<sa.length;i++){
            sa[i]="' "+i+" '";
        }
        System.out.println(Arrays.toString(sa));
    }
}

练习十三：String类型数组初始化

import java.util.Arrays;

class stringExample{
    String s;
    stringExample(String str){
        this.s=str;
        System.out.println("para = "+str);
    }
    public String toString(){
        return s;
    }
}
/**
 * StringArrays
 */
public class StringArrays {

    public static void main(String[] args) {
        int num=5;
        stringExample[] sea=new stringExample[num];
        System.out.println(Arrays.toString(sea));
        for(int i=0;i<sea.length;i++){
            sea[i]=new stringExample("' "+i+" '");
        }
        System.out.println(Arrays.toString(sea));
    }
}

结果

[null, null, null, null, null]
patal [0]
patal [1]
patal [2]
patal [3]
patal [4]
[[0], [1], [2], [3], [4]]

练习14： 可变参数

public class Variable {

    Variable(String... strs){
        for(String s:strs){
            System.out.print(s+" ");
        }
    }
    public static void main(String[] args) {
        new Variable("hello","world");
        System.out.println();
        new Variable(new String[]{"haha","hehe","heihei"});
    }
}

结果：

hello world
haha hehe heihei

练习15：使用enum

/**
 * TestEnum
 */
public class TestEnum {

    private enum Money{
        HUNDRED,
        FIFTY,
        TEN
    }
    public static void main(String[] args) {
        for(Money m:Money.values()){
            System.out.print(m+":"+m.ordinal()+" ");
            switch(m){
                case HUNDRED:
                    System.out.println(100);
                    break;
                case FIFTY:
                    System.out.println(50);
                    break;
                case TEN:
                    System.out.println(10);
                    break;
                default:
                    break;
            }
        }
    }
}