JAVA
來(lái)源：
sun公司溉潭，oracle收購(gòu)
版本情況：
1.0 ....1.5(5.0)....8.0(1.8)...11(2.1)
安裝JDK ，JDK 編譯環(huán)境 ，JRE 運(yùn)行環(huán)境
配置：我的電腦（屬性），高級(jí)，環(huán)境變量交掏，系統(tǒng)變量，path（內(nèi)容的最前 + ";"在分號(hào)前復(fù)制jdk的bin目錄的位置）
javac? 文件（包括后綴）? 編譯
java? 文件的名字（沒(méi)有后綴） 運(yùn)行
java語(yǔ)言特點(diǎn)：半編譯半解釋（通過(guò)jvm器紧，多個(gè)平臺(tái)耀销，各有自己的jvm）
源代碼(.java)->javac? -> java字節(jié)碼（.class）->java ->本地機(jī)械碼文件（cpu只能運(yùn)行機(jī)械碼）
jvm：java虛擬機(jī)
main: 主函數(shù) ：代表程序的開(kāi)始和程序的結(jié)束
// ：注釋 楼眷，不能運(yùn)行的代碼铲汪，給我們程序員說(shuō)明程序用的
public? class? Test{
public static void main(String args[]){? //從這里開(kāi)始
System.out.println("hello hehe");? //在系統(tǒng)的控制臺(tái)輸出（一定）的內(nèi)容
} //到這里結(jié)束
}
{} ：塊 代碼塊
數(shù)據(jù)類型：
基本數(shù)據(jù)類型（4類8種）：
整數(shù)：
byte:1個(gè)字節(jié) ，8位 罐柳，-128 ~127
short:2個(gè)字節(jié)掌腰，16位，-2^15 ~2^15-1
int:4個(gè)字節(jié)张吉，32位齿梁，-2^31 ~2^31-1 （默認(rèn)）
long:8個(gè)字節(jié)，64位肮蛹，-2^63 ~2^63-1
所有書寫的整數(shù)勺择，默認(rèn)都是int類型，long類型的數(shù)字默認(rèn)是最后+L
所有書寫的整數(shù)伦忠，默認(rèn)是十進(jìn)制
數(shù)字前面 0省核， 為8進(jìn)制
數(shù)字前面 0x，為16進(jìn)制
進(jìn)制轉(zhuǎn)換最好通過(guò)二進(jìn)制進(jìn)行中轉(zhuǎn)
浮點(diǎn)數(shù)：
float: 4個(gè)字節(jié)昆码，32位
double: 8個(gè)字節(jié)气忠，64位
默認(rèn)的所有的書面寫的浮點(diǎn)數(shù)都是doubule，float類型的數(shù)字默認(rèn)+f
不能參與嚴(yán)格的計(jì)算赋咽，可以用來(lái)顯示
字符：2個(gè)字節(jié) 旧噪，單引號(hào)引起來(lái)一個(gè)字符
char:本質(zhì)是short，但是通過(guò)字符表映射成字母顯示
支持轉(zhuǎn)義字符： '\''
回車：\n?
支持unicode? \u
布爾值：1個(gè)字節(jié)
boolean: true ,false
不參與算數(shù)運(yùn)算脓匿，只能進(jìn)行邏輯和關(guān)系運(yùn)算
引用數(shù)據(jù)類型（無(wú)數(shù)）：
數(shù)組 ：一組數(shù) []
類 ：6章
接口：7章
數(shù)據(jù)類型轉(zhuǎn)換：
顯式轉(zhuǎn)換：程序員通過(guò)代碼主動(dòng)轉(zhuǎn)換
? 整數(shù) 淘钟，浮點(diǎn)數(shù)，字符? 陪毡；(datatype)data
? 如果大范圍的數(shù)據(jù)類型轉(zhuǎn)向小類型的范圍米母，有溢出的可能（看數(shù)據(jù)是否超過(guò)要轉(zhuǎn)的類型的取值范圍）
隱式轉(zhuǎn)換：計(jì)算機(jī)替程序員把數(shù)據(jù)轉(zhuǎn)換（轉(zhuǎn)的效果和顯式一樣）
? 計(jì)算機(jī)何時(shí)替我們做隱式轉(zhuǎn)換
? 小范圍自動(dòng)轉(zhuǎn)大范圍
? byte袱瓮，short，char 直接跳到int
? 浮點(diǎn)型最大
變量：
使用變量的前提：
1.聲明變量? ? int a ;
2.變量的初始化? a = 1;
作用域：塊作用域
在聲明塊及內(nèi)部的淺套塊可以使用爱咬，外部則不認(rèn)尺借；
大作用域和嵌套作用域有同名的變量，使用的時(shí)候優(yōu)先使用離自己聲明更近的變量
函數(shù)塊里聲明的變量：局部變量
類塊聲明的變量：實(shí)例變量或者叫屬性
運(yùn)算符：
算數(shù)：+ -? *? /? %?
/:兩個(gè)整數(shù)相除精拟，結(jié)果只能還是整數(shù)燎斩，浮點(diǎn)去掉
%：符號(hào)看被除數(shù)
? ++ 自增? ,--
? 語(yǔ)法點(diǎn)： 位置在變量前，先完成自增運(yùn)算 蜂绎，后作為一個(gè)變量來(lái)使用
? ? 位置在變量后栅表，則先作為變量使用，最后在獨(dú)自完成自增（滯后性）
比較運(yùn)算：>? <? >=? <=? ==? !=? ?
邏輯運(yùn)算： 短位：? &&? , ||? ,!? （如果表達(dá)式的左邊結(jié)果已決定整個(gè)表達(dá)式的結(jié)果师枣，則不計(jì)算右邊）
? ? ? ? ? 按位：? &? , |?
位運(yùn)算：必須是整數(shù)才能計(jì)算
&? , |? ,~? 怪瓶，^? ,>>? ,<<? ,>>>
計(jì)算機(jī)底層存儲(chǔ)補(bǔ)碼，一切運(yùn)算都以補(bǔ)碼進(jìn)行
1.10進(jìn)制轉(zhuǎn)成2進(jìn)制原碼（負(fù)數(shù) 符號(hào)位1践美，其他和正數(shù)一樣）
? 如果正數(shù)洗贰，則直接當(dāng)補(bǔ)碼用
? 如果負(fù)數(shù) ， 先轉(zhuǎn)反碼（符號(hào)位不變陨倡，其他1變0敛滋，0變1），在把反碼轉(zhuǎn)補(bǔ)碼（符號(hào)位不變兴革，反碼其他位+1）
? ? ? ? ? ? 2.兩個(gè)補(bǔ)碼運(yùn)算绎晃，運(yùn)算結(jié)果一定是補(bǔ)碼，看符號(hào)位是否0杂曲，0則直接當(dāng)原碼庶艾，轉(zhuǎn)回10進(jìn)制
? ? ? ? ? ? ? 如果符號(hào)位是1，則先把補(bǔ)碼（符號(hào)位不變擎勘，其他-1）咱揍，在把反碼轉(zhuǎn)原碼（符號(hào)位不變，其他1變0货抄，0變1）述召，
? ? ? ? ? ? ? 0則直接當(dāng)原碼，轉(zhuǎn)回10進(jìn)制 ?
賦值運(yùn)算：=? +=? -= *= /=? %= >>=? <<=? >>>=
邏輯上 a+=b? a= a+b ,邏輯上相等蟹地，但是實(shí)際上有區(qū)別积暖。?
條件運(yùn)算：? ? :
運(yùn)算符優(yōu)先級(jí)：
1>2>3
流程控制語(yǔ)句：
選擇：
?:
if( 布爾值 ){ }?
如果布爾值為true，則執(zhí)行語(yǔ)句塊的代碼怪与，否則不執(zhí)行
int chengji = 90;
if(chengji >=90 && chengji<=100){
System.out.println("A");
}
if(chengji >=80 && chengji<90){
System.out.println("B");
}
if(chengji >=70 && chengji<80){
System.out.println("C");
}
if(chengji >=60 && chengji<70){
System.out.println("D");
}
if(chengji >=0 && chengji<60){
System.out.println("E");
}
缺點(diǎn)：不方便寫夺刑，性能差
if(chengji<60){
System.out.println("E");
}else{
if(chengji>=60 && chengji <70){
System.out.println("D");
}else{
if(chengji >=70 && chengji <80){
System.out.println("C");
}else{
if(chengji >=80 && chengji <0){
System.out.println("B");
}else{
System.out.println("A");
}
}
}
}
缺點(diǎn)亂：
if (chengji < 60) {
System.out.println("E");
} else if (chengji >= 60 && chengji < 70) {
System.out.println("D");
} else if (chengji >= 70 && chengji < 80) {
System.out.println("C");
} else if (chengji >= 80 && chengji < 0) {
System.out.println("B");
} else {
System.out.println("A");
}
缺點(diǎn)：性能不極致
key:int byte? short? char? 1.7版本之后 枚舉? ，字符串
case值不能重復(fù)，
跳出：
break：跳出包含當(dāng)前break語(yǔ)句最近的switch或者循環(huán)塊
continue：跳出本次循環(huán)
不允許其他語(yǔ)句出現(xiàn)在break或者continue之后
switch (chengji/10) {
case 10:
System.out.println("A");
break;
case 9:
System.out.println("A");
break;
case 8:
System.out.println("B");
break;
case 7:
System.out.println("C");
break;
case 6:
System.out.println("D");
break;
default:
System.out.println("E");
break;
}
缺點(diǎn)：不能寫條件遍愿，只能匹配值存淫，使用場(chǎng)景少
循環(huán)語(yǔ)句：
? while:事前事后雙判斷，只要符合條件就重復(fù)執(zhí)行
? do while： 直接執(zhí)行沼填，事后判斷桅咆，只要符合就重復(fù)執(zhí)行
例子：
int a = 1;
while(a<6){
System.out.println(a++);
}
do{
System.out.println(a++);
}while(a<6);
for(int a = 1;a<6;a++){
//? 0.初始化表達(dá)式；1.條件表達(dá)式坞笙；3.循環(huán)后操作表達(dá)式
System.out.println(a);
//? 2.循環(huán)體
}
0.1岩饼，2，3薛夜，1籍茧，2，3梯澜，1寞冯，2，3........?
初始化表達(dá)式先執(zhí)行晚伙，僅執(zhí)行一次吮龄；
執(zhí)行條件表達(dá)式，表達(dá)式結(jié)果為TRUE執(zhí)行循環(huán)體撬腾，但是如果結(jié)果為false則直接跳出循環(huán)
執(zhí)行玩循環(huán)體后螟蝙，執(zhí)行循環(huán)后操作表達(dá)式恢恼；
執(zhí)行玩循環(huán)后操作表達(dá)式之后重新執(zhí)行條件表達(dá)式
for適合處理已知循環(huán)次數(shù)的循環(huán)問(wèn)題（int i =0;i<? ;i++）
while：適合解決未知循環(huán)次數(shù)的循環(huán)問(wèn)題 (true){ },內(nèi)部陪一個(gè)跳出條件語(yǔ)句
do while:
引用類型：
數(shù)組：
基本數(shù)據(jù)類型變量：
int a;
//變量的聲明
a = 1;
//變量的賦值
int b= 2;
//變量的初始化
數(shù)組的變量：
int []arr;
//數(shù)組的聲明
arr = new int[2];
//數(shù)組的創(chuàng)建民傻，new 開(kāi)辟內(nèi)存空間
arr[0] = 1;
//數(shù)組的賦值
arr[1] = 2;
//數(shù)組的賦值
int []brr = {1,2};
//靜態(tài)初始化
數(shù)組最小下標(biāo)0，最大數(shù)組長(zhǎng)度-1? 场斑；長(zhǎng)度是length屬性
二維數(shù)組的聲明漓踢，創(chuàng)建，遍歷
冒泡：
int [] arr = {9,4,3,1,2,8,7,6,5};
//冒泡排序
//1.先找數(shù)組中最小的數(shù)
int temp ;
int count = 0;
for(int j = 0;j<arr.length-1;j++){
//有多少個(gè)數(shù)漏隐，就挪多少次喧半，把所有數(shù)都挪過(guò)一遍，順序就自然出來(lái)
System.out.println("開(kāi)始尋找第"+(j+1)+"輪尋找最小數(shù)");
for(int i=0;i<arr.length-1-j;i++){
//把數(shù)組中從前到后青责，向臨的兩個(gè)元素進(jìn)行比較大小挺据，如果比不過(guò)就換位置，為了把最大或者最小挪到最后
System.out.print("本次比較,當(dāng)前比較的數(shù)是第"+i+"下標(biāo)"+arr[i]+",和第"+(i+1)+"下標(biāo)"+arr[i+1]+"? " );
if(arr[i]<arr[i+1]){
//比較前后數(shù)的大小脖隶，互換位置
temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
System.out.println("本次比較發(fā)現(xiàn)"+arr[i]+"大于"+arr[i+1]+",所以互相換位置? ");
}
for (int z = 0; z < arr.length; z++) {
System.out.print(arr[z]+",");
}
System.out.println();
count++;
}
}
System.out.println("~~~~~~~");
System.out.println(count);
選擇：
int arr[] = {192,976,23,56,768,342,132,56,9,4,0,123};
int temp;
//找到當(dāng)前最大的數(shù) 扁耐，直接把最大的數(shù)和最后一個(gè)數(shù)交換
int maxIndex ;
//記錄當(dāng)前最大值的下標(biāo)
for(int j = 0;j<arr.length-1;j++){
//找多少輪最大值，有多少數(shù)找多少次
maxIndex = 0;
//默認(rèn)最左邊0下標(biāo)為當(dāng)前的初始最大值下標(biāo)
for(int i= 0;i<arr.length-j;i++){
//從第一個(gè)數(shù)進(jìn)行比較一直比較到能比較的最后一個(gè)數(shù)
if(arr[maxIndex]<arr[i]){
//如果比較后發(fā)現(xiàn)當(dāng)前默認(rèn)最大值比不過(guò)产阱，那被比較的值應(yīng)該是新的最大值婉称，記錄它的下標(biāo)
maxIndex = i;
}
}
if(maxIndex != arr.length-1-j){
//如果最大值的下標(biāo)和應(yīng)該的位置不匹配，則互換值
temp = arr[maxIndex];
arr[maxIndex] = arr[arr.length-1-j];
arr[arr.length-1-j] = temp;
}
}
for(int i:arr){
//輸出
System.out.print(i+",");
}
二維數(shù)組的遍歷：
int [][]brrs = {{1,2,3},{4,5,6},{28,1}};
for(int j =0;j<arrs.length;j++){
for(int i=0;i<arrs[j].length;i++){
System.out.print(arrs[j][i]+",");
}
System.out.println();
}
方法:函數(shù)的聲明和調(diào)用(不用對(duì)象參與叫函數(shù)，需要對(duì)象調(diào)用才是方法)
? ? 函數(shù)的優(yōu)點(diǎn)：1.代碼量變少王暗，變整潔
? ? 2.可讀性強(qiáng)
? ? 3.忽略細(xì)節(jié)
? ? 4.易于維護(hù)和修改
? ? 函數(shù) 的聲明：只是創(chuàng)建了一個(gè)帶有某種特定功能的代碼塊悔据，自己不能運(yùn)行，必須被調(diào)用
? ? 語(yǔ)法：
? ? 所謂實(shí)參：是為了滿足函數(shù)功能必須給予的基礎(chǔ)數(shù)據(jù)
? ? 所謂形參：由于聲明函數(shù)的時(shí)候沒(méi)有實(shí)際數(shù)據(jù)俗壹，但是為了完成代碼算法的編寫
? ? 公式中需要臨時(shí)代替數(shù)據(jù)參與的變量科汗；其實(shí)就是函數(shù)的局部變量。
? ? public? ? static? ? void|datatype? ? functionName (datatype varname [,...]){
? ? // 權(quán)限控制? 修飾符? ? 沒(méi)有|返回值類型? ? 函數(shù)名字? (數(shù)據(jù)類型 變量名)形參列表
? ? //函數(shù)的代碼塊（固定的功能代碼）
? ? [return? data ;]
? ? //如果不用void則必須return 绷雏；return永遠(yuǎn)只能是當(dāng)前函數(shù)的最后一句話
? ? }
? ? 函數(shù)的調(diào)用：具體執(zhí)行函數(shù)的功能
? ? ? ? functionName (data[,...])
? ? ? // 使用的函數(shù)名字? ()實(shí)參列表)
? ? 重載：
? ? 一個(gè)類中肛捍，同名的方法
? ? 參數(shù)列表不同：個(gè)數(shù)不同，類型不同
面向?qū)ο螅?/p>
what：
面向?qū)ο蟮乃枷耄菏且环N編程思想
面向?qū)ο蟮奶匦裕悍庋b之众，繼承拙毫，多態(tài) ！
面向?qū)ο蟮恼Z(yǔ)言：java語(yǔ)言有關(guān)面向?qū)ο蟮恼Z(yǔ)法棺禾！
why：
解決復(fù)雜問(wèn)題缀蹄，大型軟件的開(kāi)發(fā)和維護(hù)問(wèn)題
how：
解決對(duì)象
? 對(duì)象：現(xiàn)實(shí)世界在代碼中的代表，把一個(gè)復(fù)雜的現(xiàn)實(shí)問(wèn)題抽象成代碼中的對(duì)象來(lái)解決問(wèn)題膘婶。
? 需要計(jì)算機(jī)提供對(duì)象缺前，（計(jì)算機(jī)如何知道對(duì)象應(yīng)該是啥樣的？悬襟？）
? 類class:
? 語(yǔ)法：class{
? 類的成員：
? 屬性
? 方法
? // 塊衅码，嵌套類
? }
類是對(duì)象的模板，對(duì)象是類 的代表
對(duì)象的誕生：
類名? 引用? =? new? 構(gòu)造器;
引用和對(duì)象的區(qū)別：
引用是保存對(duì)象的地址值脊岳，通過(guò)引用來(lái)代指對(duì)象逝段。
匿名對(duì)象:沒(méi)有引用的對(duì)象。
優(yōu)點(diǎn)：省內(nèi)存割捅。
缺點(diǎn)：不能重復(fù)使用奶躯。
建議：優(yōu)先使用，但是如果發(fā)現(xiàn)需要重復(fù)使用則一定不能用匿名亿驾。
構(gòu)造器語(yǔ)法：
構(gòu)造器的名字必須和所在類的名字完全一樣嘹黔。
類名 (形參列表){
代碼塊
}
默認(rèn)構(gòu)造器：
構(gòu)造器可以不寫，系統(tǒng)默認(rèn)送一無(wú)參莫瞬，無(wú)內(nèi)容的構(gòu)造器儡蔓；但凡有一個(gè)構(gòu)造器則系統(tǒng)不送了
構(gòu)造器和方法 的區(qū)別：
? 構(gòu)造器也叫構(gòu)造方法（一方面長(zhǎng)得像，功能也像疼邀；永遠(yuǎn)都不是方法）
? 構(gòu)造器永遠(yuǎn)沒(méi)有返回值喂江，不需要寫void，（除了權(quán)限控制符）也不能有其他的修飾符
構(gòu)造器重載：
? 構(gòu)造器允許有多個(gè)檩小，多個(gè)構(gòu)造器可以發(fā)生重載开呐，（形參列表不一致）
? ? 構(gòu)造器的作用：
? ? ? 創(chuàng)建對(duì)象（程序員寫的構(gòu)造器跟創(chuàng)建對(duì)象無(wú)關(guān)）
? ? ? 為了對(duì)象的初始化
構(gòu)造器的內(nèi)存：
? 構(gòu)造器默認(rèn)生產(chǎn)的對(duì)象，每個(gè)對(duì)象都有自己獨(dú)立的屬性，方法統(tǒng)一筐付。
this的作用：
第一種作用卵惦，當(dāng)"this." ,代表當(dāng)前正在運(yùn)行或者使用或者生產(chǎn)的對(duì)象（當(dāng)前對(duì)象）。
第二種作用瓦戚，當(dāng)"this()",代表當(dāng)前類的某個(gè)構(gòu)造器
this.用來(lái)區(qū)分局部變量和對(duì)象的屬性
this(),用來(lái)構(gòu)造器沮尿，代碼的復(fù)用
this()只能第一行；和super()不能同時(shí)使用
當(dāng)發(fā)生繼承的時(shí)候如何構(gòu)造：
先運(yùn)行super较解，再運(yùn)行this
繼承：
什么類可以繼承另外一個(gè)類（什么時(shí)候應(yīng)該使用繼承）
當(dāng)子類是父類
繼承的實(shí)現(xiàn)畜疾，優(yōu)缺點(diǎn)
java語(yǔ)法中一個(gè)類只要被extends 就能成為另一個(gè)類的父類；一個(gè)類只能有一個(gè)父類印衔；
如果父類沒(méi)有無(wú)參的構(gòu)造器啡捶，子類則必須調(diào)用有參的super才可以不報(bào)錯(cuò)；
代碼簡(jiǎn)潔奸焙，支持復(fù)用
不能任意代碼都拷貝瞎暑，子類語(yǔ)法受到父類的限制，只能使用1次繼承与帆，每次子類誕生其
實(shí)都同時(shí)誕生了一個(gè)父類對(duì)象了赌，子類代碼依賴父類代碼
子類和父類的代碼如何調(diào)用
子類實(shí)例化生成對(duì)象前需要先調(diào)用父類構(gòu)造器，每一個(gè)子類對(duì)象的生產(chǎn)都伴隨一個(gè)它
的父類對(duì)象誕生,通過(guò)super()實(shí)現(xiàn)父類對(duì)象的誕生
super的作用:
第一種作用玄糟，當(dāng)"super." ,代表當(dāng)前正在運(yùn)行或者使用或者生產(chǎn)的對(duì)象的父類對(duì)象（當(dāng)前對(duì)象）勿她。
第二種作用，當(dāng)"super()",代表當(dāng)前類的父類的某個(gè)構(gòu)造器
super()只能第一行阵翎；和this（）不能同時(shí)使用
子類對(duì)象和父類對(duì)象的關(guān)系
每一個(gè)子類對(duì)象都有一個(gè)super指向他自己的父類對(duì)象逢并，子類自身沒(méi)有父類的任何代碼，只能通過(guò)
父類對(duì)象取獲取父類的資源
繼承如何在封裝中體現(xiàn)
繼承如何實(shí)現(xiàn)多態(tài)
封裝：隱藏某些細(xì)節(jié)或者內(nèi)容贮喧。
利用訪問(wèn)權(quán)限控制符實(shí)現(xiàn)隱藏筒狠。
包：
package：物理上文件夾，邏輯上功能相似的類
打包：package 告訴計(jì)算機(jī)當(dāng)前類屬于哪個(gè)包
引包：import 告訴計(jì)算機(jī)需要哪個(gè)包的類來(lái)幫助運(yùn)行
默認(rèn)引的包：java.lang 語(yǔ)言包（String 箱沦，Object，System）
訪問(wèn)權(quán)限控制符 private? default? protected? public
私有的? 默認(rèn)的? ? 受保護(hù)的? 公有的
從小~~~~到
public:所有人都可以看到和使用
private：所有人都無(wú)法看到和使用除了自己,(子類也無(wú)法使用)
default:同一個(gè)包中可以使用
protected:同一個(gè)包中可以使用雇庙，如果是別的包想用（別的包中的類必須是當(dāng)前類的子類才能用）
把屬性私有（private）,同時(shí)提供公有（public）set(賦值)|get(獲取值)的方法
多態(tài)：不修改代碼谓形，調(diào)整功能通過(guò)添加子類重寫方法，調(diào)用父類引用傳入子類對(duì)象來(lái)實(shí)現(xiàn)疆前。
1.數(shù)據(jù)類型可以轉(zhuǎn)換 2.子類是一個(gè)完美父類 3.子類可以選擇自己的行為
? 一種事物多種形態(tài)
? 語(yǔ)法：一.方法的重寫
? ? 重寫和重載的相同點(diǎn)：
? ? 1.方法的名字都相同
? ? 不同點(diǎn)：
? ? 1.位置不同：重載一個(gè)類中
? ? 重寫在父類和子類中寒跳，
? ? 2.參數(shù)列表：重載形參不一致（個(gè)數(shù)，類型）
? ? 重寫形參一致
? ? ? 3.返回值：重載不看返回值
? ? ? ? 重寫返回值必須相同
? ? ? 重寫的兩個(gè)方法的返回值和形參必須完全相等
? 二.引用數(shù)據(jù)類型的轉(zhuǎn)換
? 引用數(shù)據(jù)類型部分能轉(zhuǎn)竹椒，部分不能轉(zhuǎn)童太。看繼承
? 如果兩個(gè)引用類型存在繼承關(guān)系，編譯不報(bào)錯(cuò)书释，如果是子類轉(zhuǎn)父類可以翘贮，如果是父類轉(zhuǎn)子類運(yùn)行報(bào)錯(cuò)（除非父類對(duì)象原本是子類轉(zhuǎn)的），
? 爆惧；如果不存在繼承關(guān)系編譯直接報(bào)錯(cuò)狸页； ?
? ? 顯示轉(zhuǎn)換：
? ? char a = 'a';
? ? (int) a ;
? ? (Boolean)a;
? ? Person p = new Person();
? ? (Monkey)p
? ? 父類轉(zhuǎn)子類需要顯示轉(zhuǎn)換
? ? 向下轉(zhuǎn)型
? ? 隱式轉(zhuǎn)換：
? ? 子類對(duì)象可以直接隱式轉(zhuǎn)換成父類對(duì)象；
? ? 向上轉(zhuǎn)型
其他多態(tài)：
接口：
抽象類的進(jìn)階：接口 扯再，沒(méi)有構(gòu)造器
what:不是類芍耘，是一種特殊的代碼塊（嵌套級(jí)別和類一樣）；本身是用來(lái)對(duì)java單繼承的補(bǔ)充（利用接口多實(shí)現(xiàn)）
單繼承（只能有一個(gè)父類）熄阻，多實(shí)現(xiàn)（可以實(shí)現(xiàn)多個(gè)接口）
[public]? Interface? interfaceName{
[public] [final] [static] datatype varname = value;
[public] [abstract] [datatype|void] functionName(datatype varname [,...]);
}
where: 子類實(shí)現(xiàn) （implements）
how:
接口的成員： 常量和抽象方法
一個(gè)類如果實(shí)現(xiàn)一個(gè)接口斋竞，則必須實(shí)現(xiàn)這個(gè)接口的所有抽象方法，如果不實(shí)現(xiàn)則子類變成抽象類
why:為了不破壞java的單繼承秃殉，（一個(gè)子類主繼承誰(shuí)窃页？父類（父類繼承資源），接口留下要求）
多繼承問(wèn)題：
內(nèi)部類：類的成員
what：
內(nèi)部類的分類：
1.成員內(nèi)部類：正常的內(nèi)部類
2.靜態(tài)內(nèi)部類：靜態(tài)內(nèi)部類只能訪問(wèn)外部類的靜態(tài)資源
3.匿名內(nèi)部類：用來(lái)實(shí)現(xiàn)接口類型的對(duì)象
4.局部?jī)?nèi)部類：
public class TestInner {
public static void main(String[] args) {
Outer o = new Outer();
Outer.Inner in = new Outer().new Inner();
System.out.println(in.getA());
}
}
class Outer{
private int a = 1;
class Inner{
public int getA(){
return a;
}
public void setA(int acopy){
a = acopy;
}
}
}
why：1.方便訪問(wèn)外部類的私有資源
2.不可見(jiàn)性
3.解決多繼承沖突問(wèn)題
public class Test1 {
public static void main(String[] args) {
Z z = new Z();
z.haha();
z.new zz().haha();
}
}
class Asd{
// int a = 1;
void haha(){
}
}
interface f{
// int a = 2;
int haha();
}
class Z extends Asd {
int a = 2;
void haha(){
System.out.println("z擁有了Asd的haha無(wú)參方法"+a);
}
class zz implements f{
@Override
public int haha() {
// TODO Auto-generated method stub
System.out.println("z的zz擁有了f的haha無(wú)參方法"+a);
return 0;
}
}
}
多態(tài)的運(yùn)行：
繼承問(wèn)題：
? ? 1. 單純的父類對(duì)象指向父類引用 只能調(diào)用父類的屬性和父類的方法复濒。
? ? 2. 單純的子類對(duì)象指向子類引用 可以調(diào)用父類的屬性和父類的方法脖卖，以及自己的屬性和自己的方法
? ? ? （如果自己的屬性或者方法 和父類重復(fù)優(yōu)先使用自己的），如果非要調(diào)用父類的屬性或者方法需要+super.
? ? 多態(tài)問(wèn)題：
? ? 3. 子類對(duì)象指向父類引用 只能調(diào)用父類有的屬性和父類的方法巧颈；如果父類的屬性和父類的方法自己也有畦木；
? ? 屬性優(yōu)先調(diào)用父類的，但是方法如果自己有則優(yōu)先調(diào)用子類自己的
? ? ? （子類方法 中如果調(diào)用的屬性子類有則調(diào)用子類的砸泛，子類沒(méi)有再調(diào)用父類的）
? ? 4. 子類對(duì)象指向父類引用 如果非要使用子類自己的屬性十籍，需要先向下轉(zhuǎn)型（把子類對(duì)象的引用指回子類自己）
? ? 5. 向下轉(zhuǎn)型前需要通過(guò)instanceof來(lái)判斷對(duì)象的實(shí)際類型是否滿足子類引用
修飾符：static：
what：靜態(tài)的，類的
where：塊唇礁，屬性勾栗，方法，類
why：靜態(tài)塊一般用來(lái)給類進(jìn)行初始化
靜態(tài)屬性：有一些屬性我們希望他的值能統(tǒng)一盏筐，只存一份围俘，一份改則全改。
靜態(tài)方法：方便調(diào)用琢融，適合設(shè)計(jì)一些不需要本類的數(shù)據(jù)但是應(yīng)該歸本類提供的方法
how：
語(yǔ)法：
靜態(tài)塊：不能使用非靜態(tài)的屬性
當(dāng)?shù)谝淮蝞ew所屬類的對(duì)象或者通過(guò)類名調(diào)用靜態(tài)資源的時(shí)候會(huì)運(yùn)行靜態(tài)塊的代碼
但是只運(yùn)行一次界牡，而且首先運(yùn)行
靜態(tài)方法：不能使用非靜態(tài)的屬性，可以使用非靜態(tài)的局部變量漾抬；
? 可以被類名直接調(diào)用宿亡，也可以被對(duì)象直接調(diào)用
靜態(tài)變量：在普通方法和構(gòu)造器 中可以使用靜態(tài)變量。沒(méi)有靜態(tài)的
? 局部變量纳令，靜態(tài)可以修飾的變量一定是屬性挽荠，這種變量也
? 叫靜態(tài)變量或者類變量（可以被類名直接調(diào)用）克胳。
? 類變量也可以正常被對(duì)象調(diào)用；
? 靜態(tài)變量在靜態(tài)塊執(zhí)行之前已經(jīng)存在
普通塊：當(dāng)生產(chǎn)對(duì)象的時(shí)候而且一定在構(gòu)造器之前運(yùn)行
內(nèi)存使用情況：
當(dāng)對(duì)象第一次被new的時(shí)候：
0.父類的靜態(tài)變量（父類加載進(jìn)方法區(qū)：java的反射）
1.先執(zhí)行父類的靜態(tài)塊的代碼圈匆，
1.2：子類的靜態(tài)變量（子類加載進(jìn)方法區(qū)）
1.3：再執(zhí)行子類的靜態(tài)塊（靜態(tài)塊永遠(yuǎn)只執(zhí)行一次漠另，永遠(yuǎn)第一個(gè)執(zhí)行）
1.5：父類的普通變量（父類對(duì)象誕生）
2.執(zhí)行父類普通塊的代碼（永遠(yuǎn)在構(gòu)造器之前執(zhí)行，每次new對(duì)象都執(zhí)行）
3.執(zhí)行父類的構(gòu)造器的代碼
3.5：子類的普通變量（子類對(duì)象誕生）
4.執(zhí)行子類的普通塊
5.執(zhí)行子類的構(gòu)造器
所有的靜態(tài)變量都保存在自己類的靜態(tài)區(qū)中臭脓，所有對(duì)象公用一個(gè)靜態(tài)變量
final：
what：最終的最后的
where：變量酗钞，方法，類
how：
final變量：常量来累，值一旦付給就不可再變
final方法：不可被重寫的方法
final類：不可被繼承
why：代碼不希望改砚作，鎖內(nèi)存
單例模式：特殊問(wèn)題的方案（來(lái)源于23種特殊的面向?qū)ο蟮脑O(shè)計(jì)模式）
案例：
要求：私有構(gòu)造器，私有靜態(tài)本類的屬性（賦值）嘹锁，公有的提供屬性的方法
class Single{
private? static Single s= new Single();
//封裝? ? ? static:靜態(tài)方法只能調(diào)用靜態(tài)屬性? 任意類型都可以作為類的屬性葫录，總點(diǎn)new出來(lái)一個(gè)對(duì)象
private Single(){
//只有構(gòu)造器私有，才能避免其他的類隨便new構(gòu)造器领猾，生產(chǎn)對(duì)象
}
public static Single getInstance(){
//方便其他類訪問(wèn)? ? ? 只有靜態(tài)的方法 才能不需要對(duì)象調(diào)用
return s;
}
}
abstract:抽象的
where:類米同，方法
how:
抽象方法：沒(méi)有代碼塊，在形參列表后用分號(hào)結(jié)尾摔竿；
? 一旦一個(gè)類中有抽象方法面粮，則這個(gè)類也必須抽象，
? 注定永遠(yuǎn)不會(huì)被執(zhí)行也無(wú)法執(zhí)行继低，
? 不能被靜態(tài)修飾熬苍，
? 不能被final修飾，
抽象類：不能被實(shí)例化袁翁，可以有構(gòu)造器
抽象類可以全是抽象方法柴底；抽象了也可以沒(méi)有抽象方法
子類如何繼承一個(gè)抽象類作為父類，則要不然實(shí)現(xiàn)所有的抽象方法粱胜，要不然自己變成抽象類
why：抽象方法為了被重寫
抽象類為了被繼承
抽象類的抽象方法可以看作父類對(duì)子類的要求柄驻，子類應(yīng)該盡可能實(shí)現(xiàn)（覆蓋）父類的要求
異常：
錯(cuò)誤：int a ; 沒(méi)有初始化的變量直接被使用報(bào)錯(cuò)，語(yǔ)法錯(cuò)誤（書寫錯(cuò)誤）
異常：1.下標(biāo)越界焙压，/0? 運(yùn)行時(shí)異常鸿脓，（邏輯上錯(cuò)誤）
? 2.語(yǔ)法無(wú)誤，但是編譯出錯(cuò)（不想運(yùn)行的異常冗恨，通過(guò)一場(chǎng)處理方案調(diào)整不錯(cuò)）檢查性異常
異常處理的方案：
1.積極方案：
try ..catch:
try:監(jiān)視問(wèn)題代碼答憔，在try塊中的代碼如果出問(wèn)題，會(huì)自動(dòng)new一個(gè)異常的對(duì)象發(fā)送給catch進(jìn)行匹配
一旦被try捕獲則停止繼續(xù)執(zhí)行try塊里的代碼
catch:捕獲try提供的異常掀抹，看是否和參數(shù)的類型匹配如果匹配則執(zhí)行catch塊的代碼，
? catch可以提供多個(gè)心俗，但是異常的類型必須從小到大（繼承關(guān)系）
finally:無(wú)論發(fā)生什么情況一定會(huì)執(zhí)行傲武，只要進(jìn)入try肯定要執(zhí)行finally的代碼（函數(shù)跳出也要執(zhí)行）
2.消極方案：
throws:拋出（甩鍋）蓉驹，throws一般放在方法的形參列表后面 + 異常的類型：
? 如果該方法中發(fā)現(xiàn)相同類型的異常，則把異常對(duì)象拋出給調(diào)用方揪利，
? 兩種結(jié)果：第一種态兴，誰(shuí)都不處理，交給java虛擬機(jī)疟位。
? ? ? ? ? ? 第二種瞻润，中間使用trycatch 處理問(wèn)題。
throw：拋（補(bǔ)全異常類型）
把異常對(duì)象拋給異常處理模塊
public static void main(String[] args) throws NewException {
int age = 10;
if(age<18){
throw? new NewException();
}
}
public class NewException extends Exception{
}
API：
UTIL:
Object ：
toString:把對(duì)象轉(zhuǎn)成字符串來(lái)方便表示甜刻，格式如下：getClass().getName() + "@" + Integer.toHexString(hashCode())
hashcode:哈希值不相等則對(duì)象一定不相等绍撞；反之不一定相等。
equals:Object類的equals比較兩個(gè)對(duì)象的地址值得院，如果相等則true否則false,
? 如果自定義類想要使用equals建議重寫傻铣。
? 如果重寫equals應(yīng)該一起重寫hashcode
? ? finalize：當(dāng)對(duì)象被垃圾回收器回收的時(shí)候由垃圾回收起運(yùn)行。
? ? 1.需要引用賦值為null祥绞，2.所在類重寫finalize方法非洲，3.手動(dòng)調(diào)用System.gc();
? ? ? ? 包裝類：
? ? ? Integer:int
? ? ? intValue:把包裝類的值轉(zhuǎn)成基本數(shù)據(jù)類型
? ? ? ！Ｍ删丁两踏！parseInt:把字符串轉(zhuǎn)成對(duì)應(yīng)的包裝類
? ? ? !!!高速緩存：建議如果要使用的包裝類對(duì)象是-128~127之間通過(guò)valueOf來(lái)獲取
? ? ? 常用API:
? ? ? Integer i1 = new Integer(10);
System.out.println(i1.toString());
System.out.println(i1.compareTo(new Integer(0)));
//比較兩個(gè)Integer對(duì)象，相等=0兜喻，大于1小于-1
System.out.println(i1.hashCode());
System.out.println(Integer.max(1, 3));
System.out.println(Integer.toBinaryString(9));
System.out.println(Integer.toHexString(9));
System.out.println(Integer.toOctalString(9));
System.out.println(Integer.valueOf(10));
!!自動(dòng)拆/裝箱：
Integer i3 = 111;//把一個(gè)基本數(shù)據(jù)類型直接當(dāng)對(duì)象使用梦染，自動(dòng)裝箱
System.out.println(i3-1);//把一個(gè)對(duì)象直接當(dāng)基本數(shù)據(jù)類型來(lái)使用，自動(dòng)拆箱
? ? ? Character:char：無(wú)法把字符串轉(zhuǎn)成字符
? ? ? API:
? ? ? System.out.println(Character.isDigit('1'));//字母是否是數(shù)字內(nèi)容
System.out.println(Character.isLetter('啊'));//是否是文字
System.out.println(Character.isWhitespace('\n'));//是否空格或者換行
System.out.println(Character.toLowerCase('C'));//大小寫轉(zhuǎn)換
System.out.println(Character.toUpperCase('a'));
System.out.println(Character.isLetterOrDigit('c'));//是否字母或者數(shù)字
System.out.println(Character.isLowerCase('C'));//是否小寫
System.out.println(Character.isUpperCase('c'));//是否大寫
? ? ? Boolean:boolean
? ? ? Boolean b = Boolean.valueOf("fasle"); //字符串非真全是假
? ? ? Byte:byte
? ? ? Float:float? :浮點(diǎn)型沒(méi)有告訴緩存
? ? ? Double:double
? ? ? Short:short
? ? ? Long:long ? ?
String:
設(shè)計(jì)說(shuō)明：
? ? 1.字符串的內(nèi)容都保存在一個(gè)value引用指向的字符數(shù)組對(duì)象中虹统，為了節(jié)省空間弓坞。
? ? 2.由于所有相同內(nèi)容的字符串可能引用同一個(gè)value空間，所以不能隨便修改车荔，value要求常量渡冻，私有不允許隨便改。
1.構(gòu)造器：
1.無(wú)參
? String s1 = new String();
String s2 = null;
System.out.println(s2.length());
System.out.println(s1.length());
//生成了字符串對(duì)象忧便，只不過(guò)內(nèi)容沒(méi)有匆篓，但是空間存在，可以正常使用方法浩嫌。
2.參數(shù)為字符數(shù)組的
字面量的隱藏代碼：
char c1[] = {'a','b','c'};
String s3 = new String(c1);
3.參數(shù)為字符串的
String s5 = new String("abc");
4.參數(shù)為字節(jié)數(shù)組的
字符串編碼問(wèn)題：
String Client = new String("abc你我他".getBytes("utf-8"),"iso8859-1");
String Server = new String(Client.getBytes("iso8859-1"),"utf-8");
2.字面量："字符串類型的對(duì)象"葬馋，所有字符串對(duì)象都是常量（字符串類型的引用不是）
字面量的字符串對(duì)象有系統(tǒng)優(yōu)化，對(duì)象在常量池中誕生蒂教，有且僅有一份巍举，所有內(nèi)容相同的字面量是同一份內(nèi)存
String s = "abc";//誕生了一個(gè)對(duì)象
String s1 = new String("abc");//誕生了new 的對(duì)象，如果“abc” 之前存在則不需要誕生凝垛，如果不存在則需要誕生
System.out.println(s1);
intern :
String s6 =s5.intern();
//返回一個(gè)常量池中的字符串對(duì)象,如果當(dāng)前池中有對(duì)象則直接返回對(duì)象的地址懊悯，
//如果沒(méi)有則先把當(dāng)前值放到常量池中去再返回當(dāng)前的地址
//能夠強(qiáng)行把堆空間的字符串升到常量池中去
3.（高效）字符串拼接：
StringBuffer :可變字符序列蜓谋，線程安全， 速度稍慢炭分，append追加 桃焕，
StringBuilder:可變字符序列，線程不安全捧毛，速度較快观堂，append追加。
public static void main(String[] args) {
String s1 = "abc";
StringBuffer sb = new StringBuffer(s1);
for(int i =0;i<100000;i++){
sb.append(i);
}
s1 =sb.toString();
System.out.println(s1.length());
}
4.常用API：
String s = ";AAab;cdef;abcd;";
String s1 = new String(s);
System.out.println(s.charAt(5));//根據(jù)坐標(biāo)返回對(duì)應(yīng)的字母呀忧，拿他能取首字母
System.out.println(s.substring(5, 8));//對(duì)字符從開(kāi)始坐標(biāo)截取到終止坐標(biāo)前一個(gè)
System.out.println(s.length());//求字符的個(gè)數(shù)
System.out.println(s.trim());//去兩端空格
System.out.println(s.endsWith("bcd"));//判斷是否以某個(gè)字符串結(jié)尾
System.out.println(s.equals(s1));
System.out.println(s.compareTo("abcdefabcd"));//根據(jù)字典順序比較大小 0相等 正數(shù)大于 負(fù)數(shù)小于
System.out.println(s.concat("hahaha"));//字母串拼接
System.out.println(s.contains("wxy"));//是否包含字符串
System.out.println(s.indexOf("bc"));//獲取字符串的位置
System.out.println("".isEmpty());//判斷字符串內(nèi)容是否為空字符串
System.out.println(s.lastIndexOf("bc"));//從后往前找字符串的位置（位置永遠(yuǎn)是從做往右算）
System.out.println(s.replace("abc", "$"));//字符串替換
System.out.println(s.startsWith("abc"));
System.out.println(s.toLowerCase()); //轉(zhuǎn)小寫
System.out.println(s.toUpperCase());//轉(zhuǎn)大寫
String sarr[]= s.split(";");//根據(jù)符號(hào)對(duì)字符串拆分,前有分隔符可以拆师痕，后有不算，$不好使
System.out.println(sarr[3]);
char c [] = s.toCharArray();
byte b[] =s.getBytes();
郵箱：
String mail = "asdas@c123.cn";
String []mailarr = mail.split("@");
char arr[] = mailarr[0].toCharArray();
char c = mail.charAt(0);
if((c>=97&&c<=122) ||(c>=65&&c<=90)){
if((mail.endsWith(".com")||mail.endsWith(".cn"))){
if(mailarr.length==2){
if(mailarr[1].indexOf(".")==mailarr[1].lastIndexOf(".")){
for(int i =1 ;i<arr.length;i++){
if(!((arr[i]>=97&&arr[i]<=122) ||(arr[i]>=65&&arr[i]<=90)||Character.isDigit(arr[i]))){
System.out.println("@前只能由數(shù)字或者字母組成");
? break;
}
}
}else{
System.out.println(".符號(hào)在@之后有且僅能有一個(gè)");
}
}else{
System.out.println("@規(guī)定只能有一個(gè)");
}
}else{
System.out.println("結(jié)尾只能是.com或者.cn");
}
}else{
System.out.println("首字符應(yīng)該是字母");
}
Math:
System.out.println(Math.E);
System.out.println(Math.PI);
System.out.println(Math.abs(-13));
System.out.println(Math.ceil(13.9));
System.out.println(Math.floor(13.1));
System.out.println(Math.exp(3.0));
System.out.println(Math.log(10));
System.out.println(Math.log10(10));
System.out.println(Math.sqrt(4));
System.out.println(Math.round(13.4));
System.out.println(Math.pow(3, 4));
System.out.println(Math.random());//大于等于0 并且小于1
隨機(jī)數(shù)：
Random r = new Random(10);
for(int i=0;i<10;i++){
// System.out.println(Math.floor(Math.random()*10)+1);
System.out.println(r.nextInt(100)+1);//大于等于0荐虐，小于參數(shù)
}
Date:日期
Date d = new Date();
//不支持時(shí)區(qū)
System.out.println(d);
d.setYear(2018-1900);
System.out.println(d.getYear()+1900);//1900年到現(xiàn)在多少年
System.out.println(d.getMonth());//0~11
System.out.println(d.getDate()); //一個(gè)月的第幾天
System.out.println(d.getDay()); //一周的第幾天
System.out.println(d.getHours());
System.out.println(d.getMinutes());
System.out.println(d.getSeconds());
System.out.println(d.getTime());//1970年到現(xiàn)在的毫秒數(shù)
Calendar：日歷 七兜，抽象類，獲取的永遠(yuǎn)是子類的對(duì)象
Calendar c = Calendar.getInstance();
System.out.println(c.get(Calendar.YEAR));
System.out.println(c.get(Calendar.MONTH));
System.out.println(c.get(Calendar.DATE));
System.out.println(c.get(Calendar.HOUR));
System.out.println(c.get(Calendar.MINUTE));
System.out.println(c.get(Calendar.SECOND));
System.out.println(c.get(Calendar.DAY_OF_YEAR));
System.out.println(c.get(Calendar.DAY_OF_WEEK));
System.out.println(c.getTime().getTime());
//1548729018840
c.setTime(new Date(1548729018840l));
SimpleDateFormat:
Date d = new Date();//創(chuàng)造日期
System.out.println(d);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
//創(chuàng)造格式
String? date = sdf.format(d);
System.out.println(date); //通過(guò)格式轉(zhuǎn)換日期
System.out.println(sdf.parse(date)); //把符合格式的字符串轉(zhuǎn)回日期
? ? 集合：
? ? what:是一種存放使用數(shù)據(jù)的容器福扬。
? ? 數(shù)組的長(zhǎng)度是固定的腕铸，數(shù)組容器元素的類型是統(tǒng)一的
? ? 集合不需要固定長(zhǎng)度，隨用隨漲铛碑；集合中可以存放任意類型的數(shù)據(jù)
? ? why：替代數(shù)組的方案
? ? how：? 元素的存儲(chǔ)狠裹，修改，提取
? ? int arr [] = new int[5];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
arr[3] = 4;
arr[4] = 5;
System.out.println(arr);
arr[0] = 10;
System.out.println(arr[0]);
ArrayList al = new ArrayList();
al.add(1);
al.add(2);
al.add(3);
al.add(4);
al.add(5);
al.add(new Date());
System.out.println(al);
al.set(0, 10);
System.out.println(al.get(0));?
? ? 1.集合的框架：
? ? 背圖
? ? 2.集合常用API
? ? list：
? ? al.isEmpty();
? ? al.add(1);
? ? al.set(0, 10);
? ? al.size()汽烦；
? ? al.contains(2)
? ? al.remove(0);
? ? al.toArray();
? ? al.indexOf(3)
? ? al.clear();
? ? al.get(0);
? ? Map：
? ? HashMap hm = new HashMap();
hm.put("一", "haha");//把鍵值對(duì)放入容器
hm.put("一", "gaga");
hm.put("二", "hehe");
System.out.println(hm.remove("二"));
System.out.println(hm.get("二"));
System.out.println(hm.containsKey("一"));
System.out.println(hm.size());
System.out.println(hm.isEmpty());
// System.out.println(hm.replace("一", "gaga"));
System.out.println(hm.values());
System.out.println(hm);
Map集合的遍歷：
//1.keySet
Set s = hm.keySet();
Iterator it = s.iterator();
while(it.hasNext()){
System.out.println(hm.get(it.next()));
}
//2.entrySet
Set s1 = hm.entrySet();
Iterator it1 =s1.iterator();
while(it1.hasNext()){
Entry entry=(Entry)it1.next();
System.out.println(entry.getKey()+"? "+entry.getValue());
}
? ? 3.迭代器：
? ? Iterator it = hs.iterator();
//it=利用hs集合對(duì)象獲取一個(gè)hs集合專用的迭代器
while(it.hasNext()){
System.out.println(it.next());
}
迭代器模式
? ? 4.集合的工具類
? ? Collections 和Collection的區(qū)別涛菠？
? ? 一個(gè)是工具類，一個(gè)是線性集合的父接口
? ? Collections.sort(al);
System.out.println(Collections.max(al));
Collections.reverse(al);
? ? 5.集合中泛型的使用
? ? 泛型：集合中的泛型用來(lái)約束元素的數(shù)據(jù)類型
? ? IO流
? ? 文件：
? ? File：路徑
? ? API:
? ? File f = new File("C:/test1");
// f.createNewFile();
//創(chuàng)建新文件
f.delete();
//刪除路徑上的資源
f.mkdir();
//創(chuàng)建文件夾
// f.mkdirs();
//創(chuàng)建指定路徑的文件夾
System.out.println(f.exists());
//路徑上是否有資源
System.out.println(f.getAbsolutePath());
//獲取絕對(duì)路徑
System.out.println(f.isDirectory());
//判斷是否為文件夾
System.out.println(f.getParentFile());
//獲取當(dāng)前路徑的父路徑
System.out.println(f.getName());
//當(dāng)前路徑的文件名
System.out.println(f.canExecute());
//能否執(zhí)行
System.out.println(f.canRead());//能不能讀
System.out.println(f.canWrite());//能不能寫
System.out.println(f.isHidden());//是否隱藏
File farr[] = f.listFiles();//返回當(dāng)前路徑的下一層子路徑
System.out.println(farr[0]);
System.out.println(farr[1]);
? ? 常用流：數(shù)據(jù)傳輸過(guò)程中形成的管道
? ? 三種流分類：
? ? 方向：輸入撇吞，輸出
? ? 內(nèi)容：字節(jié)俗冻，字符
? ? 能力：節(jié)點(diǎn)，處理（低級(jí)牍颈，高級(jí)）:高級(jí)流必須依賴低級(jí)流
? ? FileWriter f = new FileWriter(filename, append) //append 決定輸出文件是否覆蓋源文件內(nèi)容
? ? 文本文件的拷貝：
? ? //1.找到數(shù)據(jù)源
File fsr = new File("E:/timg.jpg");
//2.通過(guò)數(shù)據(jù)源獲取文件名字
String filename = fsr.getName();
//3.通過(guò)名字在另一個(gè)空間生成新文件
File newFile = new File("D:/"+filename);
newFile.createNewFile();
//4.把源數(shù)據(jù)復(fù)制新文件中
//4.1 讀取源數(shù)據(jù)（1次讀一個(gè)迄薄，往新文件中寫一個(gè)），一直讀寫到源文件結(jié)束
FileReader fr = new FileReader(fsr);
FileWriter fw = new FileWriter(newFile);
int a = fr.read();
while(a!=-1){
fw.write(a);
a = fr.read();
}
fw.flush();
? ? 二進(jìn)制文件的拷貝：
? ? //1.找到數(shù)據(jù)源
File fsr = new File("E:/11.mp4");
//2.通過(guò)數(shù)據(jù)源獲取文件名字
String filename = fsr.getName();
//4.1 讀取源數(shù)據(jù)（1次讀一個(gè)煮岁，往新文件中寫一個(gè)）讥蔽，一直讀寫到源文件結(jié)束
FileInputStream fr = null;
FileOutputStream fw = null;
try {
fr = new FileInputStream(fsr);
fw = new FileOutputStream("D:/"+filename);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
BufferedInputStream bis = new? BufferedInputStream(fr);
BufferedOutputStream bos = new BufferedOutputStream(fw);
byte[] b = new byte[4096];
//高速緩存
int a;
try {
a = bis.read(b);
while(a!=-1){
bos.write(b,0,a);
a = bis.read(b);
}
bos.flush();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
bis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
bos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
fr.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
fw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
序列化：
public class TestObject {
public static void main(String[] args) throws IOException {
People p1 = new People();
p1.name = "hehe";
p1.age = 18;
File f = new File("C:/people.txt");
FileOutputStream fos = new FileOutputStream(f);
? ? ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(p1);
oos.flush();
oos.close();
fos.close();
}
}
class People implements Serializable{
String name;
int age;
void haha(){
System.out.println(name+"haha");
}
}
反序列化：
File f = new File("C:/people.txt");
FileInputStream fis = new FileInputStream(f);
ObjectInputStream ois = new ObjectInputStream(fis);
((People)ois.readObject()).haha();
ois.close();
fis.close();
JDBC:
mysql8.0
Class.forName("com.mysql.cj.jdbc.Driver");
Connection conn = DriverManager.getConnection("jdbc:mysql://localhost/scott?useSSL=FALSE&serverTimezone=UTC","root", "root");
Statement st = conn.createStatement();
ResultSet rs = st.executeQuery("select ename,job from emp where deptno = 10");
while (rs.next()) {
System.out.println(rs.getString("ename")+","+rs.getString("job"));
}
? ? Oracle:
? ? Class.forName("oracle.jdbc.driver.OracleDriver");
//加載驅(qū)動(dòng)
Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl", "scott", "tiger");
//通過(guò)驅(qū)動(dòng)和信息創(chuàng)建連接通道
Statement stat = conn.createStatement();
//給管道匹配一個(gè)空的sql對(duì)象
ResultSet? rs = stat.executeQuery("select ename,job from emp where deptno = 10");
//把sql語(yǔ)句綁定到對(duì)象上并且執(zhí)行,并把結(jié)果返回給結(jié)果集resultset
while(rs.next()){
//遍歷一條數(shù)據(jù)，如果還有則返回true
System.out.println(rs.getString("ename")+","+rs.getString("job"));
//根據(jù)數(shù)據(jù)的類型獲取對(duì)應(yīng)數(shù)據(jù)
}
preparestatment:
Class.forName("oracle.jdbc.driver.OracleDriver");
//加載驅(qū)動(dòng)
Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl", "scott", "tiger");
//通過(guò)驅(qū)動(dòng)和信息創(chuàng)建連接通道
// Statement stat = conn.createStatement();
PreparedStatement ps = conn.prepareStatement("select ename from emp where ename=? and deptno = ?");
ps.setString(1, "SMITH");
ps.setString(2, "9? or 1=1");
ResultSet rs = ps.executeQuery();
rs.next();
System.out.println(rs.getString("ename"));
DButil:
public class DButil {
static{
try {
Class.forName("oracle.jdbc.driver.OracleDriver");
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
System.out.println("數(shù)據(jù)庫(kù)蹦蹦了");
}
}
public static Connection getConn() throws ClassNotFoundException, SQLException{
//加載驅(qū)動(dòng)
Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl", "usermanager", "abc123");
conn.setAutoCommit(false);
return conn;
}
}
? ? 網(wǎng)絡(luò)? ?
