Head Pic: 【洛天依】"521" / Illustration by "TID" [pixiv]

练习1

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

package world.pixiv.thinkinginjava.exercise.chapter5;

import static world.pixiv.thinkinginjava.util.Printer.*;

public class Exercise01 {
    static String s;
    public static void main(String[] args) {
        println(s);
    }
}
/* Output:
 * null
 */

练习2

创建一个类,它包含一个在定义时就被初始化的String域,以及另一个通过构造器初始化的String域。

package world.pixiv.thinkinginjava.exercise.chapter5;

public class Exercise02 {
    @SuppressWarnings("unused")
    public static void main(String[] args) {
        String s1 = "";
        String s2 = new String("");
    }
}

练习3

创建一个带无参构造器的类,在构造器中打印一条消息。为这个类创建一个对象。

package world.pixiv.thinkinginjava.exercise.chapter5;

import static world.pixiv.thinkinginjava.util.Printer.*;

public class Exercise03 {
    public Exercise03(){
        println("https://4o5.xyz");
    }
    @SuppressWarnings("unused")
    public static void main(String[] args) {
        Exercise03 e = new Exercise03();
    }
}
/* Output
 * https://4o5.xyz
 */

练习4

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

package world.pixiv.thinkinginjava.exercise.chapter5;

import static world.pixiv.thinkinginjava.util.Printer.*;

public class Exercise04 {
    public Exercise04() {
        println("https://4o5.xyz");
    }
    public Exercise04(String s) {
        println("https://4o5.xyz");
        println(s);
    }
    @SuppressWarnings("unused")
    public static void main(String[] args) {
        Exercise04 e = new Exercise04("233");
    }
}
/* Output:
 * https://4o5.xyz
 * 233
 */

练习5

创建一个名为Dog的类,它具有重载的bark()方法。此方法应根据不同的基本数据类型进行重载,并根据被调用的版本,打印出不同类型的狗吠(barking)和咆哮(howling)等信息。

package world.pixiv.thinkinginjava.exercise.chapter5;

import static world.pixiv.thinkinginjava.util.Printer.*;

class Dog{
    public void bark(int a) {
        println(a + " barking");
    }
    public void bark(boolean b) {
        println(b + " barking");
    }
}

public class Exercise05 {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.bark(false);
        d.bark(233);
    }
}
/* Output:
 * false barking
 * 233 barking
 */

练习6

修改前一个程序,让两个重载方法各自接受两个类型的不同参数,但二者顺序相反。

package world.pixiv.thinkinginjava.exercise.chapter5;

import static world.pixiv.thinkinginjava.util.Printer.*;

class Dog1{
    public void bark(int a,boolean b) {
        println(a + " barking " + b);
    }
    public void bark(boolean b,int a) {
        println(b + " barking " + a);
    }
}

public class Exercise06 {
    public static void main(String[] args) {
        Dog1 d = new Dog1();
        d.bark(false,233);
        d.bark(233,false);
    }
}
/* Output:
 * false barking 233
 * 233 barking false
 */

练习7

创建一个没有构造器的类,并在main()中创建其对象以验证编译器是否真的加入无参构造器。

package world.pixiv.thinkinginjava.exercise.chapter5;

public class Exercise07 {
    @SuppressWarnings("unused")
    public static void main(String[] args) {
        Exercise07 e = new Exercise07();
    }
}

练习8

编写具有两个方法的类,在第一个方法内调用第二个方法两次,第一次用this,第二次不用。

package world.pixiv.thinkinginjava.exercise.chapter5;

public class Exercise08 {
    public void method1() {}
    public void method2() {
        method1();
        this.method1();
    }
}

练习9

编写具有两个构造器的类,并在第一个构造器中通过this调用第二个。

package world.pixiv.thinkinginjava.exercise.chapter5;

public class Exercise09 {
    public Exercise09() {}
    public Exercise09(String s) {
        this();
    }
}

练习10

编写具有finalize()方法的类,并在方法中打印消息。

package world.pixiv.thinkinginjava.exercise.chapter5;

import static world.pixiv.thinkinginjava.util.Printer.*;

class Test{
    protected void finalize() {
        println("https://4o5.xyz");
    }
}

public class Exercise10 {
    @SuppressWarnings("unused")
    public static void main(String[] args) {
        Test t = new Test();
        System.gc();
    }
}

练习11

修改前一个练习的程序,让你的finalize()总会被调用。

package world.pixiv.thinkinginjava.exercise.chapter5;

import static world.pixiv.thinkinginjava.util.Printer.*;

class Test2{
    protected void finalize() {
        println("https://4o5.xyz");
    }
}

public class Exercise11 {
    public static void main(String[] args) {
        Test2 t = new Test2();
        t.finalize();
        System.gc();
    }
}
/* Output:
 * https://4o5.xyz
 */

练习12

编写名为Tank的类,此类的状态可以是“满的”或“空的”。其终结条件是:对象被清理时必须处于空状态。请编写finalize()以检验终结条件是否成立。

package world.pixiv.thinkinginjava.exercise.chapter5;

import static world.pixiv.thinkinginjava.util.Printer.*;

class Tank{
    boolean status = true;
    void change() {
        status = !status;
    }
    protected void finalize() {
        if(status) {
            println("Error: not empty");
        }
    }
}

public class Exercise12 {
    public static void main(String[] args) {
        Tank t = new Tank();
        t.change();
        new Tank();
        t.change();
        t.finalize();
        System.gc();
    }
}
/* Output:
 * Error: not empty
 * Error: not empty
 */

练习13

验证前面段落的语句。

package world.pixiv.thinkinginjava.exercise.chapter5;

import static world.pixiv.thinkinginjava.util.Printer.*;

class Cup{
    Cup(int marker){
        println("Cup(" + marker + ")");
    }
    void f(int marker) {
        println("f(" + marker + ")");
    }
}

class Cups{
    static Cup cup1;
    static Cup cup2;
    static {
        cup1 = new Cup(1);
        cup2 = new Cup(2);
    }
    Cups(){
        println("Cups()");
    }
}

public class Exercise13 {
    public static void main(String[] args) {
        println("Inside main()");
        Cups.cup1.f(99);
    }
}
/* Output:
 * Inside main()
 * Cup(1)
 * Cup(2)
 * f(99)
 */

练习14

编写一个类,拥有两个静态字符串域,其中一个在定于处初始化,另一个在静态块中初始化。现在加入一个静态方法用以打印出两个字段值。

package world.pixiv.thinkinginjava.exercise.chapter5;

import static world.pixiv.thinkinginjava.util.Printer.*;

class StringTest{
    static String s1 = "4o5.xyz";
    static String s2;
    
    static {
        s2 = "pixiv.world";
    }
    
    public static void print() {
        println(s1);
        println(s2);
    }
}

public class Exercise14 {
    public static void main(String[] args) {
        StringTest.print();
    }
}
/* Output:
 * 4o5.xyz
 * pixiv.world
 */

练习15

编写一个含有字符串域的类,并采用实例初始化的方式进行初始化。

package world.pixiv.thinkinginjava.exercise.chapter5;

import static world.pixiv.thinkinginjava.util.Printer.*;

public class Exercise15 {
    {
        String s = "4o5.xyz";
    }
}

练习16

创建一个String[],并为每个元素都赋一个String,用for循环打印之。

package world.pixiv.thinkinginjava.exercise.chapter5;

import static world.pixiv.thinkinginjava.util.Printer.*;

public class Exercise16 {
    public static void main(String[] args) {
        String[] s = new String[5];
        
        for(int i = 0;i < 5;i++) {
            s[i] = "4o5.xyz";
        }
        
        for(String delta : s) {
            println(delta);
        }
    }
}
/* Output:
 * 4o5.xyz
 * 4o5.xyz
 * 4o5.xyz
 * 4o5.xyz
 * 4o5.xyz
 */

练习17

创建一个类,它有一个接受一个String参数的构造器。在构造阶段打印该参数。创建一个该类的对象引用数组,但不赋值内容。

package world.pixiv.thinkinginjava.exercise.chapter5;

import static world.pixiv.thinkinginjava.util.Printer.*;

class T{
    public T(String s) {
        println(s);
    }
}

public class Exercise17 {
    public static void main(String[] args) {
        T[] t = new T[5];
    }
}

练习18

通过创建对象赋值给引用数组,从而完成前一个练习。

package world.pixiv.thinkinginjava.exercise.chapter5;

import static world.pixiv.thinkinginjava.util.Printer.*;

class T2{
    public T2(String s) {
        println(s);
    }
}

public class Exercise18 {
    public static void main(String[] args) {
        T2[] t = new T2[5];
        for(int i = 0;i < 5;i++) {
            t[i] = new T2("4o5.xyz" + i);
        }
    }
}

练习19

写一个类,它接受一个可变参数的String数组。

package world.pixiv.thinkinginjava.exercise.chapter5;

public class Exercise19 {
    public static void main(String... args) {
        
    }
}

练习20

创建一个使用可变参数列表而不是普通的main()语法的main()。打印args[]。

package world.pixiv.thinkinginjava.exercise.chapter5;

import static world.pixiv.thinkinginjava.util.Printer.*;

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

练习21

创建一个enum,它包含纸币最小面值的6种类型,通过values()循环打印每个值极其ordinal()。

package world.pixiv.thinkinginjava.exercise.chapter5;

import static world.pixiv.thinkinginjava.util.Printer.*;

enum Money{
    ONE,FIVE,TEN,TWENTY,FIFTY,HUNDRED;
}

public class Exercise21 {
    public static void main(String[] args) {
        for(Money m : Money.values()) {
            println(m + ", ordinal " + m.ordinal());
        }
    }
}
/* Output:
 * ONE, ordinal 0
 * FIVE, ordinal 1
 * TEN, ordinal 2
 * TWENTY, ordinal 3
 * FIFTY, ordinal 4
 * HUNDRED, ordinal 5
 */

练习22

为前例的enum写一个switch,对于每个case,输出该特定货币描述。

package world.pixiv.thinkinginjava.exercise.chapter5;

import static world.pixiv.thinkinginjava.util.Printer.*;

class E{
    Money money;
    E(Money money){
        this.money = money;
    }
    public void describe() {
        switch(money) {
        case ONE : println("1");break;
        case FIVE : println("5");break;
        case TEN : println("10");break;
        case TWENTY : println("20");break;
        case FIFTY : println("50");break;
        case HUNDRED : println("100");break;
        }
    }
}

public class Exercise22 {
    public static void main(String[] args) {
        E
            e1 = new E(Money.ONE),
            e2 = new E(Money.FIFTY),
            e3 = new E(Money.HUNDRED);
        e1.describe();
        e2.describe();
        e3.describe();
    }
}
最后修改:2019 年 05 月 25 日 11 : 27 PM