- 面向對象
- 萬物皆對象
我們是怎麼認識世界的？
人類從小就不斷的接觸到各種各類存在世界上的各種生物，然後通過事物的公共特性，將它們歸類，所以以後就不會出現見到貓叫老虎。那麼我們在現實生活中，是通過具體的某個事物歸納總結它們的公共特性然後產生類那麼類就描述了該種事物的的共別。性，相當於造事物的圖紙，我們可以根據這個圖紙去做出具體的實體對象。
對象：在現實生活中存在具體的一個事物。;
類：實際就是對某種類型事物的共性屬性與行爲的抽取。
人類認識世界： 對象----à類。
在java中： 類 -----à對象。
使用計算機語言就是不斷的在描述現實生活中的事物。
java中描述事物通過類的形式體現，類是具體事物的抽象，概念上的定義。
對象即是該類事物實實在在存在的個體。
類與對象的關係如圖
可以理解爲：
類就是圖紙
汽車就是堆內存中的對象
“面向對象”(英語：Object Oriented,簡稱OO)是一種以事物爲中心的編程思想。
面向對象程序設計（英語：Object-oriented programming，縮寫：OOP），是一種程序開發的方法。它將對象作爲程序的基本單元，將程序和數據封裝其中，以提高軟件的重用性、靈活性和擴展性。
面向對象時相對於面向過程而已的（c則是一個典型的面向過程的語言），站在面向對象的角度去看問題，你則是對象的動作的指揮者。如果站在面向過程的角度去看問題，你則是動作的執行者。
“萬物皆對象”。
1：買電腦
1：面向過程
1：查資料
2：電腦城砍價
3：被黑
4：痛苦歸來
1：面向對象
1：找對象。老師
2：老師.砍價
3：老師.檢測電腦
4：電腦成功購買
2：喫飯
1：面向過程
1：自己動手做
2：買菜
3：洗菜
4：煮飯炒菜
5：很難喫，浪費時間
2：面向對象
1：找專業對象
2：餐館.點餐
3：餐館，做飯
4：飯好喫，節約時間，精力
4：找對象
1：求介紹，相親，找現成的對象。（面向對象的思想先找有的對象，直 接拿來使用）
2：不滿意，沒有對象，自己造一個。（sun沒有提供，自己造對象）
再例如：人開門，人開電視，人畫園。
強調的是功能行爲，面向過程”是一種以過程爲中心的編程思想。“面向過程”他們不支持豐富的“面向對象”特性（比如繼承、多態），就是分析出解決問題所需要的步驟，然後用函數把這些步驟一步一步實現，使用的時候一個一個依次調用就可以了。面向過程在這一系列工作的執行中，強調的是工作的執行。
-
- 對象
對象（object）代表現實世界中可以明確標識的一個實體。例如：一個學生、一張桌子、一間教室，一臺電腦都可以看做是一個對象。每個對象都有自己獨特的狀態標識和行爲
對象的屬性（attribute，或者狀態（state）），學生有姓名和學號，該學生特有的姓名和學號就是該學生（對象）的屬性。
對象的行爲（behavior），是由方法定義，調用對象的一個方法，其實就是給對象發消息，要求對象完成一個動作。可以定義學生對象具備學習的行爲。學生對象可以調用學習的方法，執行學習的動作
封裝(encapsulation)
繼承(inheritance)
多態(polymorphism)
開發的過程：其實就是不斷的創建對象，使用對象，指揮對象做事情。
設計的過程：其實就是在管理和維護對象之間的關係.
案例：通過Java語言定義一個汽車類，並生產出汽車，有顏色，輪胎個數， 有運行的功能。
分析：
如何描述現實世界中的事物，描述該事物的屬性和行爲，汽車具有顏色和輪胎數的屬性，具備運行的行爲。
如何使用Java語言進行轉換？
根據對應關係：
屬性：類中的成員變量
行爲：類中的成員函數
那麼定義Java類就是定義一個類的成員。汽車類具備的成員是：顏色，輪胎數，運行方法。
Car類定義流程：
- 使用class 關鍵字 定義類，
-
-
- class空格 類名。類名就是標識符，命名規則，單詞的首字母大寫，多個單詞的首字母大寫。注意：不是規定，但是最好遵守
- 類名後緊跟一對{}表示類的開始和結束。
-
-
- 汽車有輪胎數 int num;
-
-
- 不需要給num初始化值，因爲汽車輪胎數不確定，有4，有6，有8。
-
-
- 有顏色 String color
-
-
- 爲什麼使用String 例如定義顏色"紅色"是字符串類型。
- 也不需要初始化值。
-
-
- 跑的行爲(方法、函數) void run(){}
-
-
- 方法中執行輸出語句。syso("跑啦。。。。");
-
-
|
public class Car {
String color;// 成員變量 int num; // 成員變量
// 成員函數 void run() { System.out.println(color + "的車，輪胎數：" + num + "個，跑起來了"); } } |
-
- 對象的創建
創建Car對象
- 使用new關鍵詞，就像new數組一樣
- 需要給型的汽車起一個名字，car
- 變量都是有類型的，car屬於什麼類型，屬於Car類型，叫做類類型
- Car car=new Car();
圖紙畫好了，類定義成功了。如何根據圖紙生產汽車，在Java中如何根據類來生產一個對象。
Java中生產汽車比較簡單，通過一個關鍵字”new”, 通過 new Car(); 就在內存中產生了一個實體，汽車對象就生產出來了。
汽車對象生產出來後，還沒有名字，爲了方便使用，需要起一個名字。就用小寫的C 來表示新車的名字。
Java中的變量都需要有類型。那麼c 是什麼類型呢？c 是Car類型，所以c也叫做類類型變量。
|
class CarDemo { public static void main(String[] args) { // java 中創建對象，使用new關鍵字。在堆內存中開闢了空間。產生了一個實體。 Car c = new Car(); //爲了方便使用生產的汽車，就起了一個名字。 //那麼c是什麼類型,是Car類型。叫做類類型變量。 //注意 c是持有的引用，新生產的汽車並沒有直接賦值給c，持有的只是一個引用。c就想電視遙控器一樣。 c.run(); //使用對象的功能。 } }
|
-
- 對象成員的調用
有了car對象，調用對象成員
- 成員變量
- 成員方法
|
public class CarDemo { public static void main(String[] args) { Car c = new Car(); //對象名.成員變量名將返回成員變量中存儲的數值 int num=c.num; System.out.println(num);
//對象名.成員變量名,也可以給成員變量賦值 c.num = 4; c.color = "black";
//對象名.成員方法(); c.run(); } } |
成員變量: 定義在類中變量
局部變量: 定義在方法中變量
成員變量與局部變量的區別：
- 應用範圍
-
-
- 成員變量在整個類內都有效
- 局部變量只在其聲明的方法內有效
-
-
- 生命週期
- 成員變量: 它屬於對象，它隨着對象的創建而創建，隨着對象的消失而消失
- 局部變量: 使用完馬上釋放空間。
void show(int id){
for(int i=0;i<10;i++){
for(int j=0;j<10;j++){
System.out.println(id);
}
}
}
這時候 id,i,j者是在方法內聲明的，全是局部變量
j當裏層for循環執行它的生命週期開始，當裏層for結束，j消失
i當外層for循環執行它的生命週期開始，當外層for結束，j消失
id在方法被調用時開始，方法結束時，id消失.
- 存儲位置 成員變量屬於對象，它存儲在堆內，堆內的實體，當沒有引用指向其時，才垃圾回收清理 局部變量存在棧內存中，當不在使用時，馬上就會被釋放。
- 初始值
成員變量它存儲在堆中，如果沒有賦初值，它有默認值。
-
-
-
-
-
-
- 整數byte、short、int、long =0；
- char='\uoooo'；
- boolean =flase；
- String =null;
- 類類型 =null；
- 數組 =null；
-
-
-
-
-
局部變量，如果要想使用必須手動初始化.
-
-
-
-
-
- 方法中，參數列表中，語句中。
- 必須給初始化值，沒有初始值，不能使用
- 在棧內存中
-
-
-
- 內存分析
-
案例一：
//汽車
class Car {
//汽車應該具備的屬性
int num;
//汽車具備的顏色
String color;
//汽車跑的行爲
public void run(){
System.out.println(num+"輪子的汽車跑起來啦");
}
}
public class CarDemo{
public static void main(String[] args)
{ //創建實體，並且給該實體起一個名字
Car c = new Car();
c.color = "red";
c.num = 4;
c.run();//指揮車進行運行。調用格式：對象.對象成員
}
}
(圖1 )
案例二分析：
public static void main(String[] args)
{ //創建實體，並且給該實體起一個名字
Car c = new Car();
Car c1 = new Car();
c.color = "red";
c1.num = 4;
System.out.println(c1.color);
c.run();//指揮車進行運行。調用格式：對象.對象成員
}
內存圖：
(圖二)
案例三
public static void main(String[] args)
{ //創建實體，並且給該實體起一個名字
Car c = new Car();
Car c1 = c;
c.color = "red";
c1.num = 4;
c1.color = "green";
System.out.println(c1.color);
c.run();//指揮車進行運行。調用格式：對象.對象成員
}
內存圖三
(圖三)
1：完成修理汽車的功能
2：分析
1：面向對象的思想思考需要什麼對象
1：汽車
1：汽車有輪子
2：有顏色
3：有名字
4：有運行的方法
2：汽車修理廠
1：有名字
2：有地址
3：有修理汽車的方法
3：代碼實現
1：定義汽車類
2：定義汽車修理廠類
4：測試代碼
1：創建汽車對象
2：汽車少了輪子無法運行。
3：創建汽車修理廠
1：設置廠名
2：設置地址
3：將汽車拖進修理廠
1：運行汽車修理廠的修車方法，修理汽車
4：取車
1：開走汽車
|
package oop01;
/* 面向對象之練習 完成修理汽車的功能
汽車類 汽車修理廠類 名字，地址， 修理汽車的功能
*/ public class Demo1 {
public static void main(String[] args) { SCar sc = new SCar(); sc.run(); //將汽車輪子改爲3個 sc.num = 3; sc.run();
CarFactory cf = new CarFactory(); cf.name = "幸福修理廠"; cf.addr = "天河區棠東東路預付科貿園a棟206";
cf.repairCar(sc); sc.run();
System.out.println(); } }
class SCar { String name = "smart"; String color = "red"; int num = 4;
void run() { if (num < 4) { System.out.println("汽車壞了，趕緊修理吧。。。。"); } else { System.out.println(name + ":" + color + ":" + num + ":跑起來了。。。。"); }
}
}
class CarFactory { String name; String addr;
void repairCar(SCar sc) { sc.num = 4; System.out.println("汽車修好了。。。。"); } }
|
|
|
2.1匿名對象：沒有名字的實體，也就是該實體沒有對應的變量名引用。
2.2匿名對象的用途
1，當對象對方法進行一次調用的時候，可以使用匿名對象對代碼進行簡化。
爲什麼只對方法，而不調用屬性呢？因爲匿名對象調用屬性沒意義。
如果對象要多成員進行多次調用，必須給對象起個名字。不能在使用匿名 對象。
2，匿名對象可以實際參數進行傳遞。
2：匿名對象的簡單演示
1：new Car().run();
3：內存結構圖
1：new Car().num=5;
2：new Car().clor="blue";
兩個new 是兩個不同的對象，在堆內存中有不同的空間，相互不相互干擾。
4：匿名對象的使用
1：當只使用一次時可以使用匿名對象。執行完畢到;後該對象就變成了垃圾。
new Car().run();
2:執行方法時，可以將匿名對象作爲實際參數，傳遞進去。
5:修黑車
1：需求
將小汽車改裝成3個輪子的黑車。
1：汽車類。
2：汽車修理廠
|
/* 匿名對象 匿名信 修黑車 汽車類 黑車廠類 把汽車的改成黑色3輪車。
*/ class Car { String name = "smart"; String color = "red"; int num = 4;
void run() { System.out.println(name + ":" + color + ":" + num + ":跑起來了。。。。"); }
}
class BlackCarFactory { String name; String addr;
Car repairCar(Car c) { c.num = 3; c.color = "黑色"; System.out.println("改裝成功啦。。。");
} }
class Demo1 {
public static void main(String[] args) {
BlackCarFactory bcf = new BlackCarFactory(); bcf.name = "幸福修理廠"; bcf.addr = "天河區棠東東路御富科貿園a棟206";
// 非匿名對象 Car c = new Car(); c.run(); // 改裝 bcf.repairCar(c); // 取車 c.run();
// 匿名對象一,只使用一次： // 如下創建了2個對象 /* * new Car().run(); * * new Car().run(); */
// 匿名對象二，作爲實際參數傳遞 Car c2 = bcf.repairCar(new Car()); c2.run();
System.out.println(); } } |
練習：
- 請問輸出的name屬性是什麼? new Perosn == new Person()相等嗎？
總結：
1. 匿名對象設置的屬性永遠無法獲取？ 沒有引用變量指向那個對象。
2. 任何兩個匿名對象使用==比較，永遠返回false。
3. 匿名對象主要應用於實參。
我們日常使用的電腦主機，把cpu、內存、主板等等都封裝到機箱裏面去。假如沒有機箱的話的出現什麼問題，主機、主板全部都散落在一處，然後開機沒有開機按鈕，那麼需要我們直接操作接跳線才能把電腦開啓。這樣子的話假如操作不慎的話，會讓機器損壞危險,那麼假如用機箱封裝起來的話，那麼就不需要這樣子做了。體現了封裝的---安全特性。
你拿電腦去加內存，可以直接給電腦給維修的人，等他加好內存了之後。你拿到的還是那個機箱，裏面發生了怎樣子的變化你並不知道。封裝的第二個好處-將變化隔離。
在機箱裏面提供一個開機按鈕，而不需要你直接使用跳線開機的話，體現了封裝的—便於使用的特性。
只要機箱提供了一個開機的功能，然後無論這個機箱拿到哪裏去，都可以使用這個開機的功能.體現了封裝的---提供重複性的特性。
-
- 沒有封裝
模擬問題
- 描述Employee類。定義姓名，工號，性別的成員變量，和工作的方法。成員使用public修飾。
- 創建Employee對象，對象.成員的方式進行賦值。最後該對象調用工作方法。
- 總結：如果不使用封裝，很容易賦值錯誤，並且任何人都可以更改，造成信息的 不安全。
- 問題解決：使用封裝
|
package oop01;
public class EmployeeDemo { public static void main(String[] args) { // 創建對象 Employee jack = new Employee();
// 進制通過類名.成員的形式調用成員。初始化實例變量 jack.name = "jack"; jack.id = "123456"; jack.gender = "男";
// 調用成員方法 jack.work(); System.out.println();
// 傳入非法的參數 jack.gender = "不是男人"; jack.work();
} }
class Employee { String name; String id; String gender;
public void work() { System.out.println(id + ":" + name + ":" + gender + " 努力工作中！！！"); } } |
-
- 封裝的實現
1：設置類的屬性爲private(關鍵字)，不能使用對象名.屬性名的方式直接訪問對象的屬性。
|
package oop01;
public class EmployeeDemo { public static void main(String[] args) { // 創建對象 Employee jack = new Employee();
//編譯報錯 jack.name = "jack"; jack.id = "123456"; jack.gender = "男";
// 編譯報錯 jack.gender = "不是男人"; jack.work();
} }
class Employee { //使用了private修飾了成員變量 private String name; private String id; private String gender;
public void work() { System.out.println(id + ":" + name + ":" + gender + " 努力工作中！！！"); } } |
問題：
1：爲什麼之前可以通過對象名.屬性名的方式訪問？
2：public 成員修飾符，公共的誰都可以訪問。
3：private 成員修飾符，私有的，只有自己可以訪問。
2：修改Employee類 性別的修飾符修改爲private
1：編譯不通過
2：private修飾的成員在自己所在的類中可以使用，在類外邊不可以使用。
3：Employee類的gender的修飾符修改爲private後，無法再類外調用，那麼如何給gender設置值？
1：對外提供公開的用於設置對象屬性的public方法
1：設置set
2：獲取get
2：在set方法中加入邏輯判斷，過濾掉非法數據。
3：將所有的成員變量封裝加上private，提供get、set方法
|
package oop01;
public class EmployeeDemo { public static void main(String[] args) { // 創建對象 Employee jack = new Employee();
// 調用公有方法，給成員變量賦值。 jack.setId("007"); jack.setName("jack"); jack.setGender("男xx");
// 獲取實例變量的值 System.out.println(jack.getGender()); System.out.println(jack.getId()); System.out.println(jack.getName());
// 調用成員方法 jack.work();
} }
class Employee { private String name; private String id; private String gender;
// 提供公有的get set方法 public String getName() { return name; }
public void setName(String n) { name = n; }
public String getId() { return id; }
public void setId(String i) { id = i; }
public String getGender() { return gender; }
public void setGender(String gen) { if ("男".equals(gen) || "女".equals(gen)) { gender = gen; } else { System.out.println("請輸入\"男\"或者\"女\""); }
}
public void work() { System.out.println(id + ":" + name + ":" + gender + " 努力工作中！！！"); } } |
-
- 封裝的好處
1：隱藏了類的具體實現
2：操作簡單
3：提高對象數據的安全性
-
- 封裝練習
練習：描述一個計算器類
|
/** Demo9描述一個計算器類。 */ // 0. 使用詞霸確定類名 class Calculator { // 1. 查看具體的計算器對象抽取所有計算器具有的共同屬性 public String name = "我的計算器我做主"; public double num1; public double num2; public char option; // 2. 查看具體的計算器對象抽取所有計算器具有的共同功能 // 2.1 定義接受數據的功能函數 public void init( double a , char op , double b ){
num1 = a; option = op; num2 = b; } // 2.2 定義計算的功能 public void calculate(){
switch ( option ) { case '+': System.out.println( name + " : " + num1 + " + " + num2 + " = " + ( num1 + num2 ) ); break; case '-': System.out.println( name + " : " + num1 + " - " + num2 + " = " + ( num1 - num2 ) ); break; case '*': System.out.println( name + " : " + num1 + " * " + num2 + " = " + ( num1 * num2 ) ); break; case '/': { if( num2 != 0 ) System.out.println( name + " : " + num1 + " / " + num2 + " = " + ( num1 / num2 ) ); else System.out.println("除數不能爲0!"); break; } case '%': { // 1.處理結果的符號問題，使得結果的符號滿足數學的要求 // 2.解決NaN的問題 System.out.println( name + " : " + num1 + " % " + num2 + " = " + ( num1 % num2 ) ); break; } default : System.out.println("你在搗亂，我不理你，氣死你......");
}
} } class Demo9 { public static void main(String[] args) {
Calculator cal = new Calculator(); cal.init( 41 , '%' , 0 ); cal.calculate(); System.out.println("計算完畢!再來一次......"); } } |
1.我們人出生的時候，有些人一出生之後再起名字的，但是有些人一旦出生就已經起好名字的。那麼我們在java裏面怎麼在對象一旦創建就賦值呢？
構造方法作用：對對象進行初始化.
- 一般函數是用於定義對象應該具備的功能。而構造函數定義的是，對象在調用功能之前，在建立時，應該具備的一些內容。也就是對象的初始化內容。
- 構造函數是在對象建立時由jvm調用, 給對象初始化。一般函數是對象建立後，當對象調用該功能時纔會執行。
- 普通函數可以使用對象多次調用，構造函數就在創建對象時調用。
- 構造函數的函數名要與類名一樣，而普通的函數只要符合標識符的命名規則即可。
- 構造函數沒有返回值類型。
1. 當類中沒有定義構造函數時，系統會指定給該類加上一個空參數的構造函數。這個是類中默認的構造函數。當類中如果自定義了構造函數，這時默認的構造函數就沒有了。
備註：可以通過javap命令驗證。
2.在一個類中可以定義多個構造函數，以進行不同的初始化。多個構造函數存在於類中，是以重載的形式體現的。因爲構造函數的名稱都相同。
|
class Perosn{ private int id;
private String name;
private int age;
public Perosn(){ cry(); } public Perosn(int id, String name, int age) { this.id = id; this.name = name; this.age = age; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; }
public void cry(){ System.out.println("哇哇哇...."); }
} |
問題：要求每個小孩出生都會哭，這份代碼有兩個構造函數，如果需要每個小孩出生都要哭的話，那麼就需要在不同的構造函數中都調用cry()函數，但是這樣子的話造成了代碼重複問題，那麼怎麼解決呢？構造代碼塊。
-
- 構造代碼塊
構造代碼塊作用：給所有的對象進行統一的初始化。
|
class Perosn{ private int id;
private String name;
private int age;
{ cry();// 每個Person對象創建出來都會執行這裏的代碼 }
public Perosn(){ cry(); } public Perosn(int id, String name, int age) { this.id = id; this.name = name; this.age = age; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; }
public void cry(){ System.out.println("哇哇哇...."); }
} |
2：作用
1：給對象進行初始化。對象一建立就運行並且優先於構造函數。
2：與構造函數區別
1：構造代碼塊和構造函數的區別，構造代碼塊是給所有對象進行統一初始化， 構造函數給對應的對象初始化。
2：構造代碼塊的作用：它的作用就是將所有構造方法中公共的信息進行抽取。
例如孩子一出生統一哭
|
class Boy {
String name; int age; String gender; // 構造代碼塊,給所有對象進行初始化。 { System.out.println("哭。。。"); }
Boy() { System.out.println("無參構造"); }
Boy(String n, int a, String g) { name = n; age = a; gender = g; System.out.println("有參構造"); }
void run() { System.out.println("跑..."); }
}
class Demo9 {
public static void main(String[] args) {
System.out.println(); Boy b = new Boy();
Boy b2 = new Boy("jack", 1, "男");
} } |
疑問：創建的p對象爲什麼沒有值。
解答：name與age在指定的構造函數裏面已經存在，當name=name這個語句執行的時候，如果jvm在該方法內能尋找到該變量，則不會去尋找成員變量，那麼要想指定給成員變量或對象的屬性進行初始化賦值，那麼必須指定name是成員屬性。
this關鍵字代表是對象的引用。也就是this在指向一個對象，所指向的對象就是調用該函數的對象引用。
1：沒有this會出現什麼問題
1：定義Person類
1：有姓名年齡成員變量，有說話的方法。
2：定義構造方法，無參的，多個有參的。都要實現。
|
class Person {
String name; int age; //無參數構造函數 Person() { System.out.println("這是無參的構造函數"); }
//有參數構造函數 Person(int a) { age = a; System.out.println("有參構造1"); } //有參數構造函數 Person(String n) { name = n; System.out.println("有參構造2"); } //有參數構造函數 Person(int a, String n) { age = a; name = n; System.out.println("有參構造"); }
//普通函數 void speak() { System.out.println("hah"); } } |
2；假設定義40個成員變量，第一個有參構造初始化20個變量，第二個有參構造需要初始化40個變量。
1：第二個有參構造想要使用第一個有參構造。
2：成員函數相互之間可以調用。構造函數可以嗎？
3：編譯失敗，那麼構造函數之間應該存在相互調用的模式。this就可以完成這個工作。
|
class Person { String name; int age;
Person() {
} Person(String n){ name=n; } Person(String n, int a) { //編譯報錯 Person(n); age = a; } } |
3：總結：實際工作中，存在着構造函數之間的相互調用，但是構造函數不是普通的成員函數，不能通過函數名自己接調用
所以sun公司提供this關鍵字。
2：this是什麼
1：在構造函數中打印this
2：創建對象，打印對象名p
3：this和p是一樣的都是內存地址值。
4：this代表所在函數所屬對象的引用。
|
class Student { String name; String gender; int age;
Student() {
}
Student(String name) { this(); this.name = name; }
Student(String name, String gender, int age) { this(name); System.out.println(this); // Student@c17164
this.gender = gender; this.age = age; }
void speak() { run(); System.out.println("姓名：" + name + " 性別：" + gender + " 年齡：" + age + " 哈哈！！！"); }
void run() { System.out.println("run....."); }
}
class Demo2 {
public static void main(String[] args) {
Student p = new Student("jack", "男", 20); System.out.println(p); // Student@c17164
Student p2 = new Student("rose", "女", 18); System.out.println(p2);
p.speak();
} } |
3：遞歸構造函數調用
1：構造函數的相互調用
在編譯時期會報錯
|
class Student { String name; String gender; int age; //構造函數見相互調用 Student() { this(null); } //構造函數見相互調用 Student(String name) { this(); this.name = name; }
Student(String name, String gender, int age) { this(name); this.gender = gender; this.age = age; }
void speak() { run(); System.out.println("姓名：" + name + " 性別：" + gender + " 年齡：" + age + " 哈哈！！！"); }
void run() { System.out.println("run....."); }
}
|
4：this只能在非靜態中（沒有static修飾的）函數使用
5：構造函數間相互調用必須放在構造函數的第一個語句中，否則編譯錯誤
6：可以解決構造函數中對象屬性和函數形參的同名問題。
static關鍵字 封裝、繼承和多態 java初學-面向對象二 https://blog.csdn.net/fei8888888/article/details/84537367
抽象類、多實現、多繼承 java初學-面向對象三 https://blog.csdn.net/fei8888888/article/details/84537551
內部類、異常 java初學-面向對象四 https://blog.csdn.net/fei8888888/article/details/84579208
包機制、訪問修飾符、Jar包 java初學 面向對象五 https://blog.csdn.net/fei8888888/article/details/84579699