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

Posted llguanli

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java编程思想第四版 *第五章 个人练习相关的知识,希望对你有一定的参考价值。


技术分享

练习3:(1)创建一个带默认构造器(即无參构造器)的类。在构造器中打印一条消息。为这个类创建一个对象。P116

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
	 */
}



练习7:(1)创建一个没有构造器的类。并在main()中创建其对象,用以验证编译器是否真的自己主动增加了默认构造器。

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();
	}
	/**
	 * 执行结果
		----空的,没问题---------
		----满的,有问题---------
	 */
}

练习13:(1)验证前面段落中的语句


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();
	}
}

练习21:创建一个enum,它包括纸币中最小面值的6种类型。通过values()循环并打印每个值及其ordinal() 

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

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

练习22:(2)在前面的样例中,为enum写一个switch语句,对于每个case,输出该特定货币的描写叙述。


public class ExpliciStatic{	
	public static void main (String args[]){  
		for(Money m:Money.values()){
			System.out.println(m+"\t "+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;
		}
	}
}





























以上是关于Java编程思想第四版 *第五章 个人练习的主要内容,如果未能解决你的问题,请参考以下文章

Java编程思想第四版第二章练习题答案

java编程思想-第五章-某些练习题

java编程思想第四版第9章

spring实战第四版第五章pom.xml

一起读《Java编程思想》(第四版)

一起读《Java编程思想》(第四版)