Java基礎語法-第八節-面向物件中

阿新 • • 發佈：2020-10-27

OOP特徵二：繼承性

為什麼要有繼承？
- 多個類中存在相同屬性和行為時，將這些內容抽取到單獨一個類中，那麼多個類無需再定義這些屬性和行為，只要繼承那個類即可。
此處的多個類稱為子類(派生類)，單獨的這個類稱為父類(基類或超類)。可以理解為:“子類 is a 父類”
類繼承語法規則:class Subclass extends SuperClass{ }
繼承的作用：
- 繼承的出現減少了程式碼冗餘，提高了程式碼的複用性。
- 繼承的出現，更有利於功能的擴充套件。
- 繼承的出現讓類與類之間產生了關係，提供了多型的前提。
注意：不要僅為了獲取其他類中某個功能而去繼承
子類繼承了父類，就繼承了父類的方法和屬性。
在子類中，可以使用父類中定義的方法和屬性，也可以建立新的資料和方法。
在Java 中，繼承的關鍵字用的是“extends”，即子類不是父類的子集，而是對父類的“擴充套件”。
關於繼承的規則：
- 子類不能直接訪問父類中私有的(private)的成員變數和方法
- Java只支援單繼承和多層繼承，不允許多重繼承
  - 一個子類只能有一個父類
  - 一個父類可以派生出多個子類

//舉例
public class Person {
	String name;
	int age;
	public void eat() {
		System.out.println("吃飯");
	}
}
public class Student extends Person{
	int id;
	public void say() {
		System.out.println("讀書");
	}
}
public static void main(String[] args) {
    Student student = new Student();
    student.eat();
    student.say();
}
//輸出
吃飯
讀書

方法的重寫(override)

定義：在子類中可以根據需要對從父類中繼承來的方法進行改造，也稱為方法的重置、覆蓋。在程式執行時，子類的方法將覆蓋父類的方法。
要求：
- 子類重寫的方法必須和父類被重寫的方法具有相同的方法名稱、引數列表
- 子類重寫的方法的返回值型別不能大於父類被重寫的方法的返回值型別
- 子類重寫的方法使用的訪問許可權不能小於父類被重寫的方法的訪問許可權
  - 子類不能重寫父類中宣告為private許可權的方法
- 子類方法丟擲的異常不能大於父類被重寫方法的異常
注意：子類與父類中同名同參數的方法必須同時宣告為非static的(即為重寫)，或者同時宣告為static的（不是重寫）。因為static方法是屬於類的，子類無法覆蓋父類的方法。

//舉例
public class Person {
	String name;
	int age;
	public void eat() {
		System.out.println("吃飯");
	}
}
public class Student extends Person{
	int id;
    public  void eat() {
		System.out.println("學生吃飯");
	}
	public void say() {
		System.out.println("讀書");
	}
}
public static void main(String[] args) {
    Student student = new Student();
    student.eat();
    student.say();
    Person person = new Person();
	person.eat();
}
//輸出
學生吃飯
讀書
吃飯

四種訪問許可權修飾符

Java許可權修飾符public、protected、(預設)、private置於類的成員定義前，用來限定物件對該類成員的訪問許可權。

修飾符	類內部	同一個包	不同包的子類	同一個工程
private	YES
default(預設)	YES	YES
protectd	YES	YES	YES
public	YES	YES	YES	YES

對於class的許可權修飾只可以用public和default(預設)。
- public類可以在任何對方被訪問
- default類之可以被同一個包內部的類訪問

關鍵字super

在Java類中使用super來呼叫父類中的指定操作：
- super可用於訪問父類中定義的屬性
- super可用於呼叫父類中定義的成員方法
- super可用於在子類構造器中呼叫父類的構造器
注意：
- 尤其當子父類出現同名成員時，可以用super表明呼叫的是父類中的成員
- super的追溯不僅限於直接父類
- super和this的用法相像，this代表本類物件的引用，super代表父類的記憶體空間的標識
呼叫父類的構造器時：
- 子類中所有的構造器預設都會訪問父類中空引數的構造器
- 當父類中沒有空引數的構造器時，子類的構造器必須通過this(引數列表)或者super(引數列表)語句指定呼叫本類或者父類中相應的構造器。同時，只能”二選一”，且必須放在構造器的首行
- 如果子類構造器中既未顯式呼叫父類或本類的構造器，且父類中又沒有無參的構造器，則編譯出錯

this和super的區別

區別點	this	super
訪問屬性	訪問本類中的屬性，如果本類沒有此屬性則從父類中繼續查詢	直接訪問父類中的屬性
呼叫方法	訪問本類中的方法，如果本類沒有此方法則從父類中繼續查詢	直接訪問父類中的方法
呼叫構造器	呼叫本類構造器，必須放在構造器的首行	呼叫父類構造器，必須放在子類構造器的首行

public class Person {
	String name;
	int age;
	public Person() {
		System.out.println("建立一個人");
	}
	public  void eat() {
		System.out.println("吃飯");
	}
}
public class Student extends Person{
	int id;
	public Student(){
		//super() 首行隱藏了super()
		System.out.println("建立一個學生");
	}
	public  void eat() {
		System.out.println("學生吃飯");
		super.eat();
	}
	public void say() {
		System.out.println("讀書");
	}
}
public static void main(String[] args) {
    Student student = new Student();
    student.eat();
    student.say();
}
//輸出
建立一個人  
建立一個學生
學生吃飯
吃飯
讀書

OOP特徵三：多型性

多型性，是面向物件中最重要的概念，在Java中的體現：
- 物件的多型性：父類的引用指向子類的物件
- 可以直接應用在抽象類和介面上
Java引用變數有兩個型別：編譯時型別和執行時型別。編譯時型別由宣告該變數時使用的型別決定，執行時型別由實際賦給該變數的物件決定。
- 簡稱：編譯時，看左邊；執行時，看右邊。
- 若編譯時型別和執行時型別不一致，就出現了物件的多型性(Polymorphism)
- 多型情況下，“看左邊”：看的是父類的引用（父類中不具備子類特有的方法）
- “看右邊”：看的是子類的物件（實際執行的是子類重寫父類的方法）
物件的多型 —在Java中,子類的物件可以替代父類的物件使用
- 一個變數只能有一種確定的資料型別
- 一個引用型別變數可能指向(引用)多種不同型別的物件
子類可看做是特殊的父類，所以父類型別的引用可以指向子類的物件：向上轉型(upcasting)。
一個引用型別變數如果宣告為父類的型別，但實際引用的是子類物件，那麼該變數就不能再訪問子類中新增的屬性和方法
```
Student m = new Student();
m.school = “pku”; //合法,Student類有school成員變數
Person e = new Student(); 
e.school = “pku”; //非法,Person類沒有school成員變數
```
- 屬性是在編譯時確定的，編譯時e為Person型別，沒有school成員變數，因而編譯錯誤
虛擬方法呼叫(多型情況下)
- 子類中定義了與父類同名同參數的方法，在多型情況下，將此時父類的方法稱為虛擬方法，父類根據賦給它的不同子類物件，動態呼叫屬於子類的該方法。這樣的方法呼叫在編譯期是無法確定的。
```
Person e = new Student();
e.getInfo(); //呼叫Student類的getInfo()方法
```
- 編譯時e為Person型別，而方法的呼叫是在執行時確定的，所以呼叫的是Student類的getInfo()方法。——動態繫結
從編譯和執行的角度看
- 過載，是指允許存在多個同名方法，而這些方法的引數不同。編譯器根據方法不同的引數表，對同名方法的名稱做修飾。對於編譯器而言，這些同名方法就成了不同的方法。它們的呼叫地址在編譯期就綁定了。Java的過載是可以包括父類和子類的，即子類可以過載父類的同名不同引數的方法。所以：對於過載而言，在方法呼叫之前，編譯器就已經確定了所要呼叫的方法，這稱為“早繫結”或“靜態繫結”；
- 而對於多型，只有等到方法呼叫的那一刻，解釋執行器才會確定所要呼叫的具體方法，這稱為“晚繫結”或“動態繫結”。
- 引用一句Bruce Eckel的話：“不要犯傻，如果它不是晚繫結，它就不是多型。”
多型作用：提高了程式碼的通用性，常稱作介面重用
前提：需要存在繼承或者實現關係。有方法的重寫
成員方法：
- 編譯時：要檢視引用變數所宣告的類中是否有所呼叫的方法。
- 執行時：呼叫實際new的物件所屬的類中的重寫方法。
成員變數：不具備多型性，只看引用變數所宣告的類
子類繼承父類
- 若子類重寫了父類方法，就意味著子類裡定義的方法徹底覆蓋了父類裡的同名方法，系統將不可能把父類裡的方法轉移到子類中。
- 對於例項變數則不存在這樣的現象，即使子類裡定義了與父類完全相同的例項變數，這個例項變數依然不可能覆蓋父類中定義的例項變數

instanceof操作符

x instanceof A：檢驗x是否為類A的物件，返回值為boolean型。
- 要求x所屬的類與類A必須是子類和父類的關係，否則編譯錯誤。
- 如果x屬於類A的子類B，x instanceof A值也為true

物件型別轉換(Casting)

基本資料型別的Casting：
- 自動型別轉換：小的資料型別可以自動轉換成大的資料型別
- 強制型別轉換：可以把大的資料型別強制轉換(casting)成小的資料型別
對Java物件的強制型別轉換稱為造型
- 從子類到父類的型別轉換可以自動進行
- 從父類到子類的型別轉換必須通過造型(強制型別轉換)實現
- 無繼承關係的引用型別間的轉換是非法的
- 在造型前可以使用instanceof操作符測試一個物件的型別

Object類的使用

Object類是所有Java類的根父類
如果在類的宣告中未使用extends關鍵字指明其父類，則預設父類為java.lang.Object類

方法名稱	型別	描述
public Object()	構造	構造器
public boolean equals(Object obj)	普通	物件比較
public int hashCode()	普通	取得Hash碼
public String toString()	普通	物件列印時呼叫

==操作符與equals方法
- ==
  - 基本型別比較值:只要兩個變數的值相等，即為true。
  - 引用型別比較引用(是否指向同一個物件)：只有指向同一個物件時，==才返回true。
  - 用“==”進行比較時，符號兩邊的資料型別必須相容(可自動轉換的基本資料型別除外)，否則編譯出錯
- equals
  - 所有類都繼承了Object，也就獲得了equals()方法。還可以重寫。
  - 只能比較引用型別，其作用與“==”相同,比較是否指向同一個物件。
  - 格式:obj1.equals(obj2)
  - 特例：當用equals()方法進行比較時，對類File、String、Date及包裝類（Wrapper Class）來說，是比較型別及內容而不考慮引用的是否是同一個物件.
    - 原因：在這些類中重寫了Object類的equals()方法。
  - 當自定義使用equals()時，可以重寫。用於比較兩個物件的“內容”是否都相等
重寫equals()方法的原則
- 對稱性：如果x.equals(y)返回是“true”，那麼y.equals(x)也應該返回是“true”。
- 自反性：x.equals(x)必須返回是“true”。
- 傳遞性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那麼z.equals(x)也應該返回是“true”。
- 一致性：如果x.equals(y)返回是“true”，只要x和y內容一直不變，不管你重複x.equals(y)多少次，返回都是“true”。
- 任何情況下，x.equals(null)，永遠返回是“false”； x.equals(和x不同型別的物件)永遠返回是“false”。
toString方法
- toString()方法在Object類中定義，其返回值是String型別，返回類名和它的引用地址。
- 在進行String與其它型別資料的連線操作時，自動呼叫toString()方法
```
Date now=new Date();
System.out.println(“now=”+now); 相當於
System.out.println(“now=”+now.toString()); 
```
- 可以根據需要在使用者自定義型別中重寫toString()方法
```
如String 類重寫了toString()方法，返回字串的值。 
s1=“hello”;
System.out.println(s1);//相當於System.out.println(s1.toString());
```
- 基本型別資料轉換為String型別時，呼叫了對應包裝類的toString()方法
```
int a=10; System.out.println(“a=”+a);
```

JUnit單元測試步驟(Eclipse版)

選中當前工程-右鍵選擇-點選build path-點選add libraries-選中JUnit 4-下一步
建立Java類，進行單元測試。
- 此時的Java類要求：①此類是public的，②此類有公共的無參構造器
測試方法的格式：方法的許可權是public的，沒有返回值，方法名自定義
此單元測試方法上需要宣告註解：@Test,並在單元測試類中匯入對應包：
宣告好單元測試方法以後，就可以在方法體內測試相關的程式碼
寫完程式碼以後，左鍵雙擊單元測試方法名，右鍵-run as-JUnit Test
說明：如果執行結果沒有任何異常，則顯示為綠條。如果執行結果出現異常，則顯示紅條

包裝類的使用

針對八種基本資料型別定義相應的引用型別—包裝類（封裝類）
有了類的特點，就可以呼叫類中的方法，Java才是真正的面向物件

基本資料型別包裝成包裝類的例項 ---裝箱

通過包裝類的構造器實現：

//基本資料型別轉換成包裝類：呼叫包裝類的構造器
int num = 10;
Integer in1 = new Integer(num);
System.out.println(in1);//10

還可以通過字串引數構造包裝類物件：

//基本資料型別轉換成包裝類：通過字串引數構造包裝類物件
Integer in2 = new Integer("123");
System.out.println(in2);//123
//下面兩行會報異常
//Integer in3 = new Integer("123asd");
//System.out.println(in3);
//特殊情況:與其他型別相比，這個不會報異常
Boolean bool = new Boolean("true123");
System.out.println(bool);//false

自動封箱(JDK5.0以後支援),但型別必須匹配。

//基本資料型別轉換成包裝類：自動封箱(JDK5.0以後支援)
int a = 10;
Integer in = a;
System.out.println(in);//10

獲得包裝類物件中包裝的基本型別變數 ---拆箱

呼叫包裝類的.xxxValue()方法：

//包裝類轉換成基本資料型別：呼叫包裝類的xxxValue()方法
		Integer in = new Integer("123");
		int a = in.intValue();
		System.out.println(a);//123

自動拆箱(JDK5.0以後支援),但型別必須匹配。

//包裝類轉換成基本資料型別：自動拆箱(JDK5.0以後支援)
Integer in = new Integer("123");
int a = in;
System.out.println(a);//123

字串轉換成基本資料型別

通過包裝類的構造器實現：
通過包裝類的parseXxx(String s)靜態方法：

//String型別轉換成基本資料型別，包裝類：
//1.呼叫包裝類的parseXxx(String s)方法
String str1 = "123";
int num1 = Integer.parseInt(str1);
System.out.println(num1);//123
//報NumberFormatException異常
//String str4 = "123a";
//int num2 = Integer.parseInt(str4);
//System.out.println(num2);//123

String str2 = "true";
boolean boo1 = Boolean.parseBoolean(str2);
System.out.println(boo1);//true
//特殊情況：不會報異常
String str3 = "true1";
boolean boo2 = Boolean.parseBoolean(str3);
System.out.println(boo2);//false
//2.呼叫包裝類的構造器
String str5 = "12";
int num3 = new Integer(str5);
System.out.println(num3);//12

基本資料型別轉換成字串

呼叫字串過載的valueOf()方法：
更直接的方式：連線運算

//基本資料型別，包裝類轉換成String型別
//1.連線運算
String str1 = 10 + "";
System.out.println(str1);//10
//2.呼叫String的valueOf(Object,object或基本資料型別)方法
int i = 10;
String str2 = String.valueOf(i);
System.out.println(str2);//10

Double d = new Double(12.4);
String str3 = String.valueOf(d);
System.out.println(str3);//12.4

裝箱：包裝類使得一個基本資料型別的資料變成了類。有了類的特點，可以呼叫類中的方法。
拆箱：將數字包裝類中內容變為基本資料型別
包裝類在實際開發中用的最多的在於字串變為基本資料型別

Integer的補充

//Integer內部定義了靜態的IntegerCache結構，IntegerCache中定義了一個Integer[],
//陣列靜態儲存了從-128~127範圍的數。如果我們使用自動裝箱的方式，給Integer賦值的範圍在
//-128~127之間，可以直接使用陣列中的元素，不用再去new了。
Integer a = 1;
Integer b = 1;
System.out.println(a);//1
System.out.println(b);//1
System.out.println(a == b);//true

Integer in1 = 128;
Integer in2 = 128;
System.out.println(in1);//128
System.out.println(in2);//128
System.out.println(in1 == in2);//false

總結

/**
 * 1.面向物件的特徵之二
 * 	一，繼承性的好處
 * 		①減少了程式碼的冗餘，提高了程式碼的複用性
 * 		②便於功能的擴充套件
 * 		③為多型性的使用，提供了前提
 * 	二，繼承的格式：class A extends B{}
 * 		A:子類，派生類，subclass
 * 		B:父類，超類，基類，superclass
 *		extends：延展，擴充套件
 * 		2.1體現：一旦子類A繼承了父類B以後，子類A中就獲取了父類B中宣告的所有屬性和方法。
 * 			特別的，父類中宣告為private的屬性和方法，子類繼承父類後，仍然認為獲取了父類中私有的結構。
 * 			只是因為封裝性的影響，使得子類不能直接呼叫父類的結構而已
 * 		2.2子類繼承父類以後，還可以宣告自己特有的屬性和方法：實現功能的擴充套件
 * 			子類和父類的關係，不同於子集和集合的關係
 * 	三，Java中關於繼承的規定 
 * 		①一個類可以被多個子類繼承
 * 		②Java中類的單繼承性：一個類只能有一個父類
 * 		③子負類是相對的概念
 * 		④子類直接繼承的父類稱為：直接父類。間接繼承的父類稱為：間接父類
 * 		⑤子類繼承父類以後，就獲取了直接父類以及所有間接父類中宣告的屬性和方法
 *	四，如果我們沒有顯示的定義一個類的父類的話，則此類繼承於java.lang.Object類
 *		所有的java類(除java.lang.Object類)都直接或間接的繼承於java.lang.Object
 *		所以所有的java類具有java.lang.Object類宣告的功能
 * 2.方法的重寫(override)
 *	一，重寫：子類繼承父類以後，可以對父類中同名引數的方法進行覆蓋操作
 *	二，應用：重寫以後，當建立子類物件以後，通過子類物件呼叫父類中的同名同參數的方法時，
 *		實際執行的是子類重寫父類的方法
 *	三，重寫的規定：
 *			方法的宣告：許可權修飾符 返回值型別 方法名(形參列表){
 *								//方法體
 *						}
 *			約定俗稱：
 *		①子類重寫的方法的方法名和形參列表與父類被重寫的方法的方法名和引數列表形同
 *		②子類重寫的方法的許可權修飾符不小於父類被重寫的 方法的許可權修飾符
 *			>特殊情況：子類不能重寫父類中宣告為private許可權的方法
 *		③返回值型別
 *			>父類被重寫的方法的返回值型別是void,則子類重寫的方法的返回值只能是void
 *			>父類被重寫的方法的返回值型別是A型別(引用型別),則子類重寫的方法的返回值可以是A型別的或A類的子類
 *			>父類被重寫的方法的返回值型別是基本資料型別,則子類重寫的方法的返回值只能也是對應的基本型別
 *		④子類重寫的方法丟擲的異常型別不大於父類被重寫的方法排除的異常型別
 *		⑤子類和父類中同名同參數的方法要麼都宣告為非static的(可以重寫)，要麼都宣告為static的(不是重寫)
 * 3.super關鍵字的使用
 * 	一，super理解為：父類的
 * 	二，super可以用來呼叫：屬性，方法，構造器
 * 	三，super呼叫屬性或方法：
 * 		①我們可以在子類的方法或構造器中，通過使用“super.屬性”或“super.方法”的方式，顯示的呼叫
 * 		父類中宣告的屬性或方法。但是通常情況下我們都習慣省略“super.”
 * 		②特殊情況：當子類和父類中定義了同名的屬性時，我們想要在子類中呼叫父類中宣告的屬性，則必須顯示的使用
 * 		“super.屬性”的方式，表明呼叫的是父類中宣告的屬性。
 * 		③特殊情況：當子類重寫了父類的方法以後，外賣想在子類的方法中呼叫父類中被重寫的方法時，必須顯示的使用
 * 		“super.方法”的方式，表明呼叫的是父類中被重寫的方法。
 *	四，super呼叫構造器：
 *		①我們可以在子類的構造器中顯式的使用“super(形參列表)”的方式，呼叫父類中宣告的制定的構造器
 *		②“super(形參列表)”的使用，必須宣告在子類構造器的首行
 *		③我們在類的構造器中，針對“this(形參列表)”或“super(形參列表)”只能二選一，不能同時出現
 *		④在構造器的首行沒有顯示的宣告“this(形參列表)”或“super(形參列表)”，則預設使用“super()”呼叫父類中空參的構造器
 *		⑤在類的多個構造器中，至少有一個類的構造器中使用了“super(形參列表)”，呼叫父類中的構造器
 * 4.子類物件例項化的過程
 * 	一，從結果上看：（繼承性）
 *		子類繼承父類後，就獲取了父類中宣告的屬性或方法
 *		建立子類的物件，在堆空間中，就會載入所有父類中的宣告的屬性
 *	二，從過程上看：
 *		當我們通過子類的構造器建立子類物件時，我們一定會直接或間接的呼叫其父類的構造器，進而呼叫父類的父類的構造器
 *		直到呼叫了java.lang.Obkect類中空參的構造器為止，正因為載入了所有的父類的結構，所以才可以看到記憶體中有父類中
 *		的結構，子類物件才可以呼叫父類的結構
 *	明確：雖然建立子類物件時，呼叫了父類的構造器，但是自始至終就建立了一個物件，即為new的子類物件
 * 5.多型性的理解
 * 	一，理解多型性：可以理解為一個事務的多種形態
 * 	二，何為多型性
 * 		物件多型性：父類的引用指向子類的物件(或子類的物件賦給物件的引用)
 *	三，多型的使用：虛擬方法呼叫
 *		有了物件的多型性後，我們在編譯時期，只能呼叫父類中宣告的方法，但在執行時期，我們實際呼叫的是父類中重寫子類的方法
 *		舉例。我們定義了一個A類，定義了一個B類，且B類繼承A類。在A類中定義一個輸出方法輸出a。B類中重寫這個輸出方法輸出b。
 *			另外B類中在定義一個show()方法，輸出show。
 *			當執行A a = new B(); a.printf(); 此時的輸出是B類中重寫的內容。即輸出b
 *			但當編寫a.show()時會編譯不通過。
 *		總結：編譯看左邊，執行看右邊。
 *	四，多型性的使用前提：
 *			①類有繼承關係。②方法要重寫。
 *	五，多型性的好處：
 *			①在呼叫以物件為引數的方法時，將方法的引數設定為父類，那麼當傳進去不同子類的物件時，執行的結果也就不同。
 *			如果此時沒有多型性。我們必須將這個方法重寫很多次以適應子類的不同。因此多型性可以減少程式碼的編寫
 *	六，多型性的注意點：
 *			①物件多型性只適用於方法，不適用於屬性(屬性和方法都看左邊)		
 *	七，記憶體中的變化。
 *			多型性的使用時，記憶體中實際上是載入了子類特有的屬性何方法的。但是由於變數被宣告為父類型別，導致編譯時，
 *			只能呼叫父類中宣告的屬性何方法。子類特有的屬性仍然存在在記憶體中但無法呼叫
 * 6.instanceof關鍵字
 *	一，多型性使用後如何讓變數呼叫子類特有的屬性和方法？
 *		①向下轉型，使用強制型別轉換符
 *			缺點：A類是B類和C類的父類。當A a = new B();時，強轉a為C類時會出現ClassCastException異常
 *		②使用instanceof關鍵字提前判斷是否可以強轉
 *	二，使用：a instanceof A：表示判斷物件a是否是類A的例項。如果是返回true。如果不是返回false
 *	三，使用情景：為了避免在向下轉型時出現ClassCastException異常，我們在向下轉型之前，先進行instanceof的判斷
 *				，一旦返回true就進行向下轉型。如果返回false則不能進行向下轉型
 *	四，補充：B類是A類的父類的話那麼a instanceof A返回true,且a instanceof B也返回true.
 * 7.Object類
 * 	 ①：Object類是所有Java類的根父類
 * 	 ②：如果在類的宣告中未使用extends關鍵字指明其父類。則預設父類為java.lang.Object類	
 * 	 ③：Object類中的功能(屬性，方法)具有通用性。
 * 		屬性：無
 * 		方法：equals()/toStrings()/getClass()/hasCode()/clone()/finalize()/wait()/notify()/notifyAll()
 *   ④：Object類只聲明瞭一個空參的構造器
 *  一，==和equals()的區別
 *   ==的使用：
 *   	①：可以使用在基本資料型別和引用資料型別變數中
 *   	②：如果比較的是基本資料型別變數，比較兩個變數的資料是否相等。(不一定型別相同)
 *   	③：如果比較的是引用資料型別變數，比較兩個物件的地址值是否相同，即兩個引用是否指向同一個物件實體
 *   	④：==符號在使用時要保證符號兩邊的資料型別要一致。既可以比較
 *   equals()的使用
 *   	①：是一個方法，而非運算子
 *   	②：只能適用於引用資料型別
 *   	③：Object類中的equals()中對定義:和==是相同的，都是比較兩個物件的地址值是否相同
 *   	原始碼：public boolean equals(Object obj) {
 *       			return (this == obj);
 *   		  }
 *   	④：像String,Date,File,包裝類等都重寫了Object類中的equals()方法，重寫後比較的是兩個物件的“實體內容”是否相同
 *   		而不是引用的地址是否相同
 *   	⑤： 自定義類的比較需要我們重寫equals()方法。一般情況下我們會選擇自動生成的equals()方法。而不自己寫。
 *	二，toString()方法的使用
 *		①：Object類的toString()方法輸出的是物件的引用地址值
 *		②：當我們輸出一個物件的應用時，實際上是呼叫物件的toString()方法
 *		③：像String,Date,File,包裝類等都重寫了Object類中的toString()方法。
 *			使得在呼叫上述型別的物件的toString()方法時，返回的是物件的“實體內容”資訊
 *		④：自定義的類可以重寫toString()方法。重寫此方法一般使用自動生成，重寫後的方法返回的是實體內容的資訊
 * 8.包裝類的使用
 * 	 ①：Java提供了8中基本資料型別對應的包裝類，使得基本資料型別的變數具有類的特徵
 *	 ②：基本資料型別，包裝類，String三者之間的轉換
 *		一，基本資料型別轉換成包裝類
 *			①：呼叫包裝類的構造
 *			②：自送封箱(JDK5.0以後支援)
 *		二，包裝類轉換成基本資料型別
 *			①：呼叫包裝類的xxxValue()方法
 *			②：自動拆箱(JDK5.0以後支援)
 *		三，基本資料型別，包裝類轉換成String型別
 *			①：連線運算
 *			②：呼叫String的valueOf(Object,object或基本資料型別)方法
 *		四，String型別轉換成基本資料型別，包裝類
 *			①：呼叫包裝類的parseXxx(String s)方法
 *			②：呼叫包裝類的構造器
 */