一、總結
一階段
day01 java 發展，java 環境( path, java_home, class_path)，java 原理， java 執行 ， jvm , jre , jdk
day02 變量 標識符命名規則 數據類型 數據類型的轉換 運算符
day03 選擇結構 if , switch
day04 循環結構 for , while , do-while
day05 雙重循環（打印星星）
day06 數組（一維數組）：排序（冒泡，選擇），數據的擴容與縮容
day07 ATM機
二階段
面向對象
day08? 面向過程，**面向對象的思想**（基于對象 -》類）， 類與對象的關系, 類是模板。? 類和對象的概念? 方法? 重載? 類的包括（成員變量，成員方法）day09 ? 封裝? this? private ? 構造函數day10? 繼承( 多個類重復的信息，提供一個公共類，使用繼承去實現)? extends ? 特點：只能單繼承不能多繼承? 子類可以繼承父里哪些（私有的繼承不了）? 重寫day11? 多態? 要有繼承 ? 要有重寫? 要有父指子類的引用? （編譯看左邊，除了方法運行看右邊外，其它的運行也是看左邊； 為什么方法運行看右邊，因為它實現重寫）day12? 抽象類與接口? 抽象類: 包括抽象方法類，一定要抽象 類，抽象類可以有構造方法，抽象 方法，還可以有普通方法； 只是不能實例化? 接口： 一定要抽象方法， jdk 1.8 default , static jdk 1.9 private 方法（主要指default使用）? 多態的分類? 具體類多態? 抽象 類多態? 接口多態 (用的最多)? 抽象類與接口區別? 關系 ? 類與類，接與接口，類與接口? 成員? 成員屬性? 構造方法? 成員方法? 設計 is a , like a day13 - day14 Math, String , Object , Date , Calendar , 包裝類 ， 正則表達式 , Scanner , Random 等day16代碼塊內部類成員內部類，局部內容部， 匿名內類部（本質是一個對象）lamda表達式day17 異常day 18 IOday 19 網絡編程day20 多線程**day21-day22 集合** ? 單列 （Connection） 雙列(Map)? list set HashMap HashTable ... ? ArrayList, LinkedList, Vecktor HashSet, TreeSet put() :存值 ，如果 鍵名相同，就是修改值 . 鍵不能重復? 考原理：數組與鏈表 (底層HashMap, Jdk1.9 結合紅黑樹去實現)? 哈希表(數組+鏈表的結合)day 23-24 Mysql ? 關系型數據 ? 增刪改查（mysql ）約束（外鍵約束）查詢 （表連接， join, left join ,right join ）索引 ? 事務（ACID）: 隔離性（臟讀，不可重復讀，幻讀 =》 sql 隔離級別）mysql 存儲引擎（不同引擎它的支持不一樣）day 25 JDBCjava 去連接數據的一種技術 （JDBC api ）不同數據庫去實現JDBC 接口下載jar使用jarjdbc連接數據的步驟：1. 注冊驅動
2. 創建連接對象
3. 創建sql執行對象 statement
4. 寫sql 語句，且調用對象的方法執行。 excuteQuery() , excuteUpdate();
5. 如果是查詢，處理結果集
6. 釋放資源 封裝 1. 把重復，提成一個方法（創建連接的方法， 釋放資源的方法）
2. 把提取方法專門一個獨立的類里(JdbcUtils)
3. jdbc連接時，url , 驅動， 用戶名，密碼； 因為它們可能進行修改，所有獨立配置文件，提高了代碼的維護性day 26 反射使用Class 對象，獲取成員屬性，構造方法，成員方法（動態代理）1. 獲取 Class 對象類名.class;對象名.getClass();Class.forName(類名-包括包名);2. 構造方法 3. 成員屬性(在使用時，必須要有對象)4. 成員方法(在使用時，必須要有對象)(加s 的表示獲取所有， 不加s表示獲取單個) -- 默認這些方法都調用的public修飾如果要獲取所有修飾的類型。 給方法一個Declared 注： 如果是私有的，即便獲取 了，也不能使用，如果要使用，把java安全語法檢查跳過. xxx.setAccessable(true);作業
-
寫一個setProperty(Object obj, String propertyName, object value){}
-
給ArrayList的一個對象，添加一個字符串
-
curd(增刪改查)商品
商品表(goods)
? g_id,g_name,g_price,g_num
? 思路：
1. 創建表2. 接口(定義方法)3. 寫一個Jdbc工具類4. 接口的實現5. 測試類，調用實現類的方法
二、JDBC 與反射結合
封裝了兩個方法： 增刪改 excuteUpdate, 查詢 excuteQuery
public class JdbcUntils {static {//1.注冊驅動 告訴jdbc我們使用哪一個數據庫廠商的驅動try {Class.forName("com.mysql.jdbc.Driver");} catch (ClassNotFoundException e) {throw new RuntimeException(e);}}//寫一個jdbc 工具類Connection connection = null;PreparedStatement st = null;ResultSet rs = null;//分析：// 當前方法寫完了，發現sql 語句是不是直接傳過來，可以如果 有參數，直接進行sql拼接會產生sql注入風險// 所以，就考慮使用參數化// 將數據，傳過來，傳來后，使用PreparedStatement添加參數public int excuteUpdate(String sql,Object... params) {int result = -1;try {//2. 創建連接connection = getConnection();//3. 創建statement對象//這個里包括了？ ，所以需要參數指定st = connection.prepareStatement(sql);//要把參數加到PreparedStatement對象中//pst.setString(1,username);// pst.setString(2,pwd);for (int i = 0; i < params.length; i++) {st.setObject((i + 1), params[i]);}result = st.executeUpdate();//4. release 釋放資源release();}catch (SQLException e){e.printStackTrace();result = -1;}finally {return result;}}public <T> List<T> excuteQuery(String sql,Class<T> c,Object... prarms){//創建一個集合，存放所有的結果對象List<T> list = new ArrayList<>();try {connection = getConnection();// 3. 獲得執行對象 Statement// 查詢 里的sql語句也可以能有參數st = connection.prepareStatement(sql);//添加參數for (int i = 0; i < prarms.length; i++) {st.setObject((i + 1), prarms[i]);}// 4. 執行sql并獲得結果集(ResultSet)rs = st.executeQuery();// 4.1 得到結果集的元數據ResultSetMetaData ms = rs.getMetaData();//列的數量int colCount = ms.getColumnCount(); // 處理結果while (rs.next()){
// int i = 1;//添加一個 T類的實例T t = c.getDeclaredConstructor().newInstance();// 1. 得到結果集，列名數組//2. 循環列名// 循環體里，根據列名，去找對象的對應的字段 ，然后在進行賦值for(int i=1;i<=colCount;i++){Object value = rs.getObject(i);if(value!=null){//將這對應的值，放到對象對應的字段中String colName = ms.getColumnName(i);//通過反射，設置字段的值//要求結果的列名，與實體對象的屬性（字段名）相同Field field = c.getDeclaredField(colName);// 跳出java的語法檢查 field.setAccessible(true);// 給字段設置對應的值 field.set(t,value);}}list.add(t);//給實例對象的每個屬性，賦值// 方法一： 獲取所有字段進行賦值，這個要求字段與數據的列的順序要求一致
// Field[] Fields = c.getDeclaredFields(); //獲取所有的字段
// for(Field field : Fields){
// //缺點： 實體的字段 與數據查詢 出來的字段要一一對應
// //思路： 如果不對應怎么？
// // 最好，可以得到結果集的列名，根據列名，給對應的字段賦值
//
// // 這里值 ，應該從結果集
// field.set(t,rs.getObject(i++));
// }//T對象加入到list中}// 5. 處理結果集release();}catch (Exception e){e.printStackTrace();list = null;} finally {return list;}}//創建連接public Connection getConnection() throws SQLException {//2.通過驅動管理器獲取一個鏈接Connection connection = (Connection) DriverManager.getConnection("jdbc:mysql://localhost:3306/j352", "root", "");return connection;}//釋放資源public void release(){if(rs!=null){try {rs.close();} catch (SQLException e) {e.printStackTrace();}rs =null; //讓jvm來回收它}if(st!=null){try {st.close();} catch (SQLException e) {e.printStackTrace();}st =null; //讓jvm來回收它}if(connection!=null){try {connection.close();} catch (SQLException e) {e.printStackTrace();}connection =null; //讓jvm來回收它}}}
三、設計原則
1）創建軟件應用程序是為了滿足不斷變化和發展的需求。一個成功的應用程序還應該提供一種簡單的方法來擴展它以滿足不斷變化的期望。如果在設計和開發軟件時應用一組面向對象的設計原則和模式，則可以避免或解決這些常見問題。
2）面向對象的設計原則也被稱為 SOLID 。在設計和開發軟件時可以應用這些原則，以便創建易于維護和開發的程序。
SOLID 原則包括，單一職責原則、開閉原則、里氏替換原則、接口隔離原則和依賴倒置原則。
單一職責原則：每個類只負責做一件事
專業的人做專業的事。每個類只負責做一件事
單一職責原則，其它就是“高內聚”的體現。
每個類只負責做一件事， 對外只提供一個功能，而引起類的變化 的原因應該只有一個。
開閉原則 ： 對擴展開放，對修改關閉
核心思想：一個對象 對擴展開放，對修改關閉
對類的改動是通過增加代碼進行，而不是修改代碼
如何實現？這就需要借助于抽象 和多態。即把可能變化 的內容抽象 出來.
因為抽象的部分是相對穩定
里氏替換原則
子類可以擴展父類的功能，但不能改變父類原有的功能
子類繼承父類時，除添加新的方法完成新增功能外，盡量不要重寫父類的方法。
接口隔離原則
別人不需要的東西不要強加給人家。
接口隔離原則是為了約束接口，降低類對接口的依賴。
接口隔離原則是為了約束接口，降低類對接口的依賴。
接口隔離原則的優點：
1）靈活性，可維護性增強
2）高內聚，低耦合
3）減少代碼冗余（減少了方法的實現）
4）體現對象層次
依賴倒置原則：
依賴于抽象，而不是依賴于具體，依賴注入模式
依賴倒置原則(Dependency Inversion Principle，DIP)是面向對象設計中的一個原則，它是SOLID原則中的一部分。依賴倒置原則的核心思想是:
高層模塊不應該依賴于低層模塊，二者都應該依賴于抽象; 抽象不應該依賴于具體細節，而具體細節應該依賴于抽象。
(依賴于抽象)
簡而言之，依賴倒置原則要求我們通過抽象來解耦高層模塊和低層模塊之間的依賴關系，從而使系統更加靈活、可擴展和易于維護。
核心思路： 要依賴于抽象 ，不要依賴于具體
為了實現這一原則 ，在編程時針對抽象類或者接口編程，而不是具體要求實現
四、設計模式
設計模式是一套反復被使用，經過驗證的，代碼的總結 ；
設計模式不是具體的方法，而一種思想.
學習設計模式就是要建立面向對象的思想，盡可能的面向接口編程，低耦合，高內聚，使程序實現復用
設計模式的幾個要素
- 名字， 必須有一個簡單，有意義的名稱
- 問題 描述在何使用
- 解決方案 如何去解決問題
- 效果 模式優點缺點
設計模式分類：
創建型模式 對象的創建
結構型模式 對象的組成（結構）
行為型模式 對象的行為
創建型模式： 簡單工廠模式， 工廠模式，單例模式等。。。
**結構型模式：**外觀模式，適配器模式，裝飾模式 。。。
**行為型模式：**模板方法模式，觀察者模式，狀態模式。。。
1.常見設計模式
簡單工廠模式
靜態工廠方法模式，它定義一個具體的工廠類負責創建一些類的實例
優點：客戶端不需要負責創建對象，明確了各位類的職責
缺點：靜態工廠負責創建對象，如果有新的對象增加，或者創建方式不同，需要不斷的修改工廠類，不利于后期維護
public class AnimalFoctory {private AnimalFoctory(){}public static Animal createAnimal(String type){if("dog".equals(type)){return new Dog();}else if("cat".equals(type)){return new Cat();}else{return null;}}public static Dog createDog(){return new Dog();}public static Cat createCat(){return new Cat();}
}工廠模式
工廠模式： 抽象工廠類負責定義創建對象的接口，具體對象的創建由繼承抽象工廠的具體類實現
優點：客戶端不需要負責創建對象，明確了各位類的職責 ； 如果 新的對象增加，不修改已有的代碼，增加了維護性和擴展性
缺點：需要額外編寫代碼，增加了工作量
單例模式
單例模式： 確保類在內存中只有一個對象，此實例必須自動創建，并且對外提供
優點：
缺點：
（餓漢式）： 類加載的就創建對象
public class Student {// 為了讓靜態方法可以訪問此對象，所以把它變成靜態的// 為了讓外界不能直接訪問，加privateprivate static Student s = new Student();private Student(){}public static Student getStudent(){return s;}
}
（懶漢式）：用的時候，才去創建
public class Student2 {private static Student2 s = null;private Student2(){}public static Student2 getStudent(){if(s==null){s = new Student2();}return s;}
}
面試題：單例模式的思想是什么？請寫一代碼體現。
? 開發：餓漢式（是不會出現問題的）
? 面試：懶漢式（可能會出現問題的）
? A: 懶加載（延遲加載）
? B: 線程安全問題
public class Student2 {private static Student2 s = null;private Student2(){}public static synchronized Student2 getStudent(){if(s==null){s = new Student2();}return s;}
}
Runtime類
public class Runtime {private static Runtime currentRuntime = new Runtime();public static Runtime getRuntime() {return currentRuntime;}/** Don't let anyone else instantiate this class */private Runtime() {}}
模式設計模式
需求： 計算出一段代碼的運行時間
優點： 滿足用戶需求，靈活多變
缺點：如果算法需要改變，需要修改抽象 類
裝飾設計模式(擴展對象)
優點：
可以提供比繼承更靈活的擴展對象的功能
缺點：可以任意組合
已經學過的裝飾：
Scanner scanner = new Scanner(System.in);
2.枚舉
枚舉是指變量的一一列出來，只能在指范圍內取值;
如： 一周只有7天，一年12個月
 響應式詳解)
-minikube的使用)
![! [remote rejected] master -＞ master (pre-receive hook declined)](http://pic.xiahunao.cn/! [remote rejected] master -＞ master (pre-receive hook declined))
