類：類是一個模板，描述一類對象的行為和狀態(tài)
對象：對象是類的一個實(shí)例，有狀態(tài)和行為；比如說。一只狗，狀態(tài)就是他有品種，名字，顏色等，行為
有搖尾巴，叫，吃等
方法：方法就是行為，一個類可以有很多方法，邏輯運(yùn)算，數(shù)據(jù)
修改等都是在方法中完成的
實(shí)例變量：每個對象都有自己的實(shí)例變量，對象的狀態(tài)就是由這些實(shí)例變量的值決定的
Java基本數(shù)據(jù)類型
變量是申請內(nèi)存來儲值，當(dāng)創(chuàng)建變量的時候需要在內(nèi)存中申請空間
根據(jù)變量的類型來為變量分配存儲空間，只用來儲存該類型數(shù)據(jù)
Java兩大數(shù)據(jù)類型
內(nèi)置數(shù)據(jù)類型和引用數(shù)據(jù)類型
內(nèi)置數(shù)據(jù)類型
八種內(nèi)置數(shù)據(jù)類型（六種數(shù)字?jǐn)?shù)據(jù)類型，一種字符類型還有一種布爾類型）
不用記范圍，直接打印輸出? Inteager.size 這樣就可以打印出范圍
引用數(shù)據(jù)類型
引用數(shù)據(jù)類型類似于指針，引用類型指向一個對象，指向?qū)ο蟮淖兞烤褪且米兞俊?/p>
這些變量在聲明時被指定為一個特定的類型，一旦申明變量，類型就不能改變。
對象，數(shù)組都是引用數(shù)據(jù)類型
所有引用類型的默認(rèn)值都是null
變量類型
類變量：獨(dú)立與方法之外的變量，用ststic修飾
實(shí)例變量：獨(dú)立與方法之外的變量，不用ststic修飾
局部變量：類的方法中的變量
Java 局部變量
局部變量聲明在方法、構(gòu)造方法或者語句塊中；
局部變量在方法、構(gòu)造方法、或者語句塊被執(zhí)行的時候創(chuàng)建，當(dāng)它們執(zhí)行完成后，變量將會被銷毀；
訪問修飾符不能用于局部變量；
局部變量只在聲明它的方法、構(gòu)造方法或者語句塊中可見；
局部變量是在棧上分配的。
局部變量沒有默認(rèn)值，所以局部變量被聲明后，必須經(jīng)過初始化，才可以使用。
java修飾符
Java方法
方法定義的格式：
修飾符 返回值類型 方法名稱 （參數(shù)類型? 參數(shù)名稱）{
方法體
return? 返回值；
}
解釋：
修飾符：目前有固定寫法。兩個關(guān)鍵字 public static
返回值類型：方法最終的數(shù)據(jù)是什么類型
方法名稱：自定義的名字，首字母小寫，從第二個單詞開始每個單詞首字母大寫
參數(shù)類型：進(jìn)入方法的數(shù)據(jù)是什么類型
參數(shù)名稱：進(jìn)入方法的數(shù)據(jù)，對應(yīng)的名稱
方法體：需要執(zhí)行的若干行代碼
return ：第一個作用一旦執(zhí)行結(jié)束當(dāng)前方法，第二帶著后面的返回值交給調(diào)用處
返回值：方法的最終數(shù)據(jù)
注意事項(xiàng)：
返回值類型必須和返回值對應(yīng)
如果參數(shù)多個，那么使用都用逗號分隔
如果不需要參數(shù)，那么小括號可以留空
定義一個沒有返回值的方法
修飾符 void 方法名稱 （參數(shù)類型 參數(shù)名稱）{
方法體
return ；//最后一行的return一般都是省略不寫
}
注意事項(xiàng)
1.返回值沒有不代表沒有參數(shù)，參數(shù)和返回值沒有必然聯(lián)系
2.不能return一個具體的返回值
viod沒有返回值
3.如果最后一行是“return”，那么可以不寫，寫與不寫完全等效
4.沒有返回值的方法，只能使用單獨(dú)調(diào)用，不能使用打印調(diào)用或者賦值調(diào)用【重要】
返回值
只能有一個或者沒有
demo 遍歷數(shù)組
1.將數(shù)組中的元素逐一打印出來
2’定義一個數(shù)組
*返回值類型：只是打印顯示而已，沒有結(jié)果數(shù)據(jù)，所以用void
*方法名稱：printArray
*參數(shù)列表：需要給我一個數(shù)組，我才能遍歷它，所以需要一個int【】數(shù)組
3.調(diào)用方法：傳入一個數(shù)組
有無返回值的對比
對比兩種情況：
1.定義一個方法，用來【求出】數(shù)組元素的總和（告訴我最終的結(jié)果）
2.定義一個方法，用來【打印】數(shù)組元素的總和（自己打印就得了，不用告訴我結(jié)果）
結(jié)論:
需要計算的有返回值
只需要打印的就沒有返回值
方法的重載（Overload ）
方法重載：方法的名稱相同，但是參數(shù)列表不同（Overload）
達(dá)到效果：對于類似功能的多個方法，只要記住一個相同的名字即可，可以根據(jù)參數(shù)列表的不同自動適配
注意事項(xiàng)：
1.參數(shù)個數(shù)不同
2.參數(shù)類型不同
3.參數(shù)的多類型的順序不同（表達(dá)式當(dāng)中需要運(yùn)算的數(shù)據(jù)類型不一樣，怎么辦？誰的數(shù)據(jù)范圍大，結(jié)果就是誰）：比如先int后double，先double后int
重載與下列因素?zé)o關(guān)：
1.與返回值類型無關(guān)，無法根據(jù)返回值的不同進(jìn)行重載;
2.與參數(shù)的名稱無關(guān)，比如int a，int b和int x，int y；
參數(shù)傳遞
參數(shù)傳遞：在調(diào)用方法的時候，向方法內(nèi)傳入一些數(shù)據(jù)的動作
【形式參數(shù)】：在“定義”方法的時候，寫在小括號之內(nèi)的參數(shù)
例如：public static? int sum(int a,int b){...}這里的a和b是在定義的時候?qū)懙?，所以就是形式參?shù)
【實(shí)際參數(shù)】；在“調(diào)用”方法的時候，真正傳入方法里的數(shù)據(jù)，叫做實(shí)際參數(shù)
例如：int num=sum（10,20）,這里的10和20是在調(diào)用方法的時候傳入方法的，所以他們是實(shí)際參數(shù)
參數(shù)傳遞的過程中，有兩項(xiàng)規(guī)則
1.對于基本數(shù)據(jù)類型（以及String）來說，形式參數(shù)的操作不會影響實(shí)際參數(shù)
2.對于引用數(shù)據(jù)類型（除了String）來說，形式參數(shù)的操作會影響到實(shí)際參數(shù)
類的定義
類是用來模仿現(xiàn)實(shí)事物的代碼手段，事物分為屬性，行為兩個部分，類中也對應(yīng)的包含了兩個部分
1.成員變量（屬性）：將變量位置直接定義在類中，在方法外即為成員變量
2.成員方法（行為）：將普通的方法去掉stataic關(guān)鍵字，即為成員方法
兩個對象內(nèi)存圖
一個對象
對比局部變量和成員變量的不同
1.定義的位置不同【重點(diǎn)記憶】
局部變量：定義在方法內(nèi)部
成員變量：直接定義在類中，在方法外面的
2.內(nèi)存中的位置不一樣
局部變量：在棧內(nèi)存中，stack
成員變量：在堆內(nèi)存中，heap
3.生命周期不一樣
局部變量：隨著方法的進(jìn)棧而出現(xiàn)，隨著方法的出棧而消失
成員變量：隨著對象被創(chuàng)建而出現(xiàn)，隨著對象被JVM回收而消失
4.默認(rèn)值不一樣【重點(diǎn)記憶】
局部變量：沒有默認(rèn)值，必須賦值之后才能使用
成員變量：如果沒有賦值，那么會有一個默認(rèn)值
private關(guān)鍵字
一旦使用了private關(guān)鍵字對成員進(jìn)行了修飾，那么超出了本類范圍之外，就不能訪問了
如果需要使用private修飾的成員變量，可以使用“間接訪問”
為private成員變量編寫一對兒Setter Getter方法
例如：
在最前方加上一個private?
專門定義了一個成員方法用來設(shè)置成員變量的數(shù)據(jù)，Setter方法
public void setAge （int num）{
? ? ?age = num;
}
專門定義了一個方法用來獲取成員變量的數(shù)據(jù)，Getter方法
public void getAge（）{
return age；
}
this關(guān)鍵字
當(dāng)局部變量與和成員變量重名的時候，方法中會根據(jù)“就近原則”使用局部變量
如果希望區(qū)分一下
this.成員變量名
this關(guān)鍵字的靜電作用：將重名的成員變量和局部變量區(qū)分開
擴(kuò)展：
this關(guān)鍵字其實(shí)代表的是“當(dāng)前對象”：通過誰調(diào)用了方法，誰就是this
構(gòu)造方法：
專門用來創(chuàng)建對象的方法，當(dāng)通過new關(guān)鍵字創(chuàng)建對象時，其實(shí)就是在調(diào)用構(gòu)造方法
格式：
public 構(gòu)造方法名 （參數(shù)類型 參數(shù)名稱）{
方法體
return? //通常最后一行return省略不寫
注意：
1.構(gòu)造方法不能寫放回值類型，連void都不能寫
2.構(gòu)造方法的名稱必須和所在的類名完全一樣，連大小寫也要一樣
}
3.構(gòu)造方法的調(diào)用格式就是創(chuàng)建對象的格式?
構(gòu)造方法重載的好處：
定義一個無參數(shù)的構(gòu)造方法，可以直接new對象
定義一個重載的全參數(shù)的構(gòu)造方法，可以在new對象的同時方便對成員變量進(jìn)行賦值
注意事項(xiàng)：
1.構(gòu)造方法根本不寫返回值類型，連void都不寫
2.構(gòu)造方法的名稱和所在類名稱必須完全相同，連大小寫都要一樣
3.構(gòu)造方法也是可以進(jìn)行承載的
4.構(gòu)造方法如果沒有自定義，那么將會默認(rèn)贈送一個，如果自定義了至少一個，那么就不再贈送默認(rèn)的
如何定義一個標(biāo)準(zhǔn)的類：
1.所有的成員變量都需要使用private關(guān)鍵字私有化
2.為每一個成員變量編寫一對Getter Setter 方法
3.編寫一個無參數(shù)的構(gòu)造方法
4.編寫一個全參數(shù)的構(gòu)造方法
布爾類型的boolean值，那么setXxx規(guī)則不變，而getXxx余姚寫成isXxx的形式
private boolean male；
public void setMale（boolean male）{
? ? this.male = male;
}
public boolean isMale (){
return male;
}
字符串的兩個問題
1.對象肯定有一個類與之對應(yīng)，那么字符串對應(yīng)的類是誰，String
為什么String這個類，不需要導(dǎo)包就可以直接用？
所有的類都需要導(dǎo)包才能使用，除了兩種情況
a. 要使用的目標(biāo)類，和當(dāng)前類位于同一個包下
b.要使用的目標(biāo)類，位于java.lang包下，但是不包含子包內(nèi)容
2.既然字符串是對象，那么為什么直接打印出來就是內(nèi)容呢？
打印println方法 邏輯：
1.如果是字符串類型，那么就直接顯示內(nèi)容
2. 如果不是字符串類型，那么就想辦法內(nèi)部轉(zhuǎn)換成字符串，然后再顯示
一般的對象都是使用“類型信息+@+地址值”作為字符串內(nèi)容的
字符串池
字符串是最為常用的對象，所以在程序設(shè)計中往往會出現(xiàn)很多個重復(fù)的字符串
為了節(jié)省內(nèi)存，所以引入了“字符串池”的設(shè)計，可以重復(fù)利用字符串
關(guān)于字符串池的幾點(diǎn)描述
1.字符串池是位于堆內(nèi)存中的一小塊空間，用來保存若干個字符串的地址值
2.字符串池當(dāng)中絕對不會重復(fù)的字符串對應(yīng)的地址，保證字符串不重復(fù)
3.凡是直接雙引號的字符串默認(rèn)都在池中，而new出來的字符串默認(rèn)不在池中
對于基本類型來說，==是進(jìn)行數(shù)據(jù)內(nèi)容的相同比較，但是對于引用類型來說，==是進(jìn)行地址值的相同比較
如果是兩個對象，那么地址值必然不同，如果地址值相同，那么必然是同一個對象
字符串的內(nèi)容不可變
字符串對象在內(nèi)存中一旦被創(chuàng)建，那么內(nèi)容不可以改變
字符串的內(nèi)容不會發(fā)生改變，每當(dāng)你覺得昊想是變了的時候，一定是創(chuàng)建了新的字符串
字符串的比較方法
如果使用 == 進(jìn)行比較，那么是進(jìn)行地址值的相同判斷
如果希望進(jìn)行字符串的內(nèi)容比較，則需要使用String當(dāng)中的成員方法
public? boolean equals (object obj); 進(jìn)行字符串的內(nèi)容比較，嚴(yán)格區(qū)分大小寫。參數(shù)obj就是另一個對象（跟誰比 ）。object也是一種類型，可以接受任何類型的數(shù)據(jù)
public boolean equalsIgnoreCase(String str);進(jìn)行字符串的內(nèi)容比較，但是忽略大小寫?
注意事項(xiàng)：
1.要想進(jìn)行字符串的內(nèi)容比較，一定要使用equals方法，你要使用==運(yùn)算
2.equals方法具有對稱性，a.equals（b）和b.equals（a）效果一樣
3. 小技巧,如果equals方法需要比較的兩個字符串當(dāng)中，有一個是常量，那么盡量將常量寫在前面
4.直接寫上的雙引號就是字符串對象，所以用雙引號直接點(diǎn)兒也能調(diào)用方法。
字符串的替換方法（敏感詞過濾）
如果希望將字符串當(dāng)中指定的部分進(jìn)行替換操作，需要使用
public String replace （CharSequence olderStr，CharSequence newStr）；將字符串當(dāng)中所有出現(xiàn)的older部分，替換成為newOlder部分
參數(shù)olderStr代表需要替換的老字符串部分
參數(shù)newStr代表需要替換成為的新字符串部分
參數(shù)類型CharSequence現(xiàn)階段可以簡單地認(rèn)為就是字符串String
字符串切割方法
使用方法
public String[] split（String regex）；將regex作為標(biāo)記進(jìn)行切刀，返回切分之后的若干段字符串（字符串?dāng)?shù)組）
注意事項(xiàng)：
現(xiàn)階段強(qiáng)烈推薦不要使用英文句點(diǎn)作為分割的標(biāo)記
因?yàn)橛⑽木潼c(diǎn)在正則表達(dá)式中有特殊含義
如果一定要使用英文句點(diǎn)，切割的標(biāo)記應(yīng)該使用“//.”（現(xiàn)階段的固定寫法）
而參數(shù)regex其實(shí)就是一個正則表達(dá)式??
集合
集合和已經(jīng)學(xué)過的數(shù)組比較類似，本身也是一種引用類型。也可以存放很多個數(shù)據(jù)
區(qū)別在于數(shù)組的長度不可以改變，集合的長度可以任意改變
集合包含很多種，ArrayList，HashSet，LinkedList，HashMap......
現(xiàn)階段我們只學(xué)習(xí)最為簡單的ArrayList一種即可，其他的集合類似
使用：
java.util.ArrayList是一個類，使用三步，導(dǎo)包，創(chuàng)建，使用??
1.導(dǎo)包
import java.util.ArrayList
2.創(chuàng)建?
類名稱 對象名 = new 類名稱（）；
ArrayList<泛型> Array = new ArrayList<>();
泛型，也就是集合當(dāng)中存放的都是同意類型的數(shù)據(jù)
注意：泛型只能是引用類型，不能是基本類型
3.使用 ：
如何在集合中存儲基本數(shù)據(jù)類型
基本類型? ? ? ?對應(yīng)的包裝類
byte? ? ? ? ? ? ? ? ? Byte
short? ? ? ? ? ? ? ? ?Short
int? ? ? ? ? ? ? ? ? ? Integer? ? ?【特殊】
long? ? ? ? ? ? ? ? ? Long
float? ? ? ? ? ? ? ? ? Float
double? ? ? ? ? ? ?Double
char? ? ? ? ? ? ? ? Character? ? 【特殊】
boolean? ? ? ? ? ?Boolean
從jdk1.5開始，基本數(shù)據(jù)類型可以和對應(yīng)的包裝類進(jìn)行自動裝箱拆箱
裝箱：基本類型-->包裝類
拆箱：包裝類 -->基本類型
如何在集合中儲存自定義數(shù)據(jù)類型
io流：
I：input,輸入
o:output，輸出
流：數(shù)據(jù)流
FileWriter 寫文件
1.導(dǎo)包：
import java.io.FileWhiter;
2.創(chuàng)建，構(gòu)造方法
public FileWriter(String fileName); 參數(shù)字符就是文件的路徑名稱
FileWriter fw = new FileWrite（“file01.txt”）；
文件擴(kuò)展名只能決定默認(rèn)用什么軟件打開軟件，不能決定其內(nèi)容
3.使用：成員方法
寫數(shù)據(jù)：public void write （String str）；參數(shù)就是需要寫到文件中的字符串
關(guān)閉流：public void close（）；關(guān)閉釋放相關(guān)資源
總結(jié)：
FileWriter基本使用步驟：創(chuàng)，寫，關(guān)
注意事項(xiàng)：
1.千萬不要忘記最后調(diào)用close方法進(jìn)行關(guān)閉
2.創(chuàng)建的時候，如果提示可能有異常，那么就點(diǎn)擊add throws...即可
FileWriter寫數(shù)據(jù)的覆蓋與追加
在使用FileWriter的時候：
1.如果指定的文件不存在，那么會自動創(chuàng)建該文件
2.如果指定的文件已經(jīng)存在，那么將會覆蓋寫入
3.如果必須希望進(jìn)行覆蓋寫入，而是希望追加，那么要用另外一種重載形式的構(gòu)造方法
public FileWriter （String fileName ， boolean append）；第二個參數(shù)為true值，那么將會追加寫入
文本文字就是數(shù)字
計算機(jī)當(dāng)中一切都是數(shù)字，文本文件當(dāng)中保存的就是數(shù)字
能夠看到文字圖形，是因?yàn)檐浖臀覀冞M(jìn)行了翻譯，翻譯的規(guī)則就是：
ASCii碼表，還有另外一張更大的表叫做Unicode碼表
后者包含了全世界所有數(shù)以萬計的文字
FileWriter提供了一種重載形式的write方法，可以直接根據(jù)數(shù)字寫文件
public void write（int ch）；參數(shù)就是單個文字所對應(yīng)的數(shù)字值
FileWriter的重載形式
FileReader讀數(shù)據(jù)的一般步驟
用來將文本文件中的字符讀取到程序當(dāng)中
1.導(dǎo)包
import java.io.FileReader;
2.創(chuàng)建
public FileReader(String fileName);參數(shù)任然是文件的路徑名
FileReader fr = new FileReader("fileXxx.txt");
如果指定的文件名不存在，那么會直接報錯?
3.使用
讀取單個字符：public int read();讀取下一個字符，得到對應(yīng)的ASCII或者Unicode值
關(guān)閉流，釋放資源：public void close；
三個步驟：創(chuàng)，讀，關(guān)；
如何使用FileReader讀取字符數(shù)組
為了提高效率。FileReafer提供了另外一種重載形式的read方法
public int read(char[] buf);
參數(shù)是一個字符數(shù)組，用來承載讀取到的多個字符
返回值代表的是數(shù)組中讀取到的有效個數(shù)
BufferWriter的緩沖原理
BufferWriter和FileWriter差不多，也是一種用來寫文件的類，屬于字符輸出類
區(qū)別與BufferWriter肚子里有一個長度為8192的char[]性字符數(shù)組，當(dāng)作緩沖區(qū)使用
每次在寫數(shù)據(jù)時，實(shí)際上都是在不斷地向緩沖數(shù)組中添加字符
如果緩沖數(shù)組已經(jīng)滿了，那么將會統(tǒng)一的寫入到硬盤中去
如果還未寫滿，那么就等待下一次的寫入
如果最終關(guān)閉流的時候，數(shù)組任未滿，那么也會將剩余的有效部分寫到硬盤文件里
如何使用BufferedWriter？
1.首先創(chuàng)建一個普通的BufferedWriter
2.將這個普通的FileWriter包裝成為緩沖的BufferedWriter，用構(gòu)造方法
3.后面的BufferedWriter使用的方法和FileWriter基本一致
構(gòu)造方法
public Buffered(FileWriter fw);參數(shù)就是一個普通的FileWriter對象
BufferedReader的緩沖原理
接口
接口的好處：通用性，隔離性
?通用性：無論是醫(yī)生還是警察還是司機(jī)
通用全都當(dāng)作的學(xué)生對待
隔離性：無論是醫(yī)生還是警察還是司機(jī)
特有的功能與我無關(guān)，我只關(guān)心學(xué)生相關(guān)的功能
接口的格式和組成部分
格式:
public interface 接口名稱{
? //
}
接口中的組成成分
1.抽象方法[學(xué)習(xí)重點(diǎn)]
2.常量
3.默認(rèn)方法（java8）
4.靜態(tài)方法(java8)
5.私有方法(java9)
接口中抽象方法定義
格式：
public abstract 返回值類型 方法名稱（參數(shù)類型 參數(shù)名稱）；
注意：
1.接口中的抽象方法，修飾如果寫必須是public abstract
2.接口中的抽象方法，修飾符可以省略不寫。默認(rèn)就是public abstract
3.抽象方法只有方法頭，沒有方法體大括號
接口實(shí)現(xiàn)類的定義
如果想要使用定義好的接口，必須有一個接口的實(shí)現(xiàn)類
定義實(shí)現(xiàn)類格式為：
public class 實(shí)現(xiàn)類的名稱 implements? 接口名稱 {
? ? ?//一定要覆蓋寫所有的抽象方法
}
注意：
什 么是覆蓋重寫Override 抽象方法
1.也就是將接口當(dāng)中的抽象方法抄寫過來
2.去掉abstract關(guān)鍵字
3.寫上大括號方法體?
package day09demo01;
public class Catimplements Animal{
public? void eat (){
System.out.println("貓吃魚");
};//吃東西
? ? public void sleep (){
System.out.println("貓睡覺");
};//睡覺
}
Cat就是Animal接口的實(shí)現(xiàn)類，Cat類實(shí)現(xiàn)了Animal接口。
接口與實(shí)現(xiàn)類的基本使用
創(chuàng)建：
接口名稱 引用名 = new 實(shí)現(xiàn)類名稱（）；
調(diào)用：
引用名.抽象方法名（參數(shù)）；? ??
注意：
1.左面是接口類型，那么只能調(diào)用接口中定義好的內(nèi)容，無法調(diào)用左側(cè)實(shí)現(xiàn)類專有的方法
2.當(dāng)調(diào)用接口當(dāng)中的抽象方法時，真正進(jìn)行運(yùn)行的是右側(cè)new的時候類的具體實(shí)現(xiàn)方法內(nèi)容
3.總結(jié)記住一句話：調(diào)用的時候看左邊，運(yùn)行的時候看右邊
面向接口編程
使用接口作為左側(cè)類型的好處所在
屏蔽掉了右側(cè)的個性特有的內(nèi)容，達(dá)到隔離，統(tǒng)一的目的。
面向接口編程：
如果使用的功能，接口已經(jīng)可以滿足，那么就不在乎具體的類是誰，只在乎接口即可
Lambda表達(dá)式：（a，b）-> a + b
method方法需要一個Calaulator接口類型的參數(shù)
Lambda表達(dá)式就是充當(dāng)了Calculator接口類型的參數(shù)
初步理解：
1.Lambda表達(dá)式前面的小括號，其實(shí)就是接口抽象方法的小括號
2.箭頭代表拿著小括號的數(shù)據(jù)做什么事情，是一個指向的動作
3.箭頭后面就代表這拿到了參數(shù)之后做什么事
Lambda表達(dá)式的語義本身就是代表了怎么做這件事情，沒有對象概念在里面。
函數(shù)式接口
Java中使用Lambda表達(dá)式的前提是，必須有“函數(shù)式接口”
概念：有且僅有一個抽象方法的接口，叫做函數(shù)式接口?
如何才能萬無一失地檢測一下當(dāng)前的接口是不是函數(shù)式接口呢？
用一個固定的格式寫在public interface前一行即可
@FunctionalInterface
public interface 函數(shù)式接口名 {
? //? ...
}
Lambda的標(biāo)準(zhǔn)格式
Lambda表達(dá)式要想使用，一定要有函數(shù)式接口的推斷環(huán)境
1.要么通過方法的參數(shù)類型來確定是哪個函數(shù)式接口
要么通過賦值操作來確定哪個是函數(shù)式接口
Lambda的格式就是為了將抽象方法，翻譯成一下三點(diǎn)
1.一些參數(shù)(方法參數(shù))
2.一個箭頭
3.一些代碼（方法體）
例如抽象方法
public abstract int sum（int a，int b）；
翻譯成為Lambda的標(biāo)準(zhǔn)格式
（int a，int b） -> {return a + b; }
Lambda表達(dá)式上下文推斷
調(diào)用方法的時候，參數(shù)類型是函數(shù)式接口，所以Lambda可以推斷出來是哪個接口
也可以根據(jù)賦值語句左側(cè)的類型來進(jìn)行Lambda上下文推斷
Lambda的簡便格式
1.在Lambda表達(dá)式當(dāng)中凡是可以推導(dǎo)的，都是可以省略的?
2.如果參數(shù)有且僅有一個，那么小括號可以省略
3.如果語句只有一個，那么大括號和return也可以省略
前面學(xué)習(xí)的代碼實(shí)現(xiàn)案例分析
1.創(chuàng)建一個集合用來存儲5個英雄
創(chuàng)建一個Hero類，代表英雄
把集合內(nèi)的對象換成hero對象
2.讀文件，吧數(shù)據(jù)加到集合當(dāng)中
3.判斷一下集合中有沒有內(nèi)容，是不是新的
如果是新的隊伍，沒有人，就需要創(chuàng)建五個對象加入到集合中
如果不是新的隊伍，已經(jīng)有人了，就不需要創(chuàng)建了
遍歷集合，輸出其中的每一個對象的具體信息//循環(huán)5次進(jìn)行遍歷//統(tǒng)計一下綜合戰(zhàn)斗力是多少
判斷一下集合是不是新的
if （isNew）{
System.out.println("將集合重的數(shù)寫到文件中”）；
}
//如果不是新的，就什么也不用做
System.out.println("退出游戲")
方法引用（java 8）
Stream流（java 8）
模塊化（java 9）
定義方法時，
有static的方法叫做靜態(tài)方法
沒有static的方法，叫做成員方法（實(shí)例方法）
定義靜態(tài)方法的格式：
public static 返回值類型 方法名稱（參數(shù)類型 參數(shù)名稱）{
? ?//方法體
}
定義成員方法的格式：
public 返回值類型 方法名稱（參數(shù)類型 參數(shù)名稱）{
? ?//方法體
}
調(diào)用靜態(tài)方法的格式
方法名（參數(shù)值）；//直接調(diào)用本類中的靜態(tài)方法，本類中的靜態(tài)方法，也可以通過類名稱調(diào)用
類名稱.方法名（參數(shù)值）；//調(diào)用另外一個類中的靜態(tài)方法
調(diào)用成員方法的格式：
? ? ?類名稱? 對象名? =? new 類名稱（）； //首先創(chuàng)建對象
? ? ?對象名.成員方法名（參數(shù)值）；? ?//通過對象名調(diào)用成員方法
同一類中直接調(diào)用：方法名（參數(shù)值）；
再另外一個類中調(diào)用：類名稱.方法名（參數(shù)值）；
成員方法調(diào)用
沒有static ，這是一個成員方法（實(shí)例方法，Instance Method）
需要調(diào)用成員方法就必須借助對象。
注意：
如果不創(chuàng)建對象，那么通過類名稱只能調(diào)用靜態(tài)方法。
如果創(chuàng)建了對象，那么通過對象名可以調(diào)用成員方法
通過對象名也可以調(diào)用靜態(tài)方法，然而不推薦這么做
Lambda表達(dá)式冗余場景
在某些場景之下，Lambda表達(dá)式要做的事情，其實(shí)在另外一個地方已經(jīng)寫過了
那么此時如果通過Lambda表達(dá)式重復(fù)編寫相同的代碼，就是浪費(fèi)。
方法引用的更優(yōu)寫法
在寫Lambda表達(dá)式的地方寫
方法引用：
如果Lambda表達(dá)式需要做的事情，在另一個類當(dāng)中已經(jīng)做過了，那么就可以直接拿過來進(jìn)行替換Lambda
方法引用的寫法：? ? ? ?
通過類名稱引用靜態(tài)方法的格式：
類名：：靜態(tài)方法名
方法引用的另一個方法，通過對象引用成員方法格式：
對象名：：成員方法名
Stream流的更優(yōu)寫法
day10Code
Stream流式思想
獲取Stream流的常用方法
java 8 當(dāng)中的“流“其實(shí)就是Stream接口的對象
JDK提供了一個流接口，java.util.stream.Stream<T>
如何獲取流？
1.根據(jù)集合獲取流：集合名稱.stream();
2.根據(jù)數(shù)組獲取流? :Stream.of(數(shù)組名稱);
Stream流的map映射方法：
獲取流之后，可以使用映射方法：map（用于轉(zhuǎn)換的Lambda表達(dá)式）
映射：就是將一個對象轉(zhuǎn)換成另一個對象，把老對象映射到新對象上
Stream流的filter過濾方法：
如果希望對流中的元素進(jìn)行過濾，可以使用過濾方法
filter（能產(chǎn)生boolean結(jié)果的Lambda），如果參數(shù)Lambda產(chǎn)生了true，則要元素；如果產(chǎn)生了false，則不要元素?
Stream流的forEach方法：
如果希望再流中進(jìn)行元素的遍歷操作，可以使用forEach方法
forEach(Lambda表達(dá)式)，意思是，對流當(dāng)中的每一個元素都要進(jìn)行操作
參數(shù)Lambda表達(dá)式必須是一個能夠消費(fèi)一個參數(shù)，而且不產(chǎn)生數(shù)據(jù)結(jié)果的Lambda
例如：
Lambda：? s -> System.out.println（s）；
方法引用：? System：：println
并發(fā)的Stream流
流當(dāng)中的元素如果特別多，那么只有一個人在逐一，挨個兒處理，肯定比較慢，費(fèi)勁
如果對流當(dāng)中的元素，使用多個人同時并發(fā)處理，這就是并發(fā)
注意事項(xiàng)：
1.使用并發(fā)流的時候，到底有幾個人進(jìn)行同時操作呢？不用管，JDK自己處理
2.只要正確使用，就不會出現(xiàn)多個人搶到同一個元素的問題
3.如果已經(jīng)獲取了一個普通流，那么只要再調(diào)用一下parallel（）方法也會變成并發(fā)流
總結(jié)：
1.直接獲取并發(fā)流：.parallelStream()
2.已經(jīng)獲取了普通流，然后升級成為并發(fā)流：.stream().parallel()
