JAVA编程思想——第五章.初始化与清理
博客专区 > leooooo 的博客 > 博客详情
JAVA编程思想——第五章.初始化与清理
leooooo 发表于12个月前
JAVA编程思想——第五章.初始化与清理
  • 发表于 12个月前
  • 阅读 46
  • 收藏 0
  • 点赞 0
  • 评论 0

    工作三年多了,做过不少的项目,越到最近越深深地感觉到自己的基础薄弱,所以最近买了《java编程思想》。希望通过这次的学习能够使自己有所收获。

    这也是我第一篇博客,以往只是看而没有自己写过,这次着重记录书本上习题的解答。

    5.1 用构造器确保初始化

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

package chapter5;

public class Session1 {

	/**
	 * 未初始化的变量会自动初始化为null
	 */
	String a;
	
    public static void main(String[] args) {
		Session1 session1 = new Session1();
		System.out.println(session1.a);
        //“null”
	}
}

    练习2:创建一个类,它包含一个在定义是就被初始化了的String域,以及另一个通过构造器初始化的String域。这两种方式有何差异?

package chapter5;

public class Session1 {
	
	/**
	 * 会先初始化类中的变量
	 */
	String b = "hello";
	String c;
	
	public Session1() {
		System.out.println(b);
		/**
		 * 后进行c的初始化
		 */
		c = "world";
	}
	
	public static void main(String[] args) {
		Session1 session1 = new Session1();
        //在类初始化前会先初始化类中的变量
        //“hello”
	}
}

    5.3 默认构造器

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

package chapter5;

public class Session2 {

	public Session2() {
		System.out.println("我是默认构造器");
	}
	
    public static void main(String[] args) {
		Session2 session2 = new Session2();
        //“我是默认构造器”
	}
	
}

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

package chapter5;

public class Session2 {

	public Session2() {
		System.out.println("我是默认构造器");
	}
	
	public Session2(String arg) {
		this();
		System.out.println("我是重载有参构造器,我接收的参数为:"+arg);
	}
	
	public static void main(String[] args) {
		Session2 session2 = new Session2("hello world");
        //“我是默认构造器”
        //“我是重载有参构造器,我接收的参数为:hello world”
	}
	
}

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

    

package chapter5;

public class Dog {

	
	void bark(String a){
		System.out.println("barking:狗吠");
	}
	
	void bark(Integer i){
		System.out.println("howling:咆哮");
	}
	
	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.bark("barking");
		dog.bark(1);
        //barking:狗吠
        //howling:咆哮
	}
}

    练习6:修改前一个练习的程序,让两个重载方法各自接受两个类型不同的参数,但二者顺序相反。验证其是否工作。

package chapter5;

public class Dog {
	
	/**
	 * 参数顺序不同也可以重载
	 * @param i
	 * @param a
	 */
	void bark(Integer i,String a){
		System.out.println("barking:狗吠");
	}
	void bark(String a,Integer i){
		System.out.println("howling:咆哮");
	}
	
	public static void main(String[] args) {
		Dog dog = new Dog();
		dog.bark(1,"barking");
		dog.bark("barking",1);
        //barking:狗吠
        //howling:咆哮
	}
}

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

package chapter5;

public class Session7 {
	
	public static void main(String[] args) {
		Session7 session7 = new Session7();
	}

}

    5.4 this关键字

    练习8:编写具有两个方法的类,在第一个方法内调用第二个方法两次:第一次调用时不使用this关键字,第二次调用时使用this关键字——这里只是为了验证它是起作用的,你不应该在实践中使用这种方式。

package chapter5;

public class TestThis {

	private void method1(){
		method2();
		/**
		 * this指当前对象的引用
		 */
		this.method2();
	}
	
	private void method2(){
		System.out.println("方法二");
	}
	
	public static void main(String[] args) {
		TestThis testThis = new TestThis();
		testThis.method1();
        //方法二
        //方法二
	}
}

    练习9:编写具有两个(重载)构造器的类,并在第一个构造器中通过this调用第二个构造器。

package chapter5;

public class Session4 {

	public Session4() {
		this("通过this调用有参构造器");
		System.out.println("无参构造器");
	}
	
	public Session4(String arg) {
		System.out.println(arg);
	}
	
	public static void main(String[] args) {
		Session4 session4 = new Session4();
        //通过this调用有参构造器
        //无参构造器
	}
	
}

    5.5 清理:终结处理和垃圾回收

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

package chapter5;

public class TestFinalize {
	
	@Override
	protected void finalize() throws Throwable {
		System.out.println("回收前执行的方法");
	}
	
	public static void main(String[] args) {
		TestFinalize finalize = new TestFinalize();
	}

}

    finalize()方法不一定会执行。

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

package chapter5;

public class TestFinalize {
	
	@Override
	protected void finalize() throws Throwable {
		System.out.println("回收前执行的方法");
	}
	
	public static void main(String[] args) {
		TestFinalize finalize = new TestFinalize();
		finalize = null;
		System.gc();
        //回收前执行的方法
	}

}

    练习12:编写名为Tank的类,此类的状态可以使“满的”或“空的”。其终结条件是:对象被清理时必须处于空状态。编写finalize()以检验终结条件是否成立。在main()中测试Tank可能发生的几种使用方式。

package chapter5;

public class Tank {

	private boolean full = true;
	
	@Override
	protected void finalize() throws Throwable {
		if(!full){
			System.out.println("空了,不要了");
		}
	}
	
	public static void main(String[] args) {
		Tank t = new Tank();
		t = null;
		System.gc();
        //此时状态是“满的”所以回收时不会执行输出
	}
	
}
package chapter5;

public class Tank {

	private boolean full = true;
	
	@Override
	protected void finalize() throws Throwable {
		if(!full){
			System.out.println("空了,不要了");
		}
	}
	
	public static void main(String[] args) {
		Tank t = new Tank();
		t.full = false;
		t = null;
		System.gc();
        //状态是“空的”
        //回收时会输出
        //空了,不要了
	}
	
}

    5.7 初始化顺序

    练习14:编写一个类,拥有两个静态字符串域,其中一个在定义处初始化,另一个在静态块中初始化。现在加入一个静态方法用以打印出两个字段值。请证明他们都会在被使用之前完成初始化动作。

package chapter5;

public class Session7 {
	
	
	static String a = "hello world";
	
	static String b;
	
	static {
		b = "hello world 2";
	}
	
	public static void main(String[] args) {
		System.out.println(Session7.a);
		System.out.println(Session7.b);
        //hello world
        //hello world 2
	}

}

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

package chapter5;


public class Session71 {

	String a;
	
	{
		a = "hello world";
	}
	
	public static void main(String[] args) {
		Session71 session71 = new Session71();
		System.out.println(session71.a);
        //hello world
	}
}

    5.8 数组初始化

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

package chapter5;

public class Session8 {

	String[] strs = {"h","e","l","l","o"};
	
	public static void main(String[] args) {
		Session8 session8 = new Session8();
		for (String string : session8.strs) {
			System.out.print(string);
		}
        //hello
	}
	
}

    练习17:创建一个类,他有一个接受一个String参数的构造器。在构造阶段,打印该参数。创建一个该类的对象引用数组,但是不实际去创建对象赋值给该数组。当运行程序时,请注意来自对该构造器的调用中的初始化消息是否打印了出来。

package chapter5;

public class Session81 {

	
	public Session81(String a) {
		System.out.println(a);
	}
	
	
	public static void main(String[] args) {
		Session81[] sss = new Session81[]{};
		//不会进行打印输出
	}
}

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

package chapter5;

public class Session81 {

	
	public Session81(String a) {
		System.out.println(a);
	}
	
	
	public static void main(String[] args) {
		Session81[] sss = new Session81[]{new Session81("1"),new Session81("2")};
		//1
		//2
	}
}

    练习19:写一个类,他接受一个可变参数的String数组。验证你可以向该方法传递一个用逗号分隔的String列表,或是一个String[]。

package chapter5;

public class Session82 {

	public Session82(String ...a) {
		for (String string : a) {
			System.out.println(string);
		}
	}
	
	public static void main(String[] args) {
		Session82 session82 = new Session82("a","b");
		
		Session82 session821 = new Session82(new String[]{"a","b"});
	}
	
}

    练习20:创建一个使用可变参数列表而不是普通的main()语法的main()。打印所产生的args数组的所有元素,并用各种不同数量的命令行参数来测试它。

package chapter5;

public class Session82 {

	public Session82(String ...a) {
		for (String string : a) {
			System.out.println(string);
		}
	}
	
	public static void main1(String...args) {
		Session82 session82 = new Session82("a","b");
		
		Session82 session821 = new Session82(new String[]{"a","b"});
	}
	
}

    5.9 枚举类型

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

package chapter5;

public enum Session9 {

	YIMAO,YIKUAI,SHIKUAI,YIBAIKUAI
	//一毛,一块,十块,一百块
}
package chapter5;

public class TestSession9 {

	public static void main(String[] args) {
		for (Session9 string : Session9.values()) {
			System.out.println(string);
			System.out.println(string.ordinal());
		}
        //YIMAO
        //0
        //YIKUAI
        //1
        //SHIKUAI
        //2
        //YIBAIKUAI
        //3
	}

}

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

package chapter5;

public class TestSession9 {

	public static void main(String[] args) {
		TestSession9 session9 = new TestSession9(Session9.SHIKUAI);
		session9.descript();
	}

	public TestSession9(Session9 session9) {
		this.session9 = session9;
	}

	private Session9 session9;

	void descript() {
		switch (session9) {
		case YIMAO:
			System.out.println("一毛");
			break;
		case YIKUAI:
			System.out.println("一块");
			break;
		case SHIKUAI:
			System.out.println("十块");
			break;
		case YIBAIKUAI:
			System.out.println("一百块");
			break;
		default:
			break;
		}
	}

}

 

共有 人打赏支持
粉丝 2
博文 3
码字总数 2556
×
leooooo
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: