Thinking in Java 习题 - 第五章
Sep 21, 2013
练习1 #
/*创建一个类，它包含一个未初始化的String引用。验证该引用被Java初始化成了null。*/
class Main {
static String s;
public static void main (String args[]){
System.out.println("s="+s);
}
}/*Output:
s=null
*/
练习2 #
/*创建一个类，它包含一个在定义时就被初始化了的String域，以及另一个通过构造器初始化的String域，这两种方式有何差异？*/
class Main {
String s1 = "hello";
String s2 ;
public Main(String s){
s2=s;
}
public static void main (String args[]){
Main s = new Main("world");
System.out.println(s.s1);
System.out.println(s.s2);
}
}/*Output:
hello
world
*/
练习3 #
/*创建一个带默认构造器（即无参构造器）的类，在构造器中打印一条消息。为这个类创建一个对象。*/
class Main {
Main(){
System.out.println("无参构造器");
}
public static void main (String args[]){
new Main();
}
}/*Output:
无参构造器
*/
练习4 #
/*为前一个练习中的类添加一个重载构造器，令其接受一个字符参数，并在构造器中把你自己的信息和接受的参数一起打印出来。*/
class Main {
Main (String s){
System.out.println(s);
System.out.println("I'm your fans");
}
public static void main (String args[]){
new Main("Hello Lady");
}
}/*Output:
Hello Lady
I'm your fans
*/
练习5 #
/*创建一个名为Dog的类，它具有重载的bark（）方法。此方法应根据不同的基本数据类型进行重载，并根据被调用的版本，
打印出不同类型的狗吠（barking）、咆哮（howling）等信息，编写main（）来调用所有不同版本的方法。*/
class Dog {
void bark(){
System.out.println("barking");
}
void bark(int i){
System.out.println("howling");
}
void bark(double i){
System.out.println("wangwang");
}
}
public class Main {
public static void main (String args[]){
Dog dog = new Dog();
dog.bark();
dog.bark(1);
dog.bark(1.0);
}
}/*Output:
barking
howling
wangwang
*/
练习6 #
/*修改前一个练习的程序，让两个重载方法各自接受两个类型的不同的参数，但二者顺序相反。验证其是否工作。*/
class Dog {
public void bark(int i){
System.out.println("barking");
}
public void bark(double i){
System.out.println("howling");
}
}
class Main {
public static void main (String args[]){
Dog dog = new Dog();
dog.bark(1.0);
dog.bark(1);
}
}/*Output:
howling
barking
*/
练习7 #
/*创建一个没有构造器的类，并在main（）中创建其对象，用以验证编译器是否真的自动加入了默认构造器。*/
class Main {
public static void main(String args[]){
Main main = new Main();
}
}
练习8 #
/*编写具有两个方法的类，在第一个方法内调用第二个方法两次：第一次调用时不使用this关键字，第二次调用时使用this关键字--
* 这里只是为了验证它是起作用的，你不应该在实践中使用这种方法。*/
class Main {
void test1(){
System.out.println("调用了test1（）方法");
}
void test2(){
System.out.print("执行test1（）方法：");
test1();
System.out.print("执行test2（）方法：");
this.test1();
}
public static void main (String args[]){
Main main = new Main();
main.test2();
}
}/*Output:
执行test1（）方法：调用了test1（）方法
执行test2（）方法：调用了test1（）方法
*/
练习9 #
/*编写两个（重载）构造器的类，并在第一个构造器中,通过this调用第二个构造器。*/
class Main {
Main(String s){
System.out.println("s="+s);
}
Main(int i){
this("i="+i);
}
public static void main (String args[]){
new Main("hello world");
new Main(521);
}
}/*Output:
s=hello world
s=i=521
*/
练习10 #
/*编写具有finalize（）方法的类，并在方法中打印消息，在main（）中为该类创建一个对象，试解释这个程序的行为。*/
class Main {
protected void finalize(){
System.out.println("finalize()called");
}
public static void main (String args[]){
new Main();
}
}
练习11 #
//修改前一个练习的程序,让你的finalize（）总会被调用。
class Main {
protected void finalize(){
System.out.println("finalize()called");
}
public static void main (String args[]){
new Main();
System.gc();
System.runFinalization();
}
}/*Output:
finalize()called
*/
练习12 #
/*编写名为Tank的类，此类的状态可以是“满的”或“空的”。其终结条件是：对象被清理时必须处于空状态。
* 请编写finalize（）以检验终结条件是否成立，在main（）中测试Tank可能发生的几种使用方式。
*/
练习13 #
//验证前面段落中的语句
class Cup{
Cup(int marker){
System.out.println("Cup()");
}
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()");
}
}
public class Main {
public static void main (String args[]){
System.out.println("main()");
Cups.cup1.f(99);
}
static Cups cups1 = new Cups();
static Cups cups2 = new Cups();
}/*Output:
Cup()
Cup()
Cups()
Cups()
main()
f(99)
*/
练习14 #
//编写一个类，拥有两个静态字符串域，其中一个在定义处初始化，另一个在静态块中初始化。
//现在，加入一个静态方法用以打印出两个字段值。请证明它们都会在被使用之前完成初始化动作。
class Main {
static String s1 = "dog";
static String s2;
static {
s2 = "kitty";
}
public static void main (String args[]){
System.out.println("s1="+s1);
System.out.println("s2="+s2);
}
}/*Output:
s1=dog
s2=kitty
*/
练习15 #
//编写一个含有字符串域的类，并采用实例初始化方式进行初始化。
class Main {
String s ;
{
s = "young for you";
}
public Main(){
System.out.println("s="+s);
}
public static void main (String args[]){
new Main();
}
}/*Output:
s=young for you
*/
练习16 #
/*创建一个String对象数据，并为每一个元素都赋值一个String。用for循环来打印该数组。*/
class Main {
public static void main(String args[]){
String[] a = new String[4];
a[0]="these";
a[1]="are";
a[2]="some";
a[3]="String";
for (int i=0;i<a.length;i++){
System.out.println(a[i]);
}
}
}/*Output:
these
are
some
String
*/
练习17 #
//创建一个类，他有一个接受一个String参数的构造器。在构造阶段，打印该参数。创建一个该类的对象引用数组，
//但是不实际去创建对象赋值给该数组。当运行程序时，请注意来自对该构造器的调用中的初始化消息是否打印了出来。
class Test {
Test(String s){
System.out.println("s="+s);
}
}
class Main {
public static void main (String args[]){
Test[] array1 = new Test[5];
}
}//不知这样是否符合题意。。
练习18 #
//通过创建对象赋值给引用数组，从而完成前一个练习。
class Test{
Test(String s){
System.out.println("s="+s);
}
}
class Main {
public static void main (String args[]){
Test[] array1 = new Test[5];
for (int i=0;i<array1.length;i++){
array1[i]=new Test(Integer.toString(i));
}
}
}/*Output:
s=0
s=1
s=2
s=3
s=4
*/
练习19 #
//写一个类，他接受一个可变参数的String数组，验证你可以向该方法传递一个用逗号分隔的String列表，或是一个String[]。
class Test{
void printString(String... args){
for (String s :args)
System.out.println(s+" ");
}
}
class Main {
public static void main (String args[]){
Test test = new Test();
test.printString("nice","to","meet","you");
}
}/*Output:
nice
to
meet
you
*/
练习20 #
//创建一个使用可变参数列表而不是普通的main()语法的main()。打印所产生的args数组的所有元素，并用各种不同数量的命令行参数来测试它。
class Main{
static void printString(String... args){
for (String s :args)
System.out.print(s+" ");
System.out.println();
}
public static void main (String... args){
printString("nice","to","meet","you");
printString(
new String[] {"there","are","some","strings"}
);
}
}/*Output:
nice to meet you
there are some strings
*/
练习21 #
//创建一个enum，它包含纸币中最小面值的6种类型。通过values()循环并打印每一个值及其ordinal（）
enum Money{
One,Five,Ten,Hun,Tho
}
class Main {
public static void main (String args[]){
for (Money s:Money.values())
System.out.println(s+",ordinal:"+s.ordinal());
}
}/*Output:
One,ordinal:0
Five,ordinal:1
Ten,ordinal:2
Hun,ordinal:3
Tho,ordinal:4
*/
练习22 #
//在前面的例子中，为enum写一个switch语句，对于每一个case，输出该特定货币的描述。
enum Money{
One,Five,Ten,Twe,Fif
}
class Main {
Money money;
public void describe(){
switch(money){
case One:System.out.println("1");break;
case Five:System.out.println("5");break;
case Ten:System.out.println("10");break;
case Twe:System.out.println("20");break;
case Fif:System.out.println("50");break;
default:
break;
}
}
public static void main (String args[]){
for (Money s : Money.values())
System.out.println(s+",ordinal:"+s.ordinal());
}
}/*Output:
One,ordinal:0
Five,ordinal:1
Ten,ordinal:2
Twe,ordinal:3
Fif,ordinal:4
*/
第5章完