JavaSE入門

Day1:======================================================================================

上課時間：
09:15-11:45
13:30-17:45
18:30-21:00

java環境變量：
JAVA_HOME:新建一個jdk路徑。
Path:修改，直接運行的程序對應的路徑
%JAVA_HOME%\bin;

主方法：
public class 類名稱{
public static void main(String[] args){

}
}

Day2:======================================================================================

變量命名規則：
首字符：字母/_/$
其餘：字母/_/$/數字
小駝峯規則
不能使用保留字(class,void...)
類命名規則：
大駝峯規則

數據類型：
基本類型：
整型：
byte： 字節型，1字節，-128~127，-2^7~2^7-1
short：短整型，2字節，-32768~32767，-2^15~2^15-1
int： 整 型，4字節，-2148473648~2148473647，-2^31~2^31-1 （經常使用）
long： 長整型，8字節，，-2^63~2^63-1
字面量：3:int
3l或3L:long
字符型：也歸於整型
char：2字節，單引號括號，unicode16編碼存儲的碼值
//char c='我';
//char c1='A';
//char c2=65;
浮點型：
float：4字節 精度7-8位
double：8字節 精度15位
字面量：1.2:double
1.2f或1.2F:float
布爾類型：
boolean；1字節，true/false

引用類型：
數組
對象

轉義字符：
System.out.println("\n");//換號
System.out.println("\t");//tab
System.out.println("\"");//雙引號
System.out.println("\\");//斜槓

類型轉換：
把幾個數值型排序:
byte,short,char < int < long < float < double

//調用鍵盤輸入交互：
import java.util.Scanner;//引入Scannerd的方法
Scanner input=new Scanner(System.in);//建立一個引用對象
int num1=input.nextInt();//聲明一個變量，調用input的方法輸入

Day3:======================================================================================

算數雲算符：
num++: 先備份 再自增
++num: 先自增 再備份
語句中取的是備份值

關係運算符：
>,>=,<,<=,==,!=
結果是boolean
只能比較兩個數的關係

邏輯運算符：
&&: 與，而且，二者都成立，結果爲true，否者爲false
||: 或，或者，一個成立，結果爲true，否者爲false
!: 非，取反
&,|,^

位運算符；（瞭解）
二進制
3<<1, 右移1位，數值等於*2
00000011,3
00000110,6

三目運算符：表達式?成立執行這：不成立執行這;

Day4:======================================================================================

條件結構：
if-else
switch-case

if-else:
若是if或else中的代碼只有一行，{}能夠省略，但不建議省略

任何狀況均可以使用，判斷點值，段值均可以

switch(表達式){
case 常量1:
代碼;
break;
case 常量2:
代碼;
break;
......
default:
代碼;
}

if-else vs switch-case:
if-else：任何狀況均可以使用，判斷點值，段值均可以
switch-case:判斷點值，整型，字符串，枚舉

對於點值，分支比較多時，建議使用switch-case
switch-case: 表達式只要計算一次，
if-else:每一個條件都要計算一次，分支越多效率比switch-case越低

字符串補充：
輸入字符串：input.next();
輸入字符：沒有直接方法
方式1：能夠輸入字符串，獲得字符串類型
input.next();
String s1 = input.next();
方式2：能夠輸入字符串，獲取第一個字符 ,獲得字符類型
input.next().charAt(0)
char c1 = input.next().charAt(0);

字符串判斷:equals()
eg:s1.equals("字符串")

//a的b次方
Math.pow(a,b),結果是double類型

//開平方：
Math.sqrt(),結果是double類型

//求隨機數
Math.random(),結果是double類型,範圍是[0~1)
//產生1~9之間的隨機整數 0~8 再+1
System.out.println((int)(Math.random()*9)+1);
//a~b -> 0~b-a -> Math.random()*(b-a+1) -> Math.random()*(b-a+1)+a
//2-8
System.out.println((int)(Math.random()*(8-2+1)+2));

//1-7
System.out.println((int)(Math.random()*7)+1);
System.out.println((int)(Math.random()*7-1+1)+1);

//2-7
System.out.println((int)(Math.random()*6)+2);
System.out.println((int)(Math.random()*7-2+1)+1);

Day5:======================================================================================

循環：
while
do-while
for

while循環語法：
while(條件表達式){
循環體;
每次要作的事情;
}
判斷成立執行循環體，最小可能執行次數：0次

Day6:======================================================================================

do while循環語法：
do{
循環體;
每次要作的事情;
}while(條件表達式);
先執行循環體再判斷，最小可能執行次數：1次

for循環
for(循環變量初始化;條件表達式;循環變量改變){
循環體;
每次要作的事情;
}

break,continue關鍵字
break:
1)用在switch中，表示結束switch結構
2)用在循環中，表示結束循環，
通常會結合條件來一塊兒使用
continue：
用在循環中，表示提早結束本次循環，進入下一次循環

Day7:======================================================================================

數組；
1,聲明數組：肯定元素類型
1)元素類型[] 數組名；
//eg: int [] array;
1)元素類型 數組名[]；
//eg: array [];

2,創造數組對象
數組變量名=new 元素類型[數組長度];
//eg: array=new int[5]

--聲明並初始化：
//eg: int[] array = new int[5];

3,使用數組
元素的索引：
範圍:0~長度-1
賦值:
數組名[索引]=值；
獲取值:
數組名[索引]；
數組長度：
數組名.length，不可改變，建立時肯定了

4,數組聲明後沒有賦值，元素有默認值：
基本類型：
數值型：默認值是0
Boolean：默認是false
引用類型：默認值是null

5，靜態語法
1)元素類型[] 數組名 = {值1,值2,...,值n};
//eg: int[] array = {1,3,5,4,5,7};

2)元素類型[] 數組名 = new 元素類型[]{值1,值2,...,值n}};
//eg: int[] array = new int[]{1,3,5,4,5,7};

注意：長度有實際賦值的元素個數決定

Day8:======================================================================================

方法：包含多行代碼
能夠反覆使用同一個方法

方法的定義：
修飾符 返回值類型 方法名(形參列表){
方法體,寫具體的代碼
}

修飾符：暫時寫public static
返回值類型：若是方法須要返回值，返回值要和返回值類型匹配
若是方法沒有返回值，返回值類型寫void
經過return 表達式返回結果;
一個方法執行到return就結束了

方法名：和變量名命名同樣，使用方法經過方法名
形參列表：用來接收調用者傳過來的值,
至關於聲明變量，多個變量用逗號隔開，值在調用方法時賦值，不須要擔憂初始化問題
若是不須要接收值，就不須要形參，()要有
eg:method1(int num)
method1(int num1,int num2)
method1(int num1,double d)

方法的調用：
在同一個類中，對於public static修飾的方法
經過 方法名(實參);
若是方法有返回值，要接收返回值 變量=方法名(實參);

Day9:======================================================================================

Arrays.sort();
Arrays.toString();
Arrays.binarySearch()

方法的定義：
修飾符 返回值類型 方法名(形參列表){
//方法體
}

修飾符：暫時寫public static
返回值類型：
方法返回結果的類型，若是方法沒有返回值，返回值類型寫void
經過return 表達式; 返回結果
方法執行到return結束

若是方法返回值類型是void,也可使用return;表示結束方法

二維數組：
1)聲明二維數組引用變量
元素類型[][] 二維數組變量名;
eg:int[][] array;

2)建立二維數組對象
二維數組變量名 = new 元素類型[二維數組長度][];
eg:array = new int[3][];
二維長度：二維數組變量名.length

每一個元素默認值是：null,沒有保存任何一維數組對象的地址

3)給二維數組對象賦值，賦一維數組對象的地址
二維數組變量名[下標]
eg：array[0] = new int[2];
獲取一維數組的長度：二維數組變量名[下標].length
eg:array[0].length

4)經過二維數組對象使用每一個一維數組中的每一個元素
二維數組變量名[第幾個一維數組的索引][一維數組中第幾個元素索引]
eg:array[0][0]

動態語法2：若是每一個一維數組長度相等,差異體如今第2步
1)聲明二維數組引用變量
元素類型[][] 二維數組變量名;
eg:int[][] array;

2)建立二維數組對象和一維數組對象
二維數組變量名 = new 元素類型[二維數組長度][一維數組長度];
eg:array = new int[3][2];
二維長度是3，3個一維數組，長度都是2

二維長度：二維數組變量名.length

3)經過二維數組對象使用每一個一維數組中的每一個元素
二維數組變量名[第幾個一維數組的索引][一維數組中第幾個元素索引]
eg:array[0][0]

靜態語法：若是每一個值都已知
能夠聲明，建立，賦值一步到位
元素類型[][] 二維數組變量名 = {{每一個一維中的值},{每一個一維中的值},...,{每一個一維中的值}};

eg:int[][] array = {{1,2},{3,4,5},{6,7,8,9}};
二維長度3：
一維：2 1,2
一維：3 3,4,5
一維：4 6,7,8,9


Day10:======================================================================================

OOP：Object Orientied Programming

面向對象編程：一週左右，知識點連續度高度，難點，重點
1.基本類，對象，對象使用
2.類的三大特性：（抽象），封裝，繼承，多態
3.抽象類
4.接口

類語法：
public class 類名{
屬性;

方法;
}
對象語法：
1.對象的建立
1)聲明一個引用變量,可以保持對應類型的對象地址,使用對象
類名 引用變量名;
2)建立對象
引用變量名 = new 類名();
1)2)能夠同時完成

2.對象屬性的使用
對象引用變量.屬性名
賦值，獲取值

3.對象方法的使用

局部變量做用域(生命週期):從聲明開始，到聲明所在的最小{}結束

對象生命週期：從建立開始，到沒有引用指向它
若是沒有引用指向對象，對象變成垃圾，JVM後面隨時可能釋放它的空間

屬性：若是不賦值，有默認值

Day11:======================================================================================

OOP三大特性之一（封裝，繼承，多態）

封裝:

把信息封裝造成一個總體
1）把屬性，方法放到類中
2）信息的隱藏
屬性的隱藏(經過private修飾)
方法實現細節的隱藏(調用者無需關注方法的實現細節，知道做用，能執行便可)

包：package
一個工程下的類：默認直接放到src下

建立包，
包名：一般以公司的域名倒置做爲前綴，加具體功能等，以.隔開一級一級的
eg:com.hwua.view:界面類
com.hwua.dao:數據庫訪問類,對數據庫增刪改查的

定義的類：要加上所在包聲明
package 包名;
必須在有效代碼的第一行
導包：eg:工程下/bin/com/hwua/homework

構造方法：
在建立對象時調用，完成對象的初始化
定義語法：
1）沒有返回值類型
2）方法名和類名同名

this關鍵字
引用，表明當前對象的引用，

* 封裝的標準版本：
* 屬性私有化，方法公開化，
* 提供get,set方法，建議都提供，暫時也能夠按照需求提供
* 形參和屬性同名的區分：this
* 構造方法根據需求來寫

屬性賦值：總結
若是屬性可見，能夠直接賦值
若是屬性不可見，能夠經過set方法賦值
還能夠在建立對象時，直接初始化，利用構造方法

類中給屬性賦值：3個地方
1)屬性申明時：
private String name = "小白";
2)代碼塊：
{
name = "小黃";
}
3)構造方法：
public Cat(String name){
this.name = name;
}

方法重載(overload):
同類中方法名相同，形參不一樣

Day12:======================================================================================

static關鍵字
修飾屬性(靜態屬性)，方法(靜態方法)，代碼塊(靜態代碼塊)
當類被加載時候存在，都屬於這個類的

靜態屬性：只有一份，被你們共享的,
使用：類名.靜態屬性名
靜態方法
使用：類名.靜態方法(實參)

類內部，靜態的不能夠直接使用非靜態的

靜態代碼塊：
static{}，在類加載時，執行，只會執行一次

設計模式：單例模式，利用static完成：
public class Test {
private static Test test=new Test();
private Test() {
}
public static Test getTest() {
return test;
}
}
public class Test {
private static Test test=null;
private Test() {
}
public static Test getTest() {
if(test==null){
test=new Test();
}
return test;
}
}

Day13:======================================================================================


繼承:
public class B extends A{
//增長新的屬性，方法
//對繼承來的方法作修改--方法的重寫
}

方法重寫(override):
子類方法不能使用比被重寫方法更嚴格的訪問權限。
父類中的私有方法不能被重寫

super:
表明的是父類對象的引用（當子類和父類有一樣的方法，默認調用子類方法）


final:
1)寫在變量前，變量變成了常量，不可修改
2)寫在方法前，方法不能被子類重寫
3)寫在類前，此類不能被繼承

代碼調試(debug)：跟蹤代碼
對於語法錯誤：修改語法便可
對於數組下標越界等異常：根據提示找到位置，重點看運行異常信息
對於邏輯上的問題：能夠經過debug方式來跟蹤代碼，找到問題

控制按鈕：
step into:F5, 執行一行，若是這一行有方法調用，繼續調整到方法中一行一行控制走
step over:F6
執行一行，若是這一行有方法調用，快速執行完，不須要一行一行控制
step return:F7，快速執行到return
F8:快速執行到下一個斷點

類名 引用變量名 = new 構造方法();
Person
| |
Student Teacher

Student stu = new Student();//√
父類引用能夠指向子類對象，只能調用父類中存在的方法
1)編譯階段：根據引用變量的類型來肯定是否存在這個方法
2)運行階段：根據對象的類型來肯定調用哪一個方法
總結：編譯看引用，運行看對象

Day14:======================================================================================

向上轉型: Person stu = new Student()
向下轉型: Person stu = new Student()
不安全，經過instanceof來預判一下：
子類類型引用 = (子類類型)父類引用;

instanceof:
引用 instanceof 類名：返回布爾值
true：引用所指向的對象是這個類或它的後代
false:引用所指向的對象不是這個類或它的後代
做用:在運行時，判斷對象是不是某一類型

object經常使用的方法重寫：
toString()；打印輸出時能夠省略不寫
equals()：返回boolean；
重寫時，一般有必要同時重寫 hashCode 方法
eclipse 系統自動生成

int hashCode()
返回該對象的哈希碼值。

Class<?> getClass()
返回此 Object 的運行時類。

String方法：
.charAt(int index):查找對應索引的字符
.indexOf():查找字符所在的索引
.lastIndexOf():從最後開始查找字符所在的索引
.compareTo(String array):對比數組的大小，一個一個字符的的數字比較
.concat(String array):在後面拼接數組
.contains():查找是否有這樣的字符
.endsWith():判斷是否以這個字符結尾，返回boolean
.startsWith():判斷是否以這個字符結尾，返回boolean
.equals()：比較兩個字符的值是否同樣
.replace(,):新字符替換就字符
.split(""):經過字符把拆分紅多個字符串的數組
.toUpperCase():轉大寫
.toLowCase():轉小寫
.trim():取掉收尾空格部分

Day15:======================================================================================

抽象類：
abstract:抽象的
修飾方法：抽象方法，只有方法的聲明，沒有實現
有些方法，只是爲了被繼承重寫，自身的實現沒有意義，能夠聲明爲抽象方法

修飾類：
包含抽象方法的類被必須聲明爲抽象類
抽象類能夠沒有抽象方法
和普通類的不一樣：
抽象類不能被實例化
普通類繼承抽象類，必須實現抽象方法(方法的重寫)
做用：用來被繼承，交給子類去實現，多態

靜態方法是否能夠是抽象的？
--不能夠，靜態方法不存在重寫
私有方法是否能夠是抽象的？
--不能夠，私有方法只在當前類內部可見，沒法在子類中重寫


接口：interface
java繼承：單繼承，只能繼承一個父類
接口彌補了單繼承

接口和類並列：
接口組成：
jdk1.7及之前版本：接口中只能包含靜態常量，抽象方法
類能夠實現接口，類只能繼承一個父類，同時實現多個接口

語法：
定義一個接口：
public interface 接口名{
靜態常量;
抽象方法;
}
類能夠實現接口：
public class 類名 implements 接口名{
對接口中的方法作實現
}

接口的引用能夠指向實現類對象
編譯看引用，運行看對象

接口中語法細節強調：
靜態常量能夠縮寫：類型 變量名=值;
eg：public static final int NUM = 3;
-- int NUM = 3;//等價

方法也能夠縮寫：
eg：public abstract void swim();
-- void swim();

接口中的靜態常量，方法都是公開的

Day16:======================================================================================

異常分類：
1）按照繼承關係
Throwable
| |
Error Exception
| |
RuntimeException 其餘子類

RuntimeException:
運行時異常，基本爲代碼邏輯問題
好比：ArrayIndexOutOfBoundsException:下標問題致使的，修改代碼
NullPointerException:引用爲空
ClassCastException:利用instanceof先判斷一下

Exception其餘子類：外界因素致使的問題
必須經過異常機制來處理，不然編譯沒法經過

2)按照是否必須經過異常機制來處理分類
必須經過異常機制來處理(受查異常)：不然編譯沒法經過
Exception類以及除了RuntimeExcepteion的其餘子類
不須要經過異常機制來處理(非受查異常):
Error,RuntimeException

異常的處理：
經過異常機制來解決問題對應的處理手段
方式1：捕獲異常 try,catch,finally
方式2：繼續拋出異常 throws,throw

語法1：try-catch
try{
監視可能會出現異常的代碼
}catch(異常類 變量名){
捕獲到異常後的處理代碼
}
-----------------------------------
Date類: 包java.util.Date;
Date date = new Date();

SimpleDateFormat類: 包java.text.SimpleDateFormat;
建立SimpleDateFormat時，要指定時間對應的格式模式字符串

Date date = new Date();
SimpleDateFormat dates = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
dates.format(date);

Day17:======================================================================================

語法2：try-catch-catch
try{
監聽的代碼
}catch(異常類型 變量名){
異常的處理
}catch(異常類型 變量名){
異常的處理
}...

匹配的時候從前到後，若是一個能處理，後面catch就再也不執行
注意：可能出現父子類型， 先子後父

語法3：try-catch-finally

try{
監聽的代碼
}catch(異常類型 變量名){
異常的處理
}finally{
必定會執行的代碼;
作一些收尾工做
}

finally:必定會執行的代碼,包括前面有return
System.exit(0):特殊，直接退出程序，不會再執行finally
語法4：
try{
監視代碼;
}finally{
即便出了任何異常問題，也會執行到的代碼
}

異常處理方式2：向上拋出
對於受查異常，若是當前方法不處理，要繼續向上拋出，必須在方法上添加拋出聲明
語法：throws 異常類名
public void test() throws IOException{

throw new Exception其餘子類();

}

表示這個方法可能會出現IO異常，本身不處理，拋給調用者
繼承父類，起一個合理的類名，把父類的各類形式的構造方法都添加一份便可

接口--jdk1.8新特性

接口中也能夠包含實現的方法，須要加default關鍵字(總接口已添加，就能直接條用了)
也能夠包含靜態方法

自動裝箱與拆箱
基本類型：變量直接存儲值
引用類型：變量存儲的對象的地址(引用)

java中，每一個基本類型都有一個對應的類(包裝類)
byte short char int long float double boolean
Byte Short Character Integer Long Float Double Boolean

jdk1.5新特性：

自動裝箱與拆箱
自動裝箱：可以自動把基本類型轉換成對應的包裝類類型
Integer integer3 = 3;
//等價於：Integer integer3 = new Integer(3);

自動拆箱：可以自動把包裝類類轉換成對應的基本類型
int num3 = integer3;
//等價於：int num3 = integer3.intValue();

注意：實參給形參賦值，也同樣，自動裝箱與拆箱
返回值接收，也同樣，自動裝箱與拆箱

對於-128~127，常量池中包含了這些對象，一個值對應的對象只有一份
Integer i1 = 1;
Integer i2 = 1;
System.out.println(i1==i2); //true
Integer i3 = 128;
Integer i4 = 128;
System.out.println(i3==i4); //false

泛型：
編寫類通常不會涉及到泛型編程，應用的類內部可能使用了泛型

public class MyData<E>{
private E num;

public void setNum(E num){
this.num = num;
}
}

建立對象時，指定泛型類型，只能是引用類型
類名<實際類型> 引用變量 = new 構造方法<實際類型>(實參);
類名<實際類型> 引用變量 = new 構造方法<>(實參);
eg:
MyData<Integer> md1 = new MyData<>();
MyData<Double> md2 = new MyData<Double>();
MyData<String> md3 = new MyData<String>();
MyData md4 = new MyData();//Object

Day18:======================================================================================

泛型默承認以設定爲任何引用類型
若是要限定泛型的類型只能是某個類型，
T extends 類名：設定上限,只能是這個類或者這個類的後代
public class MyData<T extends Number>{

}
T:Number(√),Integer(√)，Double(√),String(×)

? 能夠表明任何引用類型，?能夠設定上限，下限
? extends 類名 ：上限
? super 類名 ：下限

集合：
數組
一系列類：存儲多個值，多多個值進行操做。

體系：
1.Collection體系：存儲一個一個的值
Collection
| | |
List(重點) Set ...
| | | |
ArrayList LinkedList HashSet TreeSet

Collection:接口，表示一組對象
List：接口，有序的 collection（也稱爲序列）。
ArrayList: List 接口的大小可變數組的實現（重點）
LinkedList: List 接口的連接列表實現

2.Map:存儲一對一對(鍵值對)的值

Map
| |
HashMap TreeMap

Map:將鍵映射到值的對象。一個映射不能包含重複的鍵；每一個鍵最多隻能映射到一個值。
HashMap:基於哈希表的 Map 接口的實現。
TreeMap:基於紅黑樹（Red-Black tree）的 NavigableMap 實現


ArrayList:
底層結構：數組
替代數組，比數組更強大

ArrayList<元素類型> 對象名 = newArrayList<元素類型>();

經常使用方法：
boolean add(E e)
將指定的元素添加到此列表的尾部。
void add(int index, E element)
將指定的元素插入此列表中的指定位置。

元素在列表中的下標可能變化的
int size()
返回此列表中的元素數。
E get(int index)
返回此列表中指定位置上的元素。
E set(int index, E element)
用指定的元素替代此列表中指定位置上的元素。
E remove(int index)
移除此列表中指定位置上的元素。
boolean isEmpty()
若是此列表中沒有元素，則返回 true
元素的個數是0表示空
void clear()
移除此列表中的全部元素。

其餘方法：
boolean contains(Object o)
若是此列表中包含指定的元素，則返回 true。
int indexOf(Object o)
返回此列表中首次出現的指定元素的索引，或若是此列表不包含元素，則返回 -1。
int lastIndexOf(Object o)
返回此列表中最後一次出現的指定元素的索引，或若是此列表不包含索引，則返回 -1。
Object[] toArray()
按適當順序（從第一個到最後一個元素）返回包含此列表中全部元素的數組。
protected void removeRange(int fromIndex, int toIndex)
移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之間的全部元素。

ArrayList遍歷(List):
1.利用下標，循環
for(int i=0; i<list.size(); i++){
System.out.println(list.get(i));
}

2.利用迭代器，看起來難，實際是固定的套路

Iterator<對象類型> it=對象列表.iterator()
while(it.hasNext()){
元素類型 引用變量 = it.next();

if(引用變量){
it.remove();//刪除元素
}

}

3.for-each：
對於數組：底層用的for循環
對於Collection:底層用的迭代器，因此不能在foreach中對集合增刪改
for(int num:array){
System.out.println(num);
}

List排序：升序/降序
類：Collections:
Collection的工具類

1.元素類實現Comparable接口，泛型指定爲元素的類型
public class 對象類型 implements Comparable<對象類型>

2.實現compareTo方法
public int compareTo(Student o){
//根據比較的需求，
經過返回正整數，0，負整數表示當前對象大於，等於，小於o
eg:
if(this.age < o.age) {
return -1;
}else if(this.age == o.age) {
return 0;
}else {
return 1;
}
}

3.對某個元素的List進行排序
Collections.sort(對象list);
排序取決於你的compareTo算法

Day19:======================================================================================

Arrays:數組的工具類
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}

ArrayList<String> list = new ArrayList<String>(
Arrays.asList("hello","haha","hi","hello","hello","hi"));

List排序：

1.Comparable
經過元素類實現Comparable接口，提供比較算法
調用Collections.sort(list); 按照提供的比較算法進行排序

2.Comparator
是否能夠把比較算法抽離出來，脫離元素類，其餘類提供比較算法
任意類實現Comparator接口

排序步驟：
一、定義一個類實現Comparator接口，泛型指定爲要比較的對象類型
二、實現compare方法，提供兩個對象的比較算法
三、調用Collections.sort(list,Comparator實現類對象);

比較Comparable和Comparator:
Comparable：修改元素類，提供比較算法，而且只能提供一種比較算法
Comparator：增長新的類，提供比較算法，每一個類能夠提供一種比較算法，能夠有多個類

面向對象設計一個原則：對修改關閉，對擴展開放


1)匿名內部類：
沒有類名，只能用一次

new 父類/接口(){
//類體;
}

new Comparator<Student>(){
public int compare(Student o1,Student o2){
return o1.getAge()-o2.getAge();
}
};

表示建立了一個實現Comparator接口的類對象，這個類沒有名字，類體是{}這一部分。

2)內部類：
在類的內部定義的類

3)局部內部類: 類比局部變量
在方法或代碼塊中定義

4)靜態內部類：類比靜態屬性
直接在類的內部定義，加上static關鍵字

public class Singleton {
private Singleton() {}

public static Singleton getInstance() {
//當第一次獲取實例時，才加載靜態內部類SingletonHolder
//才建立對象，賦值在類加載時完成，類加載只有一次， 只會建立一次
return SingletonHolder.instance;
}
//利用靜態內部類來實現
private static class SingletonHolder{
private static final Singleton instance = new Singleton();
}
}

String類補充：字符串
實現了Comparable
int compareTo(String anotherString)
按「字典順序」比較兩個字符串。
按照碼值比較

LinkedList:
List 接口的連接列表實現
底層結構：鏈表
特色：由一個一個節點組成,每一個節點空間不連續，能夠方便擴大，縮小，改變引用的指向便可

用的層面：和ArrayList基本同樣，方法有增長

void addFirst(E e)
將指定元素插入此列表的開頭。
void addLast(E e)
將指定元素添加到此列表的結尾。
E getFirst()
返回此列表的第一個元素。
E getLast()
返回此列表的最後一個元素。

Map:鍵值對（key-value)
鍵：不能重複
值：能夠重複

Map:<K,V> K:對應鍵的類型， V:對應值的類型
經常使用方法：
int size()
返回此映射中的鍵-值映射關係數。
V put(K key, V value)
將指定的值與此映射中的指定鍵關聯（可選操做）。
做用1：若是鍵不存在，添加鍵值對
做用2：若是鍵存在，則替換值
V get(Object key)
返回指定鍵所映射的值；若是此映射不包含該鍵的映射關係，則返回 null。
boolean containsKey(Object key)
若是此映射包含指定鍵的映射關係，則返回 true。
boolean containsValue(Object value)
若是此映射將一個或多個鍵映射到指定值，則返回 true。
remove
clear

Day20:======================================================================================

Map遍歷：
不能直接遍歷

方式1：keySet(),返回此映射中包含的鍵的 Set 視圖(Collection體系)。 特色：元素不重複的

方式2：entrySet()，返回全部鍵值對(Entry)對應的Set視圖。效率更高
K getKey()
返回與此項對應的鍵。
V getValue()
返回與此項對應的值。

ctrl+1，快速補全對應的方法

HashMap：
根據鍵的哈希碼(hashCode())計算出在數組的位置：
若是這個位置沒有任何元素，則做爲鏈表的第一個元素
若是這個位置已經有元素了，和每一個元素做比較,equals()肯定鍵是不是重複的，
若是比較下來都不重複，則添加鍵值對，若是有重複的，則修改對應的值

鍵不重複的，標準：hashCode(),equals()
遍歷順序和添加順序不一致的：無序的(沒法經過下標位置控制的)

TreeMap
基於紅黑樹（Red-Black tree）的 NavigableMap 實現

Set:一個不包含重複元素的 collection

集合總結：
List(重點)：列表，精確控制位置 Collection一個分支
ArrayList(整個的重點)
底層結構：數組
經常使用方法
遍歷方式:下標，迭代器，foreach
排序：Comparable,Comparator Collections.sort()
LinkedList
底層結構：鏈表
使用和ArrayList同樣
Map(存儲鍵值對)
重點掌握經常使用方法
要求掌握一種遍歷方法 keySet(),entrySet()
瞭解HashMap(用的比較多，底層鏈表的數組，基於哈希表的實現),TreeMap
Set(用的不多) Collection一個分支
經常使用方法瞭解，和位置無關
遍歷方式：迭代器，foreach
基於HashMap和TreeMap來了解HashSet和TreeSet


File類：文件或文件夾對應的類
File file = new File("文件/文件夾路徑")

經常使用方法：
boolean exists()
測試此抽象路徑名錶示的文件或目錄是否存在。
String getAbsolutePath()
返回此抽象路徑名的絕對路徑名字符串
String getName()
返回由此抽象路徑名錶示的文件或目錄的名稱。
boolean isDirectory()
測試此抽象路徑名錶示的文件是不是一個目錄。
boolean isFile()
測試此抽象路徑名錶示的文件是不是一個標準文件。
boolean isHidden()
測試此抽象路徑名指定的文件是不是一個隱藏文件。
long length()
返回由此抽象路徑名錶示的文件的長度。 以字節爲單位
String getParent()
返回此抽象路徑名父目錄的路徑名字符串；若是此路徑名沒有指定父目錄，則返回 null。
File getParentFile()
返回此抽象路徑名父目錄的抽象路徑名；若是此路徑名沒有指定父目錄，則返回 null。
String[] list()
返回一個字符串數組，這些字符串指定此抽象路徑名錶示的目錄中的文件和目錄
File[] listFiles()
返回一個抽象路徑名數組，這些路徑名錶示此抽象路徑名錶示的目錄中的文件。
獲取全部的孩子

boolean createNewFile()
當且僅當不存在具備此抽象路徑名指定名稱的文件時，不可分地建立一個新的空文件。
若是所在文件夾不存在，則會拋IOException
boolean mkdir()
建立此抽象路徑名指定的目錄。
boolean mkdirs() 推薦
建立此抽象路徑名指定的目錄，包括全部必需但不存在的父目錄。
boolean delete()
刪除此抽象路徑名錶示的文件或目錄
若是此路徑名錶示一個目錄，則該目錄必須爲空才能刪除。

Day21:======================================================================================

IO流：
I:input,O:ouput 輸入輸出，要完成輸入輸出，經過流對象

IO流分類：
按照方向：輸入流，輸出流
輸入，讀：外部數據源到程序
輸出，寫：程序到外部數據目的地
按照單位分：字節流，字符流
字節流：數據以字節爲單位
字符流：數據以字符爲單位
按照功能分：節點流(基本功能流)，包裝流(給其餘流添加功能)

體系：四個抽象類，各類流繼承這四個抽象類
InputStream：輸入字節流
OutputStream：輸出字節流
Reader：輸入字符流
Writer：輸出字符流

文件的讀寫
FileInputStream
FileOuputStream
FileReader
FileWriter

緩衝流：包裝流，給其餘流提供緩衝區，提升讀寫效率
自帶緩衝區
BufferedInputStream
BufferedOutputStream
BufferedReader:重點
BufferedWriter：後面還有一個對BufferedWriter封裝的流PrintWriter


BufferedReader:
String readLine() :讀取一個文本行

BufferedWriter
void write(String str)

void newLine() 新增方法
寫入一個行分隔符。
利用這兩個方法能夠一次寫一行

Day22:======================================================================================

轉換流：包裝流，把字節轉換成字符
InputStreamReader
InputStreamReader 是字節流通向字符流的橋樑
構造方法：
InputStreamReader(InputStream in)
建立一個使用默認字符集的 InputStreamReader。
InputStreamReader(InputStream in, String charsetName)
建立使用指定字符集的 InputStreamReader。
charsetName: //eg:GBK/UTF-8

OutputStreamWriter

打印流：
PrintWriter：包裝流，字符流，輸出流
對BufferedWriter作了再封裝
構造方法：
PrintWriter(String fileName)
建立具備指定文件名稱且不帶自動行刷新的新 PrintWriter。
PrintWriter(String fileName, String csn)
建立具備指定文件名稱和字符集且不帶自動行刷新的新 PrintWriter。
PrintWriter(OutputStream out)
根據現有的 OutputStream 建立不帶自動行刷新的新 PrintWriter。
PrintWriter(OutputStream out, boolean autoFlush)
經過現有的 OutputStream 建立新的 PrintWriter。
autoFlush:true,每次輸出後都會強制刷新緩存
false,不會強制刷新緩存
網絡編程中要用到
PrintWriter(Writer out)
建立不帶自動行刷新的新 PrintWriter。
PrintWriter(Writer out, boolean autoFlush)
建立新 PrintWriter。
方法：
void println(String x)
打印 String，而後終止該行。
寫一行

流總結：
節點流：提供基本功能
文件讀寫拷貝：重點
FileInputStream/FileOutputStream/FileReader/FileWriter
包裝流：給其餘流增長功能
緩衝流
BufferedInputStream/BufferedOutputStream/BufferedReader/BufferedWriter
自帶緩衝區，讀寫效率高
重點：讀一行 BufferedReader:readLine()

轉換流：字節轉換成字符
InputStreamReader/OutputStreamWriter

打印流：
PrintWirter：對BufferedWriter封裝
重點：寫一行：PrintWriter:println();

對象流：
ObjectInputStream/ObjectOutputStream
重點：序列化，反序列化，Serializable接口


多線程實現方式：
1.利用繼承
1)定義一個類繼承Thread
2)重寫run()方法，線程啓動執行的方法
3)建立子類對象
4)調用線程對象start()方法，啓動線程， 此時真正開闢線程，並在新的線程中執行線程對象的run()方法
2.利用實現
1)定義一個類實現Runnable，用來提供算法
2)實現run()方法，提供算法
3)建立實現類對象
4)建立線程對象，傳入第三步對象
5)調用線程對象的start()方法，啓動線程，會執行到傳入對象的run()方法

Thread類：

線程的生命週期：
新建：建立線程對象
就緒：調用start方法，真正開闢線程，在啓動以前，設置各類參數
多個線程，等着CPU調度
運行：CPU調度某一個線程，處於運行狀態，分配一個時間片
就緒狀態和運行狀態相互切換
阻塞：線程由於一些緣由，暫時沒法繼續，等到某些條件符合了再繼續，回到就緒 阻塞：IO阻塞，sleep方法阻塞，wait方法阻塞，join方法等
死亡：可能代碼執行結束，線程結束，死亡
可能出現意外狀態，致使線程結束

Thread方法介紹：
void setPriority(int newPriority)
更改線程的優先級。
int getPriority()
返回線程的優先級。
1~10：值越大優先級越高，默認優先級是5
static int MAX_PRIORITY：10
線程能夠具備的最高優先級。
static int MIN_PRIORITY :1
線程能夠具備的最低優先級。
static int NORM_PRIORITY:5
分配給線程的默認優先級。
static void sleep(long millis) 重點掌握
在指定的毫秒數內讓當前正在執行的線程休眠（暫停執行），此操做受到系統計時器和調度程序精度和準確性的影響。

void join() 瞭解
等待該線程終止。
static void yield()
暫停當前正在執行的線程對象，並執行其餘線程。
CPU調度某個線程時，調用yield方法，會致使線程提早結束本次調度，等待下一次調度，CPU從新調度，但可能調度的仍是它
void stop()
已過期。
不建議使用，簡單粗暴
void interrupt()
中斷線程。中斷處於阻塞狀態的線程，會產生異常
不建議使用

線程同步實現(one by one 執行)：
經過synchronized關鍵字

Day23:======================================================================================

synchronized：利用對象內置鎖，自動還鎖
1）synchronized加在方法上

2）synchronized加載代碼塊上
synchronized(對象引用){
同步代碼;
}

ArrayList vs Vector:
ArrayList:沒有作線程同步，多線程不安全的
Vector:作了線程同步，多線程安全的

同步步驟：
1）屬性私有化
2）操做這個屬性的方法經過synchronized來修飾

Thread.wait()
Thread.notify()

Day24:======================================================================================

Lock類
synchronized是java的關鍵字，來實現的，synchronized鎖機制，自動釋放鎖
Lock類機制實現的，Lock鎖必須手動釋放鎖

Lock接口：
void lock()
獲取鎖。
void unlock()
釋放鎖。
Condition newCondition()
返回綁定到此 Lock 實例的新 Condition 實例。

Condition接口：
void await()
形成當前線程在接到信號或被中斷以前一直處於等待狀態。
void signal()
喚醒一個等待線程。

同步代碼寫法：
Lock l = ...;

lock.lock();
try{
同步代碼;
}finally{
lock.unlock();
}

ReentrantLock:可重入鎖，和synchronized實現同樣的功能

Lock實現線程線程通訊
利用Condition對象
在經過Lock上鎖後，能夠經過newCondition()方法建立Condition對象，能夠根據須要建立
須要阻塞當前線程時：經過condition對象的await()阻塞，
線程被阻塞了，鎖還回去
要喚醒這個阻塞的線程：經過對應的condition對象的signal()喚醒
隨機喚醒一個阻塞的線程，等到再次獲取到鎖會繼續執行

相比wait(),notify(),更加靈活，能夠有多個Condition對象，在不一樣條件下的阻塞喚醒更加清楚控制


ServerSocket:此類實現服務器套接字
構造方法：
ServerSocket(int port)
建立綁定到特定端口的服務器套接字。
方法：
Socket accept()
偵聽並接受到此套接字的鏈接。

Socket:
構造方法：
Socket(String host, int port)
建立一個流套接字並將其鏈接到指定主機上的指定端口號。
方法：
InputStream getInputStream()
返回此套接字的輸入流。
OutputStream getOutputStream()
返回此套接字的輸出流。

咱們傳輸爲了方便，傳寫字符串，以行爲單位：
讀一行：BufferedReader-->InputStreamReader-->socket.getInputStream()
寫一行：PrintWriter-->socket.getOutputStream()
先寫到緩衝區，緩衝區滿了才一次性寫出去，
若是寫給另外一端，馬上收到，寫的時候要flush()
能夠在建立new PrintWriter(socket.getOutoutStream,true)
自動刷新緩存

服務器端程序流程：
1.建立服務器套接字對象，ServerSocket(int port)，指定端口號
多個進程不能使用同一個端口號
2.寫一個死循環，保證服務器一直運行

1）每次等待客戶端的鏈接請求，Socket accept()，
若是沒有客戶端鏈接，阻塞，直到有客戶端鏈接，鏈接成功則返回Socket對象
反回的Socket對象：用來專門與對應的客戶端交互
2）利用返回的Socket對象與客戶端交互，io操做
多是耗時的
能夠把2)放到一個獨立的線程中，使用完了，Socket要關閉

利用多線程來完成2-2）,提升效率，快速同時與多個客戶端鏈接


客戶端程序流程：
1.須要與服務器端創建鏈接時，建立一個Socket套接字對象，
Socket(String host, int port)
若是對象建立成功，則表示鏈接成功

2.利用Socket套接字對象，與服務器端交互，io操做