JAVA編程思想——第五章.初始化與清理

時間 2019-11-13

標籤 java 編程思想第五初始化清理欄目 Java 简体版

原文原文鏈接

工做三年多了，作過很多的項目，越到最近越深深地感受到本身的基礎薄弱，因此最近買了《java編程思想》。但願經過此次的學習可以使本身有所收穫。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域。這兩種方式有何差別？session

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：建立一個帶默認構造器（即無參構造器）的類，在構造器中打印一條消息。爲這個類建立一個對象。ide

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：修改前一個練習的程序，讓兩個重載方法各自接受兩個類型不一樣的參數，但兩者順序相反。驗證其是否工做。this

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()中建立其對象，用以驗證編譯器是否真的自動加入了默認構造器。spa

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

}