Java编程思想第四版 第五章个人练习
练习1：（1）创建一个类，它包含一个未初始化的String引用。验证该引用初始化成null。
package java_5;
public class StringPractice {
public static String A;
}
package java_5;
public class ConstructorPractice {
public static void main(String[] args) {
StringPractice a = new StringPractice();
System.out.print(a.A);
/**
* 控制台输出
null
*/
}
}
练习2：(2)创建一个类，它包含一个定义时就被初始化的String域，以及另一个通过构造器初始化的string域。这两种有什么区别。
package java_5;
public class StringPractice2 {
String a = "1";
String b = null;
public StringPractice2(String c) {
System.out.print("a = " + a + "\n");
System.out.print("b = " + b + "\n");
this.b = c;
System.out.print("b = " + b + "\n");
}
}
package java_5;
public class ConstructorPractice2 {
public static void main(String[] args){
StringPractice2 a = new StringPractice2("2");
/**
* 控制台输出
a = 1
b = null
b = 2
*/
}
}
可以从控制台输出结果看出，参数会优先于构造器执行。
练习3：创建一个默认构造器（无参构造器）的类，在构造器中打印一条信息。为这个类创建一个对象。
无参构造器
package java_5;
/**
* 练习3：创建一个默认构造器（无参构造器）的类，
* 在构造器中打印一条信息。为这个类创建一个对象。
* @author jy03133639
*/
public class NoParametricConstructor {
public NoParametricConstructor() {
System.out.print("无参构造器" + "\n");
}
}
调用
package java_5;
import org.springframework.validation.BindingResult;
public class DefaultConstructor {
public static void main(String[] args){
NoParametricConstructor b = new NoParametricConstructor();//默认构造
/**
* 控制台输出
无参构造器
*/
}
}
练习4：创建一个名为Dog的类，它具有重载bark()方法。此方法根据不同的基本数据类型进行重载，并根据调用版本打印出不同类型的狗吠（barking），咆哮（howling）等信息。编写main()来调用不同版本的方法。
package java_5;
public class Dog {
public void bark(int i){
print("barking");
}
public void bark(String i){
print("howling");
}
private void print(String s){
System.out.print(s + "\n");
}
}
package java_5;
import org.springframework.validation.BindingResult;
public class DefaultConstructor {
public static void main(String[] args){
Dog b = new Dog();//默认构造
b.bark(1);
b.bark("1");
/**
* 控制台输出
barking
howling
*/
}
}
练习6：修改前一个程序，让两个重载方法各自接收两个类型不同的参数，但是顺序相反。看是否正常工作。
package java_5;
public class Dog {
public void bark(int i,String s){
print("Int Frist");
}
public void bark(String s,int i){
print("String Frist");
}
private void print(String s){
System.out.print(s + "\n");
}
}
package java_5;
import org.springframework.validation.BindingResult;
public class DefaultConstructor {
public static void main(String[] args){
Dog b = new Dog();//默认构造
b.bark(1,"");
b.bark("1",1);
/**
* 控制台输出
Int Frist
String Frist
*/
}
}
结论可以正常使用。
练习7：创建一个没有走早起的类并在main（）中创建其对象，用以验证编译器是否真正自动加入了某人构造器。
package java_5;
public class Dog {
}
package java_5;
import org.springframework.validation.BindingResult;
public class DefaultConstructor {
public static void main(String[] args){
Dog b = new Dog();//默认构造
}
}
练习8：编写具有2个方法的类，在第一个方法调内调用第二个方法2次，第一次调用不适用this，第二次使用。
package java_5;
public class This {
public void method1(){
System.out.print("第一个方法 \n");
//三种调用方式
This main=new This();
main.method2();
method2();
this.method2();
}
public void method2(){
System.out.print("第二个方法 \n");
}
public static void main(String[] args){
This main=new This();
main.method1();
/**
* 控制台输出
第一个方法
第二个方法
第二个方法
第二个方法
*/
}
}
练习9：编写具有2个（重载）构造器的类，并在第一个构造器中通过this调用第二个构造器。
package java_5;
public class This {
This(){
//必须第一行
this("");
System.out.print("第一个构造器 \n");
}
This(String s){
System.out.print("第二个构造器 \n");
}
public static void main(String[] args){
This main=new This();
/**
* 控制台输出
第二个构造器
第一个构造器
*/
}
}
练习（10）：编写具有finalize（）方法的类，并在方法中打印消息。在main（）中为该类创建一个对象。试解释这个程序的行为。
package java_5;
/**
*
* @author jy03133639
*/
public class Finalize {
boolean flag = false;
void flageTrue(){
flag = true;
}
@Override
protected void finalize() throws Throwable {
super.finalize();
if (!flag){//如果flag为true则报错
System.err.println("flag is not true");
}
}
}
package java_5;
public class testJava5 {
public static void main(String[] args){
Finalize test = new Finalize();
test.flageTrue();
new Finalize();
//手动垃圾清理
System.gc();
}
}
没有任何内容输出。
练习（11）：修改前一个练习的程序，让你的finalize()总会被调用。
其实上一题的
System.gc();
就是这一题的答案。
执行 System.gc();这句话的时候会调用finalize。
练习（12）：编写名为Tank的类，此类的状态可以是“满的”或“空的”。其终结条件是：对象被清理时必须处于空状态。请编写finalize()以检验终结条件是否成立。在main()中测试Tank可能发生的几种使用方式。
package java_5;
public class Tank {
static String Str_Empty = "空的";
String flag = "满的";
void flagEmpty(){
flag = Str_Empty;
}
@Override
protected void finalize() throws Throwable {
if (Str_Empty.equals(flag)){//如果flag为true则报错
System.err.println("flag内容为:'"+flag+"'执行finalize");
super.finalize();
}else{
System.err.println("flag内容为:'"+flag+"'不执行finalize");
}
}
}
package java_5;
public class testJava5 {
public static void main(String[] args){
Tank test1 = new Tank();
test1.flagEmpty();
Tank test2 = new Tank();
new Tank();
//手动垃圾清理
//但是没有进finalize
System.gc();
}
}
练习13 验证前面段落中的语句。
package java_5;
import util.Print;
public class Cup {
Print p = new Print();
public Cup(int i) {
p.printl("Cup(" + i + ")");
}
void f(int marker){
p.printl("f(" + marker + ")");
}
}
package java_5;
import util.Print;
public class Cups {
Print p = new Print();
static Cup cup1;
static Cup cup2;
static {
cup1 = new Cup(1);
cup2 = new Cup(2);
}
public Cups() {
p.printl("Cups()");
}
}
package java_5;
import util.Print;
public class ExplicitStatic {
static Print p = new Print();
public static void main(String[] args){
p.printl("Inside Main()");
Cups.cup1.f(99);
/**
* 控制台输出结果
Inside Main()
Cup(1)
Cup(2)
f(99)
*/
}
}
练习14 编写一个类，拥有两个静态字符串域，其中一个在定义处初期化，另一个在静态块中初期化。现在加瑞哥静态方法用意打印出两个字段的值。请证明他们都会在被使用之前完成初始化动作。
package java_5;
import util.Print;
/**
* 练习14 编写一个类，拥有两个静态字符串域，
* 其中一个在定义处初期化，
* 另一个在静态块中初期化。
* 现在加瑞哥静态方法用意打印出两个字段的值。
* 请证明他们都会在被使用之前完成初始化动作。
* @author wdh
*/
public class StaticStringField {
static Print p = new Print();
static String a = "a初始化";
static String b;
static {
b="b初始化";
}
static void c(){
p.printl(a);
p.printl(b);
}
}
package java_5;
public class StaticStringFieldVerification {
public static void main(String[] args){
StaticStringField.c();
/**
* 控制台输出结果
a初始化
b初始化
*/
}
}
练习16：创建一个String对象数据，并为每一个元素复制一个String，用for循环来打印该数组。
package java_5;
import util.Print;
import java.awt.print.PrinterGraphics;
/**
* 练习16:创建一个String对象数据，
* 并为每一个元素复制一个String，
* 用for循环来打印该数组。
* @author wdh
*/
public class ArrayString {
static Print p = new Print();
public static void main(String[] args){
String[] a ={"a","b","c"};
int i = 0;
for (String b : a){
p.printl("a[" + i +"] : " + b);
i++;
}
/**
* 控制台输出结果
a[0] : a
a[1] : b
a[2] : c
*/
}
}
练习17：创建一个类，他有一个接受一个String参数的构造器。在构造阶段，打印该参数。穿件一个该类的引用数组，但是不实际创建对象赋值给该数组。当运行程序时，请注意来自对该构造器的调用中的初始化信息是否打印出来。
package java_5;
import util.Print;
public class StringConstructor {
static Print p = new Print();
public StringConstructor(String a) {
p.printl(a);
}
}
package java_5;
/**
* 练习17：创建一个类，
* 他有一个接受一个String参数的构造器。
* 在构造阶段，打印该参数。
* 穿件一个该类的引用数组，
* 但是不实际创建对象赋值给该数组。
* 当运行程序时，
* 请注意来自对该构造器的调用中的初始化信息是否打印出来。
* @author wdh
*/
public class StringConstructorVerification {
public static void main(String[] args){
StringConstructor[] a ;
/**
* 构造器调用中的初始化信息表并没有打印出来
* 没有初期化并没有启用构造器。
*/
}
}
练习18 通过练习17创建对象复制引用数组，从而完成前一个练习。
package java_5;
/**
* 练习18:通过练习17创建对象复制引用数组，
* 从而完成前一个练习。
* @author wdh
*/
public class StringConstructorVerification {
public static void main(String[] args){
StringConstructor[] a = new StringConstructor[5];
for (int i = 0; i < a.length; i ++){
a[i] = new StringConstructor("" + i);
}
/**
* 控制台输出结果
0
1
2
3
4
*/
}
}
练习19 练习19 写一个类，他接受一个可变参数 String数组。 验证你可以向他传递一个用逗号分隔的String 列表， 或者String[]。
package java_5;
import util.Print;
/**
* 练习19 写一个类，他接受一个可变参数 String数组。
* 验证你可以向他传递一个用逗号分隔的String 列表，
* 或者String[]。
* @author wdh
*/
public class StringVariableParameter {
static Print p = new Print();
public static void StringVariable(String ... a){
for (String b:a){
p.printl(b);
}
}
public static void main(String[] args){
StringVariable("a","b","c");
String[] a = {"a[0]","a[1]","a[2]"};
StringVariable(a);
/**
* 控制台输出内容
a
b
c
a[0]
a[1]
a[2]
*/
}
}
练习20 创建一个使用可变参数列表而不是普通main（）语法的main().打印所产生的args数组的所有元素，并用不同的数量行参数来测试他。
package java_5;
import util.Print;
/**
*练习20 创建一个使用可变参数列表而不是普通main（）语法的main().
* 打印所产生的args数组的所有元素，
* 并用不同的数量行参数来测试他。
* @author wdh
*/
public class MainStringVariable{
static Print p = new Print();
public static void main(String...args){
for (String str : args) {
p.printl(str);
}
}
/**
* 控制台输出结果
a
b
c
*/
}
main方法输入参数的方法如下：
空格是分隔数组的方式
