知識回顧：
1） 異常（業務異常，用戶千奇百怪，有很多奇葩，不管代碼怎麼寫的，他亂輸入，對於這些特殊非法值，程序都應該能正常避過。）
a) try，可能錯誤代碼放入try中，儘量無法代碼不要放在裏面
b) catch，捕獲異常，如果try中代碼出錯，就會直接跳轉到catch中執行，處理預先知道可能錯誤，進行異常處理，提升：“程序發生問題，請聯繫管理員”
c) exception，獲取異常信息：e.getMessage()出錯描述信息。
d) throw，拋出異常，自己處理不了，拋出給上級（調用類）
e) throws，接收異常，調用類就必須接收這些異常，要麼自己處理try/catch，要麼在拋出，它的調用類就必須處理。這些eclipse都有提示。
2） 流程控制
a) 順序執行。從上到下，從左到右。注意賦值語句先執行=右邊，把右邊結果賦值左邊。
b) 分支執行
i. 單分支：if(){}如果條件成立true，就執行裏面的代碼，否則不執行、if(){}else{}
ii. 多分支：if(){}else if()…else{}，switch(phone) case 110,break，switch語句可以用elseif替代
c) 循環執行
i. for，for(int i=0;i<10;i++){}，foreach後面開發中會學習到，對象變量
ii. while，可以改造成for，while更加靈活，在while前面初始化變量，注意，在while方法體內，必須改變判斷值。i++，不做就死循環了。
iii. do-while，本質就是while，它們的區別。While的循環可能一次都不執行，do-while因爲判斷是在執行代碼後面，所以不論條件是否成立，最少執行一次。（讀取磁盤文件）
今天內容：
1） 面向對象
2） Java中最重要東西：類，對象（java萬物皆對象）
3） 剖析類結構：類、成員變量、構造方法三要素
4） 方法重載
1） 面向對象，代碼編程之前，設計（概要設計、詳細設計、類設計），有不同思考方式
a) 面向過程，傳統思考方式都是面向過程，做一件事，第一、第二、第三，側重於整個業務完成過程。
b) 面向對象，新思考方式，業務中涉及哪些對象，對象有哪些屬性和行爲，側重於業務中實體（對象）
舉例：經典案例：把大象裝入冰箱分幾步？
a. 面向過程分析：（和我們日常思考方式一樣）
第一， 找到一個大象
第二， 把冰箱門打開
第三， 把大象放入
第四， 把冰箱門關閉
b. 面向對象分析：
先找這個過程中涉及對象：（業務中名詞）關注內容更加廣泛，事先想的多，哪怕有些暫時用不到
大象（屬性：幾歲，體重，四肢，尾巴，眼睛。。。；行爲（動作）：跑，走，喫。。。）
冰箱（屬性：大小，幾開門，凍到幾點。。。；行爲：插電，冷凍功能）
面向對象思考方式比面向過程思考方式多思考很多，抽象難度更大。
面向過程，c語句，vb，2004年接觸java純面嚮對象語言。
爲什麼編程主流設計思想：面向對象
開發中有一個無法避免問題，這個問題會造成項目延期，甚至無法交付，甚至軟件黃了。
需求變更：做完用戶不滿意，說你做的不是他想要的？
a. 開始要求，把大象放入冰箱就可以了
b. 中間又提一個要求，大象多大？（面向過程重新修改代碼）
c. 又提出一個要求，冰箱必須海爾（面向過程重新修改代碼）
面向對象之前考慮非常多，用戶的隱性需求都在我們的設計中涵蓋，只要修改一點點代碼，同時，不會對全局設計有影響。
結論：現在開發都以“面向對象”爲核心開發方式。實際開發中其實很多地方都是“面向過程”。非常考驗軟件設計者的設計能力。一般企業中高級資深，系統分析師去做（8年+，很多年經驗），對於初學者要求，這些名稱，概念瞭解即可。
2） 面向對象OOP，Object Oriented Programming 面向對象編程語言
a) 封裝
b) 繼承
c) 多態
d) 抽象
3） Java中萬物皆對象
a) 類
b) 對象
This method must return a result of type Integer
這個方法必須有返回值，返回值類型爲Integer
Cannot make a static reference to the non-static method add2(Integer, Integer) from the type HelloWorld
Main是一個靜態方法，它不能調用非靜態add2方法
package cn.tedu;
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
//靜態方法調用 public static Integer add()
Integer r1 = HelloWorld.add1(10, 20);
System.out.println(r1);
//普通方法調用
//HelloWorld.add2(10,20);
//對應非靜態方法，必須先創建對象，然後再調用
//helloWorld就稱爲對象
HelloWorld helloWorld = new HelloWorld();
Integer r2 = helloWorld.add2(10,20);
System.out.println(r2);
}
//創建一個方法，整數相加方法 z=x+y
//java中儘量用包裝類型
//有兩個參數
public static Integer add1(Integer x, Integer y) {
Integer z = x + y;
return z;
}
public Integer add2(Integer x, Integer y) {
Integer z = x + y;
return z;
}
}
規則：儘量不要使用static方法，它比較佔資源
類：是藍圖，死的，不能直接調用類方法（add），只能有一個（蓋房子圖紙）
對象：實例，實際案例，具體內容，活的，就可以調用對象方法（add），一個類可以創建多個對象（具體樓，相同圖紙可以蓋好幾棟樓）
HelloWorld helloWorld = new HelloWorld();
HelloWorld h1 = new HelloWorld();
最常見方式，通過new關鍵字創建新的對象，
4） 類的組成，三要素
a) 構造方法，用來創建對象時，設置初始化值
b) 成員變量（屬性）
c) 普通方法（函數）
人類：
構造方法：如果你的類不寫構造方法，java編譯器會優化，它會自動創建默認構造方法。因爲類必須有構造方法才能創建類，才能使用new關鍵字。
成員變量：name、age
普通方法：work()
package cn.tedu;
public class People {
//私有成員變量
private String name; //姓名
private Integer age; //年齡
//普通方法
public void work() {
System.out.println("我去工作了");
}
}
記住：包裝類型的默認值是null，
有參構造方法比默認構造方法更加靈活，用戶可以傳入動態值。
package cn.tedu;
//私有成員變量，普通方法，默認構造方法，帶參構造方法
public class People {
private String name;
private Integer age;
public void work() {
System.out.println(name+"開始工作了，他的年齡是："+age);
}
//默認構造方法：沒有返回值，方法名字和類名一致，一個類中只能有一個默認構造方法
public People() {
name = "tony";
age = 18;
}
//帶參構造
public People(String name, Integer age) {
//this就代表這個類
//成員變量和參數同名，此時成員變量可以通過this來明確區分
this.name = name;
this.age = age;
}
}
package cn.tedu;
public class TestPeople {
public static void main(String[] args) {
//調用默認構造方法
People p1 = new People();
p1.work();
//調用帶參構造方法
People p2 = new People("任正非",60);
p2.work();
People p3 = new People("James Pond", 70);
p3.work();
}}
上午小結：
1） 面向對象和麪向過程思考方式不同
a) 面向過程，關注是處理過程，第一、第二、第三。。。
b) 面向對象，關注是實體（語句中名詞，大象，冰箱），成員變量（大小、體重、顏色。。。）和方法（走、跑、撒花。。。）
c) 不容易理解，要花很長時間。慢慢來
2） 類和對象 HelloWorld hw = new HelloWorld();
a) 類：HelloWorld，死的，不能直接訪問成員變量和方法，藍圖（蓋房子圖紙）
b) 對象：hw（實例），活的，就訪問成員變量和方法，具體實際東西（具體多個房子）
一般情況下對象都是new出來的。
3） 類由三部分組成
a) 私有成員變量，儘量使用包裝類型
i. private String name
ii. private Integer age
b) 普通方法
c) 構造方法：
i. 無參默認構造 People p = new People();
ii. 有參構造（更加靈活）People p = new People(“任正非”, 60);
默認構造方法，無返回值，方法名必須和類名一致，一個類中只能有一個默認構造方法
自己可以不寫默認構造方法，如果再沒有其他的構造方法，java編譯器優化時會自動加入默認構造。
問題：
1） 構造方法只需要掉一個，在寫代碼時new People()這就是調用默認構造方法，如果你沒有寫構造方法，java在編譯時，生成.class文件時，會自動加入默認構造方法。調用時具體指定帶參構造方法，默認構造方法就不需要執行。
2） 調用方法必須創建測試類嗎？可以不用，通常可以在自己類中寫main方法，也可以單獨創建測試類進行測試。後者是好習慣。
3） 靜態方法和普通方法區別。正課還要深入講
a) 靜態方法：HelloWorld.add();
b) 普通方法： HelloWorld hw = new HelloWorld(); hw.add();
4） Integer和int的區別
a) 在一個方法體中使用基本變量，基本類型沒有額外方法，所佔內存空間小。優點佔用空間小，用完就被釋放資源。缺點，就沒有包裝類型這些轉換方法，很多需要自己寫。開發麻煩。
b) 在一個類的成員變量儘量包裝類型，也叫引用類型，對象，它有很多額外方法hashCode()，intValue()，toString()。。。，有了這些方法也會佔用內存。優點，開發方便，java叫做面向對象編程，它裏內容都是類，類實例化後就是對象。包裝類型本身就是對象，可以和這些對象無縫銜接。但是基本類型就必須轉換。開發起來非常方便，直接調用對應方法即可。缺點：佔內存。
總結：
1） 面向對象和麪向過程：思考方式完全不同，實際開發中兩者結合
a) 面向過程，關注點：過程，第一要幹什麼，第二步要什麼。第一步，找個大象，第二步，把冰箱門打開，第三步，把大象放入冰箱（思考過程）
b) 面向對象，關注點：實體（大象（屬性：名字、大小、尾巴。。。，行爲：方法，跑，跳，嬉戲。。。），冰箱，一般語言描述中的名詞）
2） 類和對象
a) 類就是藍圖，圖紙，死的，不能直接訪問其內部東西 HelloWorld
b) 對象，創建類的實例，活的，就可以訪問類中屬性和行爲 HelloWord hw = new HelloWorld(); ，hw就叫對象，實例
3） 類由三部分內容組成
a) 構造方法，起初始化值作用。private String name;這裏沒有設置它的值，可以通過構造方法來設置值。
b) 成員變量（屬性），傳遞數據，封裝數據。把數據暫時存下來，別處就可以訪問
c) 普通方法（行爲），加工數據，add(x,y) = x+y。算法。
4） 構造方法
a) 默認構造，創建對象必須有默認構造。如果不寫默認構造，又沒有其他構造方法，java編譯時就會自動添加默認構造。如果有其他構造方法，哪怕帶參也不會創建。
b) 有參構造方法，可以多個參數，看業務情況People(String name, Integer age, String address。。。)在設置時，用戶就可以通過有參構造方法，傳遞參數值進來。相當於默認設置。
c) 規定：沒有返回值；方法名必須和類名一致。可以有參數，可以沒有參數，不能重複。默認構造方法只能有一個。創建類時，只需要一個構造方法就可以創建。不需求調用其它構造方法。
5） 成員變量和局部變量
a) 成員變量是從屬類的，這個類中都可以直接使用成員變量
b) 局部變量是從屬方法的，局部變量只能在方法內有效，出去就用不了了
這些叫做變量聲明週期。成員變量類中長，類的對象實例消亡，纔不可用。局部變量方法結束就消亡，短
6） POJO 簡單或者純粹的java對象
a) 規定：只能有2個內容。一堆私有屬性，一堆get/set方法
b) toString不是給用戶用的，所以它存在與否沒關係。它是給開發人員調用的。測試值是否正確。
7） User POJO
Public class User{
private Integer id;
private String name;
private Integer age;
//利用eclipse生成所有get和set方法，右鍵source菜單，generate生成 get/set方法 //利用elipse生成toString方法
}