java 面向對象 下

包裝類

爲8種基本數據類型分別定義了相應的引用類型，稱爲基本數據類的包裝類。開發者可以近似地把基本類型當成對象來使用（所有裝箱，拆箱過程都由系統自動完成），反過來也可以把包裝類當成基本數據類型來使用。

包裝類還可以實現基本類和字符串之間的轉換

public class Primitive2String
{
	public static void main(String[] args) 
	{
		String intStr = "123";
		//把一個特定字符串轉換成int變量
		int it = Integer.parseInt(intStr);
		System.out.println(it);
		String floatStr = "4.56";
		//把一個特定字符串轉換成float變量
		float ft = Float.parseFloat(floatStr);
		System.out.println(ft);
		//把一個float變量轉換成String變量
		String ftStr = String.valueOf(2.345f);
		System.out.println(ftStr);
		//把一個double變量轉換成String變量
		String dbStr = String.valueOf(3.344);
		System.out.println(dbStr);
		//把一個boolean變量轉換成String變量
		String boolStr = String.valueOf(true);
		System.out.println(boolStr.toUpperCase());
	}
}

當包裝類與數值進行比較時會直接取出包裝類所包裝的數值進行比較。兩個包裝類的實例進行比較就比較複雜，因爲包裝類實際上是引用類型，只有兩個包裝裏引用指向同一個對象纔會返回true。

處理對象

輸出對象實際上是輸出對象的toString方法的返回值

toString是Object類中的一個實例方法，所有java類都是Object類的子類，所以所有類都具有toSting（）方法

當對象和字符船進行連接的時候，系統也會調用java對象的toString方法的返回值和字符串進行連接。

 

== ：不要求數值類型完全相同。對於引用型變量，只有指向同一個對象時才返回true，不能用於比較沒有父子關係的兩個對象。

public class StringCompareTest
{
	public static void main(String[] args)
	{
		// s1直接引用常量池中的"瘋狂Java"
		String s1 = "瘋狂Java";
		String s2 = "瘋狂";
		String s3 = "Java";
		// s4後面的字符串值可以在編譯時就確定下來
		// s4直接引用常量池中的"瘋狂Java"
		String s4 = "瘋狂" + "Java";
		// s5後面的字符串值可以在編譯時就確定下來
		// s5直接引用常量池中的"瘋狂Java"
		String s5 = "瘋" + "狂" + "Java";
		// s6後面的字符串值不能在編譯時就確定下來，
		// 不能引用常量池中的字符串
		String s6 = s2 + s3;
		// 使用new調用構造器將會創建一個新的String對象，
		// s7引用堆內存中新創建的String對象
		String s7 = new String("瘋狂Java");
		System.out.println(s1 == s4); // 輸出true
		System.out.println(s1 == s5); // 輸出true
		System.out.println(s1 == s6); // 輸出false
		System.out.println(s1 == s7); // 輸出false
	}
}

JVM常量池（constant pool）保證相同的字符串直接量只有一個。。例子中1,4,5所引用的字符串在編譯的時候就確定下來了，因此他們引用變量池中的同一個字符串對象。

Object默認提供的equals()只是比較對象的地址，與==的比較結果相同。但可以對它進行重寫

/**
 * Description:
 * 網站: <a href="http://www.crazyit.org">瘋狂Java聯盟</a><br>
 * Copyright (C), 2001-2018, Yeeku.H.Lee<br>
 * This program is protected by copyright laws.<br>
 * Program Name:<br>
 * Date:<br>
 * @author Yeeku.H.Lee [email protected]
 * @version 1.0
 */
class Person
{
	private String name;
	private String idStr;
	public Person(){}
	public Person(String name , String idStr)
	{
		this.name = name;
		this.idStr = idStr;
	}
	// 此處省略name和idStr的setter和getter方法。
	// name的setter和getter方法
	public void setName(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return this.name;
	}

	// idStr的setter和getter方法
	public void setIdStr(String idStr)
	{
		this.idStr = idStr;
	}
	public String getIdStr()
	{
		return this.idStr;
	}
	// 重寫equals()方法，提供自定義的相等標準
	public boolean equals(Object obj)
	{
		// 如果兩個對象爲同一個對象
		if (this == obj)
			return true;
		// 只有當obj是Person對象
		if (obj != null && obj.getClass() == Person.class)
		{
			Person personObj = (Person)obj;
			// 並且當前對象的idStr與obj對象的idStr相等纔可判斷兩個對象相等
			if (this.getIdStr().equals(personObj.getIdStr()))
			{
				return true;
			}
		}
		return false;
	}
}
public class OverrideEqualsRight
{
	public static void main(String[] args)
	{
		Person p1 = new Person("孫悟空" , "12343433433");
		Person p2 = new Person("孫行者" , "12343433433");
		Person p3 = new Person("孫悟飯" , "99933433");
		// p1和p2的idStr相等，所以輸出true
		System.out.println("p1和p2是否相等？"
			+ p1.equals(p2));
		// p2和p3的idStr不相等，所以輸出false
		System.out.println("p2和p3是否相等？"
			+ p2.equals(p3));
	}
}

 

final

final修飾的成員變量必須由程序員顯示指定初始值

類變量：必須在靜態初始化塊或者聲明該類變量時指定初始值

成員變量：必須在非靜態初始化塊、聲明該實例變量或構造器中指定初始值

final在初始化之前不能直接訪問，但可以通過方法來訪問

final修飾的引用型變量不能被重新賦值，但可以改變引用類型變量所引用對象的內容。

 

final變量可以相當於一個直接量“宏替換”，需要滿足：

在定義final變量時指定了初始值

該初始值可以在編譯時就被確認下來

/**
 * Description:
 * 網站: <a href="http://www.crazyit.org">瘋狂Java聯盟</a><br>
 * Copyright (C), 2001-2018, Yeeku.H.Lee<br>
 * This program is protected by copyright laws.<br>
 * Program Name:<br>
 * Date:<br>
 * @author Yeeku.H.Lee [email protected]
 * @version 1.0
 */
public class StringJoinTest
{
	public static void main(String[] args)
	{
		String s1 = "瘋狂Java";
		// s2變量引用的字符串可以編譯時就確定出來，
		// 因此s2直接引用常量池中已有的"瘋狂Java"字符串
		String s2 = "瘋狂" + "Java";
		System.out.println(s1 == s2); // 輸出true
		// 定義2個字符串直接量
		String str1 = "瘋狂";     //①
		String str2 = "Java";     //②
		// 將str1和str2進行連接運算
		String s3 = str1 + str2;
		System.out.println(s1 == s3); // 輸出false
	}
}

由於str1 str2在編譯時只是普通變量，不會執行宏替換，所以在編譯階段無法獲得str3的值。只要將str1 str2用fianl修飾就行

 

final修飾的類不能有子類。當子類繼承父類的時候，將可以訪問到父類內部數據，並可通過重寫來改變父類的方法的實現細節，所以不能有子類。

 

抽象類

抽象類不能用於創建實例，只要是用於被其子類調用。

當使用abstract修飾類時，表明這個類只能被繼承，當修飾方法的時候，表明這個方法只能在子類中實現。

抽象類體現的是一種模板模式的設計，抽象類作爲多個子類的通用模板，子類在抽象類的基礎上進行擴展、改造。