Java基礎學習筆記
最近在學習大數據，而後就學習了一下java基礎，下邊是基礎筆記：java
java學習筆記：算法
<chp1>
1>java + 類名：執行時不要帶".class"，不然報錯。
2>javac編譯".java"文件時，文件中的類會被分別編譯成對應的"類名.class"
3>類或接口爲public時，必須與文件名同樣，包括大小寫。一個文件只能有一個公開類或接口。編程
<chp2>
1>註釋：注意是javadoc的註釋方式：/** */
2>package包：(必須在文件開始聲明)
①便於對class文件管理，但注意必須與文件目錄一直才行，否知執行報錯
②包能夠防止類名衝突。
③命名原則：與網址相反，abc.com 對應 com.abc.corejava
3>import包：
①當package出現，package存在文件的開始位置，import排在其後。
②import 能夠導入某包內的一級類，如 "import java.util.*"，但注意不會導入其下的子包中的類。
③默認狀況下，已經導入"import java.lang.*",不須要自行導入。
4>java是區分大小寫的
5>命名規範：包、類、方法、變量、常量
①包名：全小寫
②類名：大駱峯
③變量/函數名：小駱峯
④常量：全大寫，單詞間下劃線隔開。HELLO_WORLD
6>數據類型：
①8中基本數據類型
②String類："+"能夠拼接字符串與任何類型，結果都是字符串。
③局部變量：必須先複製後使用，不然編譯報錯。做用域是從聲明開始到該級別代碼塊結束，包括子代碼塊中。
<chp3>
①Scanner
<chp5>
1>數組:
①隱式初始化時，不能指定數據大小，JVM根據實際參數格式分配
②二維數組中支持不規則數組設計模式
<chp6>對象和類
1>成員屬性：能夠在代碼中直接初始化（與C++不一樣），而且不會與方法中的變量衝突。
2>成員方法：
①重載：方法名相同，參數列表不一樣。
②構造函數：和C++同樣，能夠重載構造函數，有默認的無參構造函數。
3>對象建立過程：
①根據類屬性大小，分配內存，設置默認值:bool的爲false,int的爲0
②根據代碼，初始化成員變量。
③調用構造函數。
④引用:與C++同樣做用，只是方式不太同樣，引用傳遞
④this:this()只能在構造函數使用，表示調用本類的其餘構造函數，完成對象的構造
只能用在構造函數的第一句，不然報錯。
注意不能在構造函數中經過this()調用本身，這樣遞歸是有問題的。
<chp7>面向對象的三大特性
1>封裝：
①問修飾符：
private：類內部
public：均可以經過對象訪問
default：類內部，同包範圍內，當繼承的父類是在其餘包中時，子類是沒法訪問defalut的成員變量的。
protected：類內部，同包內部，不一樣包的子類中。
2>繼承：
①extends:
②覆蓋：方法覆蓋對方法的5部分都有要求，訪問修飾符、返回值、函數名、參數列表、異常
③對象建立過程：
->分配空間，賦默認值
->由根至子，依次初始化
->由根至子，依次調用構造函數
調用父類構造函數的時候，默認的調用無參構造函數，
若是須要調用指定的構造函數，使用super(參數列表)調用
注意：在使用super時，必須做爲構造函數的第一句。
覺得值this和super在構造函數中不能共存。
構造函數的第一句，有三種互斥狀況：
①super(參數)
②this(參數)
③前二者都不是，編譯器自動加上super(),即調用父類的無參構造函數。
->super是指向父類的引用，this是指向子類的引用。
->java是單繼承，與C++多繼承不一樣。
3>多態：父類引用引用子類對象，只能調用父類定義的方法，但方法可能被子類重寫，此時調用的就是被重寫的方法。
①instanceof: 對象的引用 instanceof 類，返回值爲bool類型。
②多態的N種方式：
->父類引用 指向子類對象，多是多層繼承關係
->接口引用 指向實現類的對象，多繼承關係多層繼承關係；
->方法多態：重載和覆蓋（能夠super調用父類被覆蓋的方法，從而實現對父類方法的擴充）
<chp8>三個修飾符：static、final、abstract
1>修飾的對象：
①static:屬性，方法，初始化代碼塊；注意其不能修飾局部變量和類。
②final：變量（包括屬性和局部變量（方法參數也是局部變量）），方法，類
③abstract:類，方法
2>含義
①static：
->屬性：靜態成員變量，類變量，是全部對象共有的。相反，非靜態屬性，是實例變量
->方法：非靜態方法，不管屬性和方法是否靜態，都能訪問。
靜態方法，只能訪問靜態屬性和方法.
->初始化代碼塊：初始化代碼塊，就是在類中，方法外的，{}內的代碼塊
靜態代碼塊，在類加載的時候只執行一次；
非靜態代碼塊，在類加載的時候執行屢次。
②final:相似const
->局部變量：一次賦值機會，之後只讀；
->屬性：對象建立完成以前有一次賦值機會，即初始化屬性或者構造函數中；
屬性沒有默認值，因此必須在創建對象以前，完成對屬性的賦值，不然編譯器報錯；
若是未初始化屬性，則全部構造函數都須要實現對其的賦值,注意此時構造函數是不能相互調用的；
注意：由於靜態屬性是在類加載的時候分配空間的，所以static final 屬性只能初始化賦值；
->方法：修飾方法表示子類沒法重寫父類的該方法；
->類：表示該類不能被繼承；
③abstract:相似C++ virtual
->類：表示是抽象類，不能實例化，但能夠申明引用，指向子類對象。即C++中含有純虛函數的類爲抽象類
->方法：表示方法只是聲明，沒有實現，須要子類實現，該類沒法建立對象；
抽象方法必須是在抽象類中，但抽象類不必定含有抽象方法；與C++不太相同
子類繼承抽象類，要麼成爲抽象類，要麼必須實現所有抽象類的抽象方法；
<chp9>接口
1>接口：特殊的抽象類，即：
全部屬性都是public static final修飾
全部方法都是public abstract 修飾
2>聲明方法：interface 接口名
3>注意：
->interface 與符合要求的abstract class相似，但聲明時能夠省略訪問修飾符；
即：屬性 省略public static final
方法 省略public abstract
->類實現接口，使用關鍵詞：implements
->一個類實現接口，若是不但願其爲抽象類，則必須實現所有方法；
->由於接口方法是public的，因此實現類中的實現方法必須使用public修飾；
->接口之間也存在繼承，使用關鍵詞extends;
->接口繼承能夠是多繼承的；
->類是單繼承，接口能夠多繼承，且子類繼承父類，實現接口時，繼承在前，實如今後，不然編譯出錯；數組
4>關於java類的單繼承，接口的多繼承 與 C++類多繼承的思考：
①java類繼承時主要類型，接口是次要類型；
②基類是事物主要共性的抽象，接口是次要共性的抽象；
③單繼承，父子類之間是簡單的樹形結構，及時是接口的多繼承也不會破壞這個樹形關係；
④接口解耦合，其實就是多態。接口就是方法的抽象的集合，是須要實現的標準；
當接口的實現這變化的時候，對接口的使用者不產生影響；
與代理模式極其類似，聲明代理，就是聲明接口，實現代理就是實現接口，從而下降使用者和實現者的耦合關係；
對於項目開發而言，能夠實現多個模塊或者系統的並行開發工做，提升開發效率；
⑤接口回調:實際就是系統庫中，定義接口，調用調用者的實現，從而實現接口的回調。
與C++ stl模板庫中算法中排序，也是這種思想；
⑥泛型：接口調用時，不少是工具類封裝的接口，程序實現接口，可是爲了工具類的擴張性，
以Comparable接口爲例，接口定義的是泛型型的，實現是須要類型化
與C++的模板庫中的模板思想是一致的；安全
<chp10>Object物種起源服務器
1>finalize:JVM垃圾回收時調用，SUM的垃圾回收是內存不足是回收垃圾
因此，釋放資源，最好調用System.gc()方法，但也不是立刻釋放資源，只是通知垃圾回收機制須要釋放資源了。
2>getClass:與instanceof相似，不一樣在於前者能夠精確判斷引用的真是類型，後者只能判斷引用是不是某個類的實例，不能精確判斷是那個類的實例，由於後者在判斷是父類的實例時也返回true
3>equals:注意與"=="的區別，前者是比較引用對象的值是否相等，後者是比較引用對象的地址是否相等；
自定義類時，若是用到equals方法，則須要覆蓋父類的equals方法：
覆蓋equals的五個步驟：
①判斷 this == obj
②判斷 obj == null
③判斷兩個對象的實際類型（getClass）
④強制類型轉換
⑤判斷兩個對象的屬性是否都相等
4>toString:相似OC的description；
5>封裝類：Object類型的引用能夠指向任意類型的對象，可是在指向基本數據類型的時候力不從心，
因此，Sun封裝了八大包裝類，實現Object類對八大基本基本數據類型的引用；
6>數據類型轉換：①字符串，②包裝類，③基本數據類型
①<->②：前者直接調用包裝類的構造方法；後者調用toString方法
①<->③：前者是對應調用Integer.parseInt(str)；後者調用：""+數據 或者調用靜態方法String.valuesOf(數據)；
②<->③：前者調用構函數；後者相似intValues()方法便可；
7>自動封箱和拆箱：JDK5後新增特性，能夠隱式實現包裝類和基本數據類型的裝換,實際上是編譯器處理過，底層實現仍是同樣的
如：int i = myInteger; myInt++;
目的是更加方便的操做基本數據類型和包裝類。
8>四種內部類：和C++的內部類基本相似,實用性不強，暫時不看網絡
<11>集合框架：相似C++ STL
1>系統接口
①Collection:數據是object類型
->List:有序
->Set:無序，惟一
->SortedSet：有序，惟一
②Map:數據是鍵值對類型
->Map:鍵不能重複
->SortedMap:鍵對象按照排序規則，自動排序
2>詳細方法介紹：
①Collection接口:
->add
->contains
->isEmpty
->iterator 迭代器
->remove
->clear
->size
②List接口：
->add(Object),add(index,Object) :前者是繼承，後者是新增
->get(index),set(index,element):前者是得到
->indexof(Object):查找對象
->實現List接口的的類：注意泛型，就是模板思想
①ArrayList：底層實現線性表，查找快，增刪慢
②LinkedList：底層實現是鏈表，增刪快，查找慢
③Vector：底層實現線性表，與ArrayList相似，但線程安全
③Set接口：
->add(Object)
->實現Set接口的類：
①HashSet:自定義類時，須要重寫覆蓋父類的equals和hashCode方法，不然沒法知足Set特性；
由於HashSet的特性是，首先判斷其hashCode的值是否相同，若是相同，再調用equals判斷；
若是不重寫equals和hashCode方法，則會調用父類的該方法；
->SortedSet接口：元素不重複，而且通過排序
->實現SortedSet接口的類：TreeSet，該類中存放的對象都必須實現Comparable接口；
②Map接口:
->Object get(Object key)
->put(Object key,Object value);若是鍵值不存在則插入，若是存在則更新其值
->remove(Object key)
->Set keySet();得到key的集合
->Collection values();得到全部值value的集合，由於可能重複，不能是Set.
->containsKey/containsValue
->size;鍵的個數
->isEmpty;
->clear
->entaySet
->Map的實現類：
①HashMap:鍵值對中的key必須重寫equals,hashCode方法，線程不安全，null能夠做爲鍵/值;
②LinkedHashMap：能夠保證放入鍵值的順序
③HashTable：線程安全，null做爲鍵/值時拋出異常
->Map.Entry是Map的內部接口
->SortedMap子接口：有序
->實現類是TreeMap:意味着放入的對象必須實了Comparable接口；
3>foreach遍歷集合:
for(Object obj : set){
System.out.println(obj);
}
4>泛型：就是C++模板思想，泛型不能多態；多線程
<shp12>異常處理：程序的白衣天使
1>異常分類：
Throwable類:全部錯誤的父類
|-Error:嚴重底層錯誤，沒法處理
|-Exception:異常，異常處理的主要對象
|-RuntimeException:未檢查異常，能夠避免，可選擇處理,編譯能夠經過。
|-非RuntimeException：沒法避免的異常，必須處理，不然編譯不經過
2>拋出異常後，異常對象會沿着方法調用鏈反向傳遞。當異常都沒有處理，拋給你了虛擬機，則虛擬機只能中止當前程序。
3>捕獲異常：try{可能不是所有代碼都執行} catch(){異常處理} finally{必定執行的代碼，主要是釋放資源，事務處理}框架
<shp13>多線程 2種方式：
1>繼承Thread類,注意Thread類不是抽象類，重寫run()方法，使用start啓動線程！
2>實現Runnable接口，實現run()方法，使用run啓動線程
3>線程狀態。阻塞：sleep()，join()
4>同步和互斥。
①synchronized(lock){}同步代碼塊與synchronized訪問修飾符，實現互斥資源的互斥訪問
②wait,signalAll();實現同步；
<shp14>I/O框架
1>File類：表示文件和文件夾
2>字節流：
1> 抽象類 其子類 構造函數 其餘
InputStream： FileInputStream String filename;File file; close;read
OutputStream： FileOutputStream String filename;File file; close;write
2>字節過濾流：
->加強讀寫八種基本數據類型和String
DataInputStream: readInt等
DataOutputStream: writeInt等
使用步驟：①建立節點流，②封裝過濾流，③讀寫數據，④關閉外層流（內存流自動關閉）
->提升I/O的讀寫效率：注意①緩衝區滿 ②調用close ③flush方法 會清空緩衝區，完成讀寫
BufferedOutputStream:
BufferedIntputStream:
->加強基本數據類型，String,緩衝區功能，對象的讀寫,對象序列化：
ObjectInputStream: readObject();
ObjectOutputStream: writeOject();
注意：實現了java.io.Serializable接口的對象才能序列化。當屬性被transient修飾時，纔不參與序列化。
4>字符流：
1> 抽象類 其子類 橋轉換（字節流轉爲字符流）
Reader: FileReader, InputStreamReader
Writer: FileWriter, OutputStreamWriter
2>字符過濾流： 方法
->BufferReader: String readLine()
->PrintWriter:
<chp15>網絡編程
1>TCP ：ServerSocket Socket getInputStream 橋轉換和過濾流，使用BufferedReader和PrintWriter進行IO操做
1>TCP服務器端：
①建立ServerSocket對象,綁定端口
②調用accept,等待請求
③調用getXXXStream，io
④關閉socket
2>TCP客戶端：
①建立socket對象，鏈接服務器
②調用getXXXStream方法，IO
③關閉Socket;
2>UDP:DatagramSocket DatagramPacket進行IO的操做
1>UDP服務器：
2>UDP客戶端：
3>URL:
URL url = new URL("http://www.sina.com.cn");
URLConnection conn = url.openConnection();
InputStream in = conn.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(in));
<shp16反射>
1>class：泛型，Class<?>
1>類對象獲取方式：
①類名.class;
②對象.getClass();
③Class.forName();
2>類名和接口名的獲取：
①getName();
②getSimpleName();
③getSuperclass().getName()
④getInterfaces();
2>方法：Method
1>獲取方法：
①getMethods:獲取全部的該類和從父類繼承的非private修飾的方法數組
②getDeclaredMethods:獲取該類中申明的全部方法的數組，不包括從父類中繼承的。
③getMethod(方法名,參數類對象數組):由於存在重載，因此須要參數類對象數組，方法的範圍同上描述
③getDeclaredMethod(方法名,參數類對象數組):由於存在重載，因此須要參數類對象數組，方法的範圍同上描述
2>獲取方法名：
①getName:獲取方法名，不包括包名
②toString:獲取方法的簽名
2>使用方法：
invoke(對象,參數列表Object數組)：方法、對象、參數值
3>屬性：Field
1>獲取屬性：
①getField(String):獲取類的對象及從父類繼承的非private屬性
②getDeclaredField(String)：獲取類的對象全部屬性，不包括繼承的；
2>操做屬性：
①Get:直接得到便可
②Set:對於私有屬性，使用以前設置setAccessible(true)，才能對其屬性賦值；
4>構造函數：Constructor
1>獲取構造函數：
Constructor con = c.getConstructor(new Class[]{String.class,int.class});
2>使用構造函數：
①con.newInstance(new Object[]{"Cz",new Integer(28)});
②c.newInstance();//無參構造函數
5>應用；
String className = "Student";
Class<?> c = Class.forName(className);
Object o = c.newInstance();
//注意className，必須是完整的類名，包括包名；
String methodName = "study";
Method m = c.getDeclaredMethod(methodName,new Class[]{});
m.invoke(o,new Object[]{});
將類名和方法字符串化，實現代碼的複用，多態的體現。和OC中經過方法名或者屬性名操做對象相似。
反射是底層操做，雖與封裝思想相違背，但它是底層的操做，能夠提升代碼重用，多用於工具和框架；
反射不足：效率較低，比較複雜，不易調試；
<chp17>OOAD:面向對象的分析與設計
1>設計模式：
①單例：
public class Singleton{
private Singleton (){}
private static Singleton instance = new Singleton();
public static Singleton getInstance(){
return instance;
}
}
②簡單工廠模式
2>數據分3層：經過反射機制，實現修改配置文件，便可修改系統的三層中的處理方式。
①DAO:
②BO(biz):
③VO:
最後一個簡單的三層代碼：
接口部分：
1 package dao; 2 3 public interface Dao{ 4 String getData(); 5 }
1 package biz; 2 import dao.Dao; 3 4 public interface Biz{ 5 void setDao(Dao dao); 6 String dealData(); 7 }
1 package view; 2 import biz.Biz; 3 4 public interface View{ 5 void setBiz(Biz biz); 6 void showData(); 7 }
實現類：
1 package dao; 2 //放在同一個報下 3 //import dao.Dao; 4 import java.io.*; 5 6 7 public class FileDaoImpl implements Dao{ 8 public String getData(){ 9 String data = ""; 10 BufferedReader br = null; 11 String tmp = ""; 12 try { 13 br = new BufferedReader(new FileReader("test.txt")); 14 while((tmp = br.readLine()) != null) 15 { 16 //System.out.println(tmp); 17 //System.out.println(data); 18 data += tmp; 19 data += '\n'; 20 } 21 } catch (IOException e) { 22 e.printStackTrace(); 23 }finally { 24 if(br != null){ 25 try { 26 br.close(); 27 } catch (IOException e) { 28 e.printStackTrace(); 29 } 30 } 31 } 32 33 return data; 34 } 35 }
1 package dao; 2 //放在同一個報下 3 //import dao.Dao; 4 import java.io.*; 5 import java.net.*; 6 7 8 public class NetDaoImpl implements Dao{ 9 public String getData() { 10 String data = null,tmp = null; 11 URL url = null; 12 URLConnection conn =null; 13 InputStream in = null; 14 BufferedReader br = null; 15 16 try { 17 url = new URL("http://www.sina.com.cn"); 18 conn = url.openConnection(); 19 in = conn.getInputStream(); 20 br = new BufferedReader(new InputStreamReader(in)); 21 String line = null; 22 23 while((tmp = br.readLine()) != null){ 24 data += tmp; 25 } 26 } catch (Exception e) { 27 e.printStackTrace(); 28 } 29 finally { 30 try { 31 if(br != null){ 32 br.close(); 33 } 34 } catch (Exception e) { 35 e.printStackTrace(); 36 } 37 38 return data; 39 } 40 41 42 43 } 44 }
1 package biz; 2 import dao.Dao; 3 4 public class UpperCaseBizImpl implements Biz{ 5 private Dao dao; 6 7 public String dealData(){ 8 String data = dao.getData(); 9 if (data != null) { 10 data = data.toUpperCase(); 11 } 12 return data; 13 } 14 public void setDao(Dao dao){ 15 this.dao = dao; 16 } 17 }
1 package biz; 2 import dao.Dao; 3 4 public class LowerCaseBizImpl implements Biz{ 5 private Dao dao; 6 7 public String dealData(){ 8 String data = dao.getData(); 9 if (data != null) { 10 data = data.toLowerCase(); 11 } 12 return data; 13 } 14 public void setDao(Dao dao){ 15 this.dao = dao; 16 } 17 }
1 package view; 2 import biz.Biz; 3 4 public class TextView implements View{ 5 private Biz biz; 6 7 public void setBiz(Biz biz){ 8 this.biz = biz; 9 } 10 public void showData(){ 11 System.out.println( biz.dealData()); 12 } 13 }
工廠類：
1 package simplefactory; 2 import dao.*; 3 import biz.*; 4 import view.*; 5 import java.util.Properties; 6 import java.io.*; 7 8 //單例模式 9 public class SimpleFactory{ 10 { 11 props = new Properties(); 12 InputStream is = null; 13 try { 14 is = new FileInputStream("conf.props"); 15 props.load(is); 16 } catch (IOException e) { 17 e.printStackTrace(); 18 } 19 finally { 20 if(is != null){ 21 try { 22 is.close(); 23 } catch (Exception e) { 24 e.printStackTrace(); 25 } 26 } 27 } 28 } 29 private static Properties props; 30 private SimpleFactory (){} 31 private static SimpleFactory instance = new SimpleFactory(); 32 public static SimpleFactory getInstance(){ 33 return instance; 34 } 35 public static Object createObject(String name){ 36 Object obj = null; 37 String objName = props.getProperty(name); 38 try { 39 Class c = Class.forName(objName); 40 obj = c.newInstance(); 41 } catch (Exception e) { 42 e.printStackTrace(); 43 } 44 return obj; 45 } 46 } 47 48 /* 49 public class SimpleFactory{ 50 private Properties props; 51 52 public SimpleFactory(){ 53 props = new Properties(); 54 InputStream is = null; 55 try { 56 is = new FileInputStream("conf.props"); 57 props.load(is); 58 } catch (IOException e) { 59 e.printStackTrace(); 60 } 61 finally { 62 if(is != null){ 63 try { 64 is.close(); 65 } catch (Exception e) { 66 e.printStackTrace(); 67 } 68 } 69 } 70 } 71 public static Dao createDao(){ 72 return new FileDaoImpl(); 73 } 74 public static Biz createBiz(){ 75 //return new UpperCaseBizImpl(); 76 return new LowerCaseBizImpl(); 77 } 78 public static View createView(){ 79 return new TextView(); 80 } 81 public Object createObject(String name){ 82 Object obj = null; 83 String objName = props.getProperty(name); 84 try { 85 Class c = Class.forName(objName); 86 obj = c.newInstance(); 87 } catch (Exception e) { 88 e.printStackTrace(); 89 } 90 return obj; 91 } 92 } 93 */
測試類：
1 package test; 2 import dao.*; 3 import biz.*; 4 import view.*; 5 import simplefactory.SimpleFactory; 6 7 public class TestMain { 8 public static void main(String [] args){ 9 Dao dao = (Dao)SimpleFactory.createObject("dao"); 10 Biz biz = (Biz)SimpleFactory.createObject("biz"); 11 biz.setDao(dao); 12 //View view = (View)SimpleFactory.createObject("view.TextView"); 13 View view = (View)SimpleFactory.createObject("view"); 14 view.setBiz(biz); 15 16 view.showData(); 17 } 18 }
編譯的時候，我使用的dos命令javac命令，注意加"-d ."，編譯器自動在當前目錄下建立包名對應的文件夾，並將類文件放入其中。
配置文件：
dao=dao.NetDaoImpl biz=biz.LowerCaseBizImpl view=view.TextView
- 1. Java基礎學習筆記
- 2. JAVA基礎學習筆記
- 3. Java 基礎學習(筆記)
- 4. java基礎學習筆記
- 5. Java 學習筆記 java 基礎複習
- 6. Java學習筆記：java基礎語法
- 7. java學習筆記--java基礎
- 8. Java學習筆記-Java基礎26（servlet）
- 9. Java學習筆記-Java基礎1
- 10. Java學習筆記-Java基礎29（ajax）
- 更多相關文章...
- • Kotlin 基礎語法 - Kotlin 教程
- • Scala 基礎語法 - Scala教程
- • Tomcat學習筆記（史上最全tomcat學習筆記）
- • Kotlin學習（二）基本類型
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Java基礎學習筆記
- 2. JAVA基礎學習筆記
- 3. Java 基礎學習(筆記)
- 4. java基礎學習筆記
- 5. Java 學習筆記 java 基礎複習
- 6. Java學習筆記：java基礎語法
- 7. java學習筆記--java基礎
- 8. Java學習筆記-Java基礎26（servlet）
- 9. Java學習筆記-Java基礎1
- 10. Java學習筆記-Java基礎29（ajax）