java编程思想第四版*第五章个人练习

public class Test{
	
	public Test(){
		System.out.println("Hello Word");
	}
	
	public static void main(String[] args) {
		new Test();
	}
	/**
	 * 执行结果
	 Hello Word
	 */
}

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

public class Test{
	
	public Test(String msg){
		System.out.println("Hello "+msg);
	}
	
	public static void main(String[] args) {
		new Test("China");
	}
	/**
	 * 执行结果
	 Hello China
	 */
}

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

public class Dog{
	
	public void bark(){
		System.out.println("barking");
	}
	
	public void bark(String name){
		System.out.println(name + " howing");
	}
	
	public static void main(String[] args) {
		Dog dog=new Dog();
		dog.bark();
		dog.bark("Lily");
	}
	/**
	 * 执行结果
	barking
	Lily howing
	 */
}

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

public class Dog{
	
	public void bark(int i){
		System.out.println(i+"barking");
	}
	
	public void bark(String name){
		System.out.println(name + " howing");
	}
	
	public static void main(String[] args) {
		Dog dog=new Dog();
		dog.bark("Lily");
		dog.bark(88);
	}
	/**
	 * 执行结果
	Lily howing
	88barking
	 */
}

public class Dog{
	
	public void bark(int i){
		System.out.println(i+"barking");
	}
	
	public void bark(String name){
		System.out.println(name + " howing");
	}
	
	public static void main(String[] args) {
		Dog dog=new Dog();
		dog.bark("Lily");
		dog.bark(88);
	}
	/**
	 * 执行结果
	Lily howing
	88barking
	 */
}

练习8：（1）编写具有两个方法的类，在第一个方法内调用第二个方法两次：第一次调用时不使用thiskeyword。第二次调用时使用thiskeyword-- * 这里仅仅是为了验证它是起作用的，你不应该在实践中使用这样的方法。

public class Test{	
	
	public static void main(String[] args) {
		Apple apple=new Apple();
		apple.getApple();
	}
	/**
	 * 执行结果
		未使用this调用：已创建好……
		使用this调用：已创建好……
	 */
}
class Apple{
	
	public void getApple(){
		System.out.print("未使用this调用：");
		createApple();
		System.out.print("使用this调用：");
		this.createApple();
	}
	
	public void createApple(){
		System.out.println("已创建好……");
	}
}

练习9：（1）编写两个（重载）构造器的类，并在第一个构造器中,通过this调用第二个构造器。

package mil.oms.main.test;

public class Test{	
	
	public static void main(String[] args) {
		new Apple();
	}
	/**
	 * 执行结果
		颜色：red
	 */
}
class Apple{
	public Apple(){
		this("red");
	}
	
	public Apple(String color){
		System.out.println("颜色："+color);
	}
}

练习10：（2）编写具有finalize（）方法的类，并在方法中打印消息。在main（）中为该类创建一个对象，试解释这个程序的行为。

public class Test{	
	
	public static void main(String[] args) {
		Apple apple=new Apple();
		apple=null;
		System.gc();
	}
	/**
	 * 执行结果
		<span style="font-family: Arial, Helvetica, sans-serif;">----finalize---------</span>
	 */
}
class Apple{	
	protected void finalize(){
		System.out.println("----finalize---------");
	}
}

练习11：（4）改动前一个练习的程序,让你的finalize（）总会被调用。

public class Test{	
	
	public static void main(String[] args) {
		new Apple();
		System.gc();
		System.runFinalization();
	}
	/**
	 * 执行结果
		颜色：red
	 */
}
class Apple{	
	protected void finalize(){
		System.out.println("----finalize---------");
	}
}

练习12：（4）编写名为Tank的类。此类的状态能够是“满的”或“空的”。

其终结条件是：对象被清理时必须处于空状态。  * 请编写finalize（）以检验终结条件是否成立。在main（）中測试Tank可能发生的几种使用方式

public class Tank{	
	
	public boolean state=false;
	
	public void changeState(boolean state){
		this.state=state;
	}
	
	protected void finalize() throws Throwable{
if(state){
System.out.println("----满的，有问题---------");
throw new Throwable ("状态不为空!");
}else{
System.out.println("----空的，没问题---------");
super.finalize();
}
}
	
	public static void main(String[] args) {
		new Tank();
		System.gc();
		System.runFinalization();
		
		new Tank().changeState(true);
		System.gc();
		System.runFinalization();
	}
	/**
	 * 执行结果
		----空的，没问题---------
		----满的，有问题---------
	 */
}

public class ExpliciStatic{	
	
	public static void main(String[] args) {
		System.out.println("Inside main()");
		Cups.cup1.f1(1);
	}
	static Cups cups1=new Cups();
	static Cups cups2=new Cups();
	/**
	 * 执行结果
		Bowl(1)
		Bowl(2)
		Cups()
		Cups()
		Inside main()
		f1(1)
	 */
}

class Cup{
	Cup(int mark){
		System.out.println("Bowl("+mark+")");
	}
	
	void f1(int mark){
		System.out.println("f1("+mark+")");
	}
}

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

练习14：（1）编写一个类。拥有两个静态字符串域。当中一个在定义处初始化，还有一个在静态块中初始化。如今，增加一个静态方法用以打印出两个字段值。

请证明它们都会在被使用之前完毕初始化动作。

public class ExpliciStatic{	
	
	public static void main(String[] args) {
		Cup.print();
	}
	/**
	 * 执行结果
		str1:str1
		str2:str2
	 */
}

class Cup{
	static String str1="str1";
	static String str2;
	static{
		str2="str2";
	}
	
	static void print(){
		System.out.println("str1:"+str1);
		System.out.println("str2:"+str2);
	}
}

练习15：（1）编写一个含有字符串域的类，并採用实例初始化方式进行初始化。

 

public class ExpliciStatic{	

	public static void main(String[] args) {
		System.out.println("start()");
		new Cup();
		System.out.println("end()");
	}
	/**
	 * 执行结果
		start()
		字段串域初始化完毕
		Cup()
		end()
	 */
}

class Cup{
	String str;
	{
		str="Hello";
		System.out.println("字段串域初始化完毕");
	}
	Cup(){
		System.out.println("Cup()");
	}
}

练习16创建一个String对象数据，并为每个元素都赋值一个String。用for循环来打印该数组。

public class ExpliciStatic{	

	public static void main(String[] args) {
		String[] strs={"H","e","l","l","o"};
		for(String str:strs){
			System.out.print(str);
		}
	}
	/**
	 * 执行结果
		Hello
	 */
}

练习17：创建一个类，他有一个接受一个String參数的构造器。

在构造阶段，打印该參数。创建一个该类的对象引用数组。可是不实际去创建对象赋值给该数组。

当执行程序时。请注意来自对该构造器的调用中的初始化消息是否打印了出

public class ExpliciStatic{	

	public static void main(String[] args) {
		Random random=new Random(47);
		Cup[] cups=new Cup[random.nextInt(10)];
	}
	/**
	 * 执行结果
		
	 */
}

class Cup{
	
	Cup(String str){
		System.out.println("Cup("+str+")");
	}
	
}

练习18：通过创建对象赋值给引用数组，从而完毕前一个练习。  

public class ExpliciStatic{	

	public static void main(String[] args) {
		Random random=new Random(47);
		Cup[] cups=new Cup[random.nextInt(10)];
		for(int i=0,j=cups.length;i<j;i++){
			cups[i]=new Cup("cup"+i);
		}
	}
	/**
	 * 执行结果
		Cup(cup0)
		Cup(cup1)
		Cup(cup2)
		Cup(cup3)
		Cup(cup4)
		Cup(cup5)
		Cup(cup6)
		Cup(cup7)
	 */
}

class Cup{
	
	Cup(String str){
		System.out.println("Cup("+str+")");
	}
}

练习19：（1）写一个类，他接受一个可变參数的String数组，验证你能够向该方法传递一个用逗号分隔的String列表。或是一个String[]。

<pre name="code" class="html">public class ExpliciStatic{	

	public static void main(String[] args) {
		String str="Hello",strs[]={str};
		System.out.print("传 入 字 符 串 ：");
		new Cup(str);
		System.out.print("传入字符串数组：");
		new Cup(strs);
		System.out.print("传入两个字符串：");
		new Cup(str,str);
	}
	/**
	 * 执行结果：
		传 入 字 符 串 ：可变。。。參数
		传入字符串数组：可变。。。
參数
		传入两个字符串：可变。。
。參数
	 */
}

class Cup{	
	Cup(String ... str){
		System.out.println("可变。。。參数");
	}
}

练习20：（1）创建一个使用可变參数列表而不是普通的main()语法的main()。

打印所产生的args数组的全部元素，并用各种不同数量的命令行參数来測试它。

public class ExpliciStatic{	
	public static void main (String... args){  
        printStr("H","e","l","l","o");  
        printStr(  
            new String[] {"H","e","l","l","o",}/** 最后的逗号可有可无 **/  
        );  
    }  
	/**
	 * 执行结果：
		Hello
		Hello
	 */

	public static void printStr(String ... strs){
		for(String str:strs){
			System.out.print(str);
		}
		System.out.println();
	}
}

public class ExpliciStatic{	
	public static void main (String args[]){  
		for(Money m:Money.values()){
			System.out.println(m+"	 "+m.ordinal());
		}
    }  
	/**
	 * 执行结果：
		one	 0
		two	 1
		five 2
		ten	 3
		hun	 4
		tho	 5
	 */
}

enum Money{
	one,two,five,ten,hun,tho
}

public class ExpliciStatic{	
	public static void main (String args[]){  
		for(Money m:Money.values()){
			System.out.println(m+"	 "+m.ordinal());
			Money.describe(m);
		}
    }  
	/**
	 * 执行结果：
		one	 0
		1分钱
		two	 1
		2分钱
		five	 2
		5分钱
		ten	 3
		10块钱
		hun	 4
		20块钱
		tho	 5
		50块钱
	 */
}

enum Money{
	one,two,five,ten,hun,tho;
	
	static void describe(Money m){
		switch(m){
		case one:
			System.out.println("1分钱");break;
		case two:
			System.out.println("2分钱");break;
		case five:
			System.out.println("5分钱");break;
		case ten:
			System.out.println("10块钱");break;
		case hun:
			System.out.println("20块钱");break;
		case tho:
			System.out.println("50块钱");break;
			default:break;
		}
	}
}