JAVA
來源：
sun公司，oracle收購
版本情況：
1.0 ....1.5(5.0)....8.0(1.8)...11(2.1)
安裝JDK ，JDK 編譯環(huán)境 ，JRE 運行環(huán)境
配置：我的電腦（屬性），高級，環(huán)境變量，系統(tǒng)變量，path（內(nèi)容的最前 + ";"在分號前復(fù)制jdk的bin目錄的位置）
javac? 文件（包括后綴）? 編譯
java? 文件的名字（沒有后綴） 運行
java語言特點：半編譯半解釋（通過jvm，多個平臺，各有自己的jvm）
源代碼(.java)->javac? -> java字節(jié)碼（.class）->java ->本地機(jī)械碼文件（cpu只能運行機(jī)械碼）
jvm：java虛擬機(jī)
main: 主函數(shù) ：代表程序的開始和程序的結(jié)束
// ：注釋 ，不能運行的代碼，給我們程序員說明程序用的
public? class? Test{
public static void main(String args[]){? //從這里開始
System.out.println("hello hehe");? //在系統(tǒng)的控制臺輸出（一定）的內(nèi)容
} //到這里結(jié)束
}
{} ：塊 代碼塊
數(shù)據(jù)類型：
基本數(shù)據(jù)類型（4類8種）：
整數(shù)：
byte:1個字節(jié) ，8位 ，-128 ~127
short:2個字節(jié)，16位，-2^15 ~2^15-1
int:4個字節(jié)，32位，-2^31 ~2^31-1 （默認(rèn)）
long:8個字節(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)換最好通過二進(jìn)制進(jìn)行中轉(zhuǎn)
浮點數(shù)：
float: 4個字節(jié)，32位
double: 8個字節(jié)，64位
默認(rèn)的所有的書面寫的浮點數(shù)都是doubule，float類型的數(shù)字默認(rèn)+f
不能參與嚴(yán)格的計算，可以用來顯示
字符：2個字節(jié) ，單引號引起來一個字符
char:本質(zhì)是short，但是通過字符表映射成字母顯示
支持轉(zhuǎn)義字符： '\''
回車：\n?
支持unicode? \u
布爾值：1個字節(jié)
boolean: true ,false
不參與算數(shù)運算，只能進(jìn)行邏輯和關(guān)系運算
引用數(shù)據(jù)類型（無數(shù)）：
數(shù)組 ：一組數(shù) []
類 ：6章
接口：7章
數(shù)據(jù)類型轉(zhuǎn)換：
顯式轉(zhuǎn)換：程序員通過代碼主動轉(zhuǎn)換
? 整數(shù) ，浮點數(shù)，字符? ；(datatype)data
? 如果大范圍的數(shù)據(jù)類型轉(zhuǎn)向小類型的范圍，有溢出的可能（看數(shù)據(jù)是否超過要轉(zhuǎn)的類型的取值范圍）
隱式轉(zhuǎn)換：計算機(jī)替程序員把數(shù)據(jù)轉(zhuǎn)換（轉(zhuǎn)的效果和顯式一樣）
? 計算機(jī)何時替我們做隱式轉(zhuǎn)換
? 小范圍自動轉(zhuǎn)大范圍
? byte，short，char 直接跳到int
? 浮點型最大
變量：
使用變量的前提：
1.聲明變量? ? int a ;
2.變量的初始化? a = 1;
作用域：塊作用域
在聲明塊及內(nèi)部的淺套塊可以使用，外部則不認(rèn)；
大作用域和嵌套作用域有同名的變量，使用的時候優(yōu)先使用離自己聲明更近的變量
函數(shù)塊里聲明的變量：局部變量
類塊聲明的變量：實例變量或者叫屬性
運算符：
算數(shù)：+ -? *? /? %?
/:兩個整數(shù)相除，結(jié)果只能還是整數(shù)，浮點去掉
%：符號看被除數(shù)
? ++ 自增? ,--
? 語法點： 位置在變量前，先完成自增運算 ，后作為一個變量來使用
? ? 位置在變量后，則先作為變量使用，最后在獨自完成自增（滯后性）
比較運算：>? <? >=? <=? ==? !=? ?
邏輯運算： 短位：? &&? , ||? ,!? （如果表達(dá)式的左邊結(jié)果已決定整個表達(dá)式的結(jié)果，則不計算右邊）
? ? ? ? ? 按位：? &? , |?
位運算：必須是整數(shù)才能計算
&? , |? ,~? ，^? ,>>? ,<<? ,>>>
計算機(jī)底層存儲補碼，一切運算都以補碼進(jìn)行
1.10進(jìn)制轉(zhuǎn)成2進(jìn)制原碼（負(fù)數(shù) 符號位1，其他和正數(shù)一樣）
? 如果正數(shù)，則直接當(dāng)補碼用
? 如果負(fù)數(shù) ， 先轉(zhuǎn)反碼（符號位不變，其他1變0，0變1），在把反碼轉(zhuǎn)補碼（符號位不變，反碼其他位+1）
? ? ? ? ? ? 2.兩個補碼運算，運算結(jié)果一定是補碼，看符號位是否0，0則直接當(dāng)原碼，轉(zhuǎn)回10進(jìn)制
? ? ? ? ? ? ? 如果符號位是1，則先把補碼（符號位不變，其他-1），在把反碼轉(zhuǎn)原碼（符號位不變，其他1變0，0變1），
? ? ? ? ? ? ? 0則直接當(dāng)原碼，轉(zhuǎn)回10進(jìn)制 ?
賦值運算：=? +=? -= *= /=? %= >>=? <<=? >>>=
邏輯上 a+=b? a= a+b ,邏輯上相等，但是實際上有區(qū)別。?
條件運算：? ? :
運算符優(yōu)先級：
1>2>3
流程控制語句：
選擇：
?:
if( 布爾值 ){ }?
如果布爾值為true，則執(zhí)行語句塊的代碼，否則不執(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");
}
缺點：不方便寫，性能差
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");
}
}
}
}
缺點亂：
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");
}
缺點：性能不極致
key:int byte? short? char? 1.7版本之后 枚舉? ，字符串
case值不能重復(fù)，
跳出：
break：跳出包含當(dāng)前break語句最近的switch或者循環(huán)塊
continue：跳出本次循環(huán)
不允許其他語句出現(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;
}
缺點：不能寫條件，只能匹配值，使用場景少
循環(huán)語句：
? 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)問題（int i =0;i<? ;i++）
while：適合解決未知循環(huán)次數(shù)的循環(huán)問題 (true){ },內(nèi)部陪一個跳出條件語句
do while:
引用類型：
數(shù)組：
基本數(shù)據(jù)類型變量：
int a;
//變量的聲明
a = 1;
//變量的賦值
int b= 2;
//變量的初始化
數(shù)組的變量：
int []arr;
//數(shù)組的聲明
arr = new int[2];
//數(shù)組的創(chuàng)建，new 開辟內(nèi)存空間
arr[0] = 1;
//數(shù)組的賦值
arr[1] = 2;
//數(shù)組的賦值
int []brr = {1,2};
//靜態(tài)初始化
數(shù)組最小下標(biāo)0，最大數(shù)組長度-1? ；長度是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++){
//有多少個數(shù)，就挪多少次，把所有數(shù)都挪過一遍，順序就自然出來
System.out.println("開始尋找第"+(j+1)+"輪尋找最小數(shù)");
for(int i=0;i<arr.length-1-j;i++){
//把數(shù)組中從前到后，向臨的兩個元素進(jìn)行比較大小，如果比不過就換位置，為了把最大或者最小挪到最后
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ù)和最后一個數(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++){
//從第一個數(shù)進(jìn)行比較一直比較到能比較的最后一個數(shù)
if(arr[maxIndex]<arr[i]){
//如果比較后發(fā)現(xiàn)當(dāng)前默認(rèn)最大值比不過，那被比較的值應(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)用(不用對象參與叫函數(shù)，需要對象調(diào)用才是方法)
? ? 函數(shù)的優(yōu)點：1.代碼量變少，變整潔
? ? 2.可讀性強(qiáng)
? ? 3.忽略細(xì)節(jié)
? ? 4.易于維護(hù)和修改
? ? 函數(shù) 的聲明：只是創(chuàng)建了一個帶有某種特定功能的代碼塊，自己不能運行，必須被調(diào)用
? ? 語法：
? ? 所謂實參：是為了滿足函數(shù)功能必須給予的基礎(chǔ)數(shù)據(jù)
? ? 所謂形參：由于聲明函數(shù)的時候沒有實際數(shù)據(jù)，但是為了完成代碼算法的編寫
? ? 公式中需要臨時代替數(shù)據(jù)參與的變量；其實就是函數(shù)的局部變量。
? ? public? ? static? ? void|datatype? ? functionName (datatype varname [,...]){
? ? // 權(quán)限控制? 修飾符? ? 沒有|返回值類型? ? 函數(shù)名字? (數(shù)據(jù)類型 變量名)形參列表
? ? //函數(shù)的代碼塊（固定的功能代碼）
? ? [return? data ;]
? ? //如果不用void則必須return ；return永遠(yuǎn)只能是當(dāng)前函數(shù)的最后一句話
? ? }
? ? 函數(shù)的調(diào)用：具體執(zhí)行函數(shù)的功能
? ? ? ? functionName (data[,...])
? ? ? // 使用的函數(shù)名字? ()實參列表)
? ? 重載：
? ? 一個類中，同名的方法
? ? 參數(shù)列表不同：個數(shù)不同，類型不同
面向?qū)ο螅?/p>
what：
面向?qū)ο蟮乃枷耄菏且环N編程思想
面向?qū)ο蟮奶匦裕悍庋b，繼承，多態(tài) ！
面向?qū)ο蟮恼Z言：java語言有關(guān)面向?qū)ο蟮恼Z法！
why：
解決復(fù)雜問題，大型軟件的開發(fā)和維護(hù)問題
how：
解決對象
? 對象：現(xiàn)實世界在代碼中的代表，把一個復(fù)雜的現(xiàn)實問題抽象成代碼中的對象來解決問題。
? 需要計算機(jī)提供對象，（計算機(jī)如何知道對象應(yīng)該是啥樣的？？）
? 類class:
? 語法：class{
? 類的成員：
? 屬性
? 方法
? // 塊，嵌套類
? }
類是對象的模板，對象是類 的代表
對象的誕生：
類名? 引用? =? new? 構(gòu)造器;
引用和對象的區(qū)別：
引用是保存對象的地址值，通過引用來代指對象。
匿名對象:沒有引用的對象。
優(yōu)點：省內(nèi)存。
缺點：不能重復(fù)使用。
建議：優(yōu)先使用，但是如果發(fā)現(xiàn)需要重復(fù)使用則一定不能用匿名。
構(gòu)造器語法：
構(gòu)造器的名字必須和所在類的名字完全一樣。
類名 (形參列表){
代碼塊
}
默認(rèn)構(gòu)造器：
構(gòu)造器可以不寫，系統(tǒng)默認(rèn)送一無參，無內(nèi)容的構(gòu)造器；但凡有一個構(gòu)造器則系統(tǒng)不送了
構(gòu)造器和方法 的區(qū)別：
? 構(gòu)造器也叫構(gòu)造方法（一方面長得像，功能也像；永遠(yuǎn)都不是方法）
? 構(gòu)造器永遠(yuǎn)沒有返回值，不需要寫void，（除了權(quán)限控制符）也不能有其他的修飾符
構(gòu)造器重載：
? 構(gòu)造器允許有多個，多個構(gòu)造器可以發(fā)生重載，（形參列表不一致）
? ? 構(gòu)造器的作用：
? ? ? 創(chuàng)建對象（程序員寫的構(gòu)造器跟創(chuàng)建對象無關(guān)）
? ? ? 為了對象的初始化
構(gòu)造器的內(nèi)存：
? 構(gòu)造器默認(rèn)生產(chǎn)的對象，每個對象都有自己獨立的屬性，方法統(tǒng)一。
this的作用：
第一種作用，當(dāng)"this." ,代表當(dāng)前正在運行或者使用或者生產(chǎn)的對象（當(dāng)前對象）。
第二種作用，當(dāng)"this()",代表當(dāng)前類的某個構(gòu)造器
this.用來區(qū)分局部變量和對象的屬性
this(),用來構(gòu)造器，代碼的復(fù)用
this()只能第一行；和super()不能同時使用
當(dāng)發(fā)生繼承的時候如何構(gòu)造：
先運行super，再運行this
繼承：
什么類可以繼承另外一個類（什么時候應(yīng)該使用繼承）
當(dāng)子類是父類
繼承的實現(xiàn)，優(yōu)缺點
java語法中一個類只要被extends 就能成為另一個類的父類；一個類只能有一個父類；
如果父類沒有無參的構(gòu)造器，子類則必須調(diào)用有參的super才可以不報錯；
代碼簡潔，支持復(fù)用
不能任意代碼都拷貝，子類語法受到父類的限制，只能使用1次繼承，每次子類誕生其
實都同時誕生了一個父類對象，子類代碼依賴父類代碼
子類和父類的代碼如何調(diào)用
子類實例化生成對象前需要先調(diào)用父類構(gòu)造器，每一個子類對象的生產(chǎn)都伴隨一個它
的父類對象誕生,通過super()實現(xiàn)父類對象的誕生
super的作用:
第一種作用，當(dāng)"super." ,代表當(dāng)前正在運行或者使用或者生產(chǎn)的對象的父類對象（當(dāng)前對象）。
第二種作用，當(dāng)"super()",代表當(dāng)前類的父類的某個構(gòu)造器
super()只能第一行；和this（）不能同時使用
子類對象和父類對象的關(guān)系
每一個子類對象都有一個super指向他自己的父類對象，子類自身沒有父類的任何代碼，只能通過
父類對象取獲取父類的資源
繼承如何在封裝中體現(xiàn)
繼承如何實現(xiàn)多態(tài)
封裝：隱藏某些細(xì)節(jié)或者內(nèi)容。
利用訪問權(quán)限控制符實現(xiàn)隱藏。
包：
package：物理上文件夾，邏輯上功能相似的類
打包：package 告訴計算機(jī)當(dāng)前類屬于哪個包
引包：import 告訴計算機(jī)需要哪個包的類來幫助運行
默認(rèn)引的包：java.lang 語言包（String ，Object，System）
訪問權(quán)限控制符 private? default? protected? public
私有的? 默認(rèn)的? ? 受保護(hù)的? 公有的
從小~~~~到
public:所有人都可以看到和使用
private：所有人都無法看到和使用除了自己,(子類也無法使用)
default:同一個包中可以使用
protected:同一個包中可以使用，如果是別的包想用（別的包中的類必須是當(dāng)前類的子類才能用）
把屬性私有（private）,同時提供公有（public）set(賦值)|get(獲取值)的方法
多態(tài)：不修改代碼，調(diào)整功能通過添加子類重寫方法，調(diào)用父類引用傳入子類對象來實現(xiàn)。
1.數(shù)據(jù)類型可以轉(zhuǎn)換 2.子類是一個完美父類 3.子類可以選擇自己的行為
? 一種事物多種形態(tài)
? 語法：一.方法的重寫
? ? 重寫和重載的相同點：
? ? 1.方法的名字都相同
? ? 不同點：
? ? 1.位置不同：重載一個類中
? ? 重寫在父類和子類中，
? ? 2.參數(shù)列表：重載形參不一致（個數(shù)，類型）
? ? 重寫形參一致
? ? ? 3.返回值：重載不看返回值
? ? ? ? 重寫返回值必須相同
? ? ? 重寫的兩個方法的返回值和形參必須完全相等
? 二.引用數(shù)據(jù)類型的轉(zhuǎn)換
? 引用數(shù)據(jù)類型部分能轉(zhuǎn)，部分不能轉(zhuǎn)?？蠢^承
? 如果兩個引用類型存在繼承關(guān)系，編譯不報錯，如果是子類轉(zhuǎn)父類可以，如果是父類轉(zhuǎn)子類運行報錯（除非父類對象原本是子類轉(zhuǎn)的），
? ；如果不存在繼承關(guān)系編譯直接報錯； ?
? ? 顯示轉(zhuǎn)換：
? ? char a = 'a';
? ? (int) a ;
? ? (Boolean)a;
? ? Person p = new Person();
? ? (Monkey)p
? ? 父類轉(zhuǎn)子類需要顯示轉(zhuǎn)換
? ? 向下轉(zhuǎn)型
? ? 隱式轉(zhuǎn)換：
? ? 子類對象可以直接隱式轉(zhuǎn)換成父類對象；
? ? 向上轉(zhuǎn)型
其他多態(tài)：
接口：
抽象類的進(jìn)階：接口 ，沒有構(gòu)造器
what:不是類，是一種特殊的代碼塊（嵌套級別和類一樣）；本身是用來對java單繼承的補充（利用接口多實現(xiàn)）
單繼承（只能有一個父類），多實現(xiàn)（可以實現(xiàn)多個接口）
[public]? Interface? interfaceName{
[public] [final] [static] datatype varname = value;
[public] [abstract] [datatype|void] functionName(datatype varname [,...]);
}
where: 子類實現(xiàn) （implements）
how:
接口的成員： 常量和抽象方法
一個類如果實現(xiàn)一個接口，則必須實現(xiàn)這個接口的所有抽象方法，如果不實現(xiàn)則子類變成抽象類
why:為了不破壞java的單繼承，（一個子類主繼承誰？父類（父類繼承資源），接口留下要求）
多繼承問題：
內(nèi)部類：類的成員
what：
內(nèi)部類的分類：
1.成員內(nèi)部類：正常的內(nèi)部類
2.靜態(tài)內(nèi)部類：靜態(tài)內(nèi)部類只能訪問外部類的靜態(tài)資源
3.匿名內(nèi)部類：用來實現(xiàn)接口類型的對象
4.局部內(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.方便訪問外部類的私有資源
2.不可見性
3.解決多繼承沖突問題
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無參方法"+a);
}
class zz implements f{
@Override
public int haha() {
// TODO Auto-generated method stub
System.out.println("z的zz擁有了f的haha無參方法"+a);
return 0;
}
}
}
多態(tài)的運行：
繼承問題：
? ? 1. 單純的父類對象指向父類引用 只能調(diào)用父類的屬性和父類的方法。
? ? 2. 單純的子類對象指向子類引用 可以調(diào)用父類的屬性和父類的方法，以及自己的屬性和自己的方法
? ? ? （如果自己的屬性或者方法 和父類重復(fù)優(yōu)先使用自己的），如果非要調(diào)用父類的屬性或者方法需要+super.
? ? 多態(tài)問題：
? ? 3. 子類對象指向父類引用 只能調(diào)用父類有的屬性和父類的方法；如果父類的屬性和父類的方法自己也有；
? ? 屬性優(yōu)先調(diào)用父類的，但是方法如果自己有則優(yōu)先調(diào)用子類自己的
? ? ? （子類方法 中如果調(diào)用的屬性子類有則調(diào)用子類的，子類沒有再調(diào)用父類的）
? ? 4. 子類對象指向父類引用 如果非要使用子類自己的屬性，需要先向下轉(zhuǎn)型（把子類對象的引用指回子類自己）
? ? 5. 向下轉(zhuǎn)型前需要通過instanceof來判斷對象的實際類型是否滿足子類引用
修飾符：static：
what：靜態(tài)的，類的
where：塊，屬性，方法，類
why：靜態(tài)塊一般用來給類進(jìn)行初始化
靜態(tài)屬性：有一些屬性我們希望他的值能統(tǒng)一，只存一份，一份改則全改。
靜態(tài)方法：方便調(diào)用，適合設(shè)計一些不需要本類的數(shù)據(jù)但是應(yīng)該歸本類提供的方法
how：
語法：
靜態(tài)塊：不能使用非靜態(tài)的屬性
當(dāng)?shù)谝淮蝞ew所屬類的對象或者通過類名調(diào)用靜態(tài)資源的時候會運行靜態(tài)塊的代碼
但是只運行一次，而且首先運行
靜態(tài)方法：不能使用非靜態(tài)的屬性，可以使用非靜態(tài)的局部變量；
? 可以被類名直接調(diào)用，也可以被對象直接調(diào)用
靜態(tài)變量：在普通方法和構(gòu)造器 中可以使用靜態(tài)變量。沒有靜態(tài)的
? 局部變量，靜態(tài)可以修飾的變量一定是屬性，這種變量也
? 叫靜態(tài)變量或者類變量（可以被類名直接調(diào)用）。
? 類變量也可以正常被對象調(diào)用；
? 靜態(tài)變量在靜態(tài)塊執(zhí)行之前已經(jīng)存在
普通塊：當(dāng)生產(chǎn)對象的時候而且一定在構(gòu)造器之前運行
內(nèi)存使用情況：
當(dāng)對象第一次被new的時候：
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)第一個執(zhí)行）
1.5：父類的普通變量（父類對象誕生）
2.執(zhí)行父類普通塊的代碼（永遠(yuǎn)在構(gòu)造器之前執(zhí)行，每次new對象都執(zhí)行）
3.執(zhí)行父類的構(gòu)造器的代碼
3.5：子類的普通變量（子類對象誕生）
4.執(zhí)行子類的普通塊
5.執(zhí)行子類的構(gòu)造器
所有的靜態(tài)變量都保存在自己類的靜態(tài)區(qū)中，所有對象公用一個靜態(tài)變量
final：
what：最終的最后的
where：變量，方法，類
how：
final變量：常量，值一旦付給就不可再變
final方法：不可被重寫的方法
final類：不可被繼承
why：代碼不希望改，鎖內(nèi)存
單例模式：特殊問題的方案（來源于23種特殊的面向?qū)ο蟮脑O(shè)計模式）
案例：
要求：私有構(gòu)造器，私有靜態(tài)本類的屬性（賦值），公有的提供屬性的方法
class Single{
private? static Single s= new Single();
//封裝? ? ? static:靜態(tài)方法只能調(diào)用靜態(tài)屬性? 任意類型都可以作為類的屬性，總點new出來一個對象
private Single(){
//只有構(gòu)造器私有，才能避免其他的類隨便new構(gòu)造器，生產(chǎn)對象
}
public static Single getInstance(){
//方便其他類訪問? ? ? 只有靜態(tài)的方法 才能不需要對象調(diào)用
return s;
}
}
abstract:抽象的
where:類，方法
how:
抽象方法：沒有代碼塊，在形參列表后用分號結(jié)尾；
? 一旦一個類中有抽象方法，則這個類也必須抽象，
? 注定永遠(yuǎn)不會被執(zhí)行也無法執(zhí)行，
? 不能被靜態(tài)修飾，
? 不能被final修飾，
抽象類：不能被實例化，可以有構(gòu)造器
抽象類可以全是抽象方法；抽象了也可以沒有抽象方法
子類如何繼承一個抽象類作為父類，則要不然實現(xiàn)所有的抽象方法，要不然自己變成抽象類
why：抽象方法為了被重寫
抽象類為了被繼承
抽象類的抽象方法可以看作父類對子類的要求，子類應(yīng)該盡可能實現(xiàn)（覆蓋）父類的要求
異常：
錯誤：int a ; 沒有初始化的變量直接被使用報錯，語法錯誤（書寫錯誤）
異常：1.下標(biāo)越界，/0? 運行時異常，（邏輯上錯誤）
? 2.語法無誤，但是編譯出錯（不想運行的異常，通過一場處理方案調(diào)整不錯）檢查性異常
異常處理的方案：
1.積極方案：
try ..catch:
try:監(jiān)視問題代碼，在try塊中的代碼如果出問題，會自動new一個異常的對象發(fā)送給catch進(jìn)行匹配
一旦被try捕獲則停止繼續(xù)執(zhí)行try塊里的代碼
catch:捕獲try提供的異常，看是否和參數(shù)的類型匹配如果匹配則執(zhí)行catch塊的代碼，
? catch可以提供多個，但是異常的類型必須從小到大（繼承關(guān)系）
finally:無論發(fā)生什么情況一定會執(zhí)行，只要進(jìn)入try肯定要執(zhí)行finally的代碼（函數(shù)跳出也要執(zhí)行）
2.消極方案：
throws:拋出（甩鍋），throws一般放在方法的形參列表后面 + 異常的類型：
? 如果該方法中發(fā)現(xiàn)相同類型的異常，則把異常對象拋出給調(diào)用方，
? 兩種結(jié)果：第一種，誰都不處理，交給java虛擬機(jī)。
? ? ? ? ? ? 第二種，中間使用trycatch 處理問題。
throw：拋（補全異常類型）
把異常對象拋給異常處理模塊
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:把對象轉(zhuǎn)成字符串來方便表示，格式如下：getClass().getName() + "@" + Integer.toHexString(hashCode())
hashcode:哈希值不相等則對象一定不相等；反之不一定相等。
equals:Object類的equals比較兩個對象的地址值，如果相等則true否則false,
? 如果自定義類想要使用equals建議重寫。
? 如果重寫equals應(yīng)該一起重寫hashcode
? ? finalize：當(dāng)對象被垃圾回收器回收的時候由垃圾回收起運行。
? ? 1.需要引用賦值為null，2.所在類重寫finalize方法，3.手動調(diào)用System.gc();
? ? ? ? 包裝類：
? ? ? Integer:int
? ? ? intValue:把包裝類的值轉(zhuǎn)成基本數(shù)據(jù)類型
? ? ? ?。?！parseInt:把字符串轉(zhuǎn)成對應(yīng)的包裝類
? ? ? !!!高速緩存：建議如果要使用的包裝類對象是-128~127之間通過valueOf來獲取
? ? ? 常用API:
? ? ? Integer i1 = new Integer(10);
System.out.println(i1.toString());
System.out.println(i1.compareTo(new Integer(0)));
//比較兩個Integer對象，相等=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));
!!自動拆/裝箱：
Integer i3 = 111;//把一個基本數(shù)據(jù)類型直接當(dāng)對象使用，自動裝箱
System.out.println(i3-1);//把一個對象直接當(dāng)基本數(shù)據(jù)類型來使用，自動拆箱
? ? ? Character:char：無法把字符串轉(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? :浮點型沒有告訴緩存
? ? ? Double:double
? ? ? Short:short
? ? ? Long:long ? ?
String:
設(shè)計說明：
? ? 1.字符串的內(nèi)容都保存在一個value引用指向的字符數(shù)組對象中，為了節(jié)省空間。
? ? 2.由于所有相同內(nèi)容的字符串可能引用同一個value空間，所以不能隨便修改，value要求常量，私有不允許隨便改。
1.構(gòu)造器：
1.無參
? String s1 = new String();
String s2 = null;
System.out.println(s2.length());
System.out.println(s1.length());
//生成了字符串對象，只不過內(nè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ù)組的
字符串編碼問題：
String Client = new String("abc你我他".getBytes("utf-8"),"iso8859-1");
String Server = new String(Client.getBytes("iso8859-1"),"utf-8");
2.字面量："字符串類型的對象"，所有字符串對象都是常量（字符串類型的引用不是）
字面量的字符串對象有系統(tǒng)優(yōu)化，對象在常量池中誕生，有且僅有一份，所有內(nèi)容相同的字面量是同一份內(nèi)存
String s = "abc";//誕生了一個對象
String s1 = new String("abc");//誕生了new 的對象，如果“abc” 之前存在則不需要誕生，如果不存在則需要誕生
System.out.println(s1);
intern :
String s6 =s5.intern();
//返回一個常量池中的字符串對象,如果當(dāng)前池中有對象則直接返回對象的地址，
//如果沒有則先把當(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)返回對應(yīng)的字母，拿他能取首字母
System.out.println(s.substring(5, 8));//對字符從開始坐標(biāo)截取到終止坐標(biāo)前一個
System.out.println(s.length());//求字符的個數(shù)
System.out.println(s.trim());//去兩端空格
System.out.println(s.endsWith("bcd"));//判斷是否以某個字符串結(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ù)符號對字符串拆分,前有分隔符可以拆，后有不算，$不好使
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(".符號在@之后有且僅能有一個");
}
}else{
System.out.println("@規(guī)定只能有一個");
}
}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();
//不支持時區(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()); //一個月的第幾天
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)是子類的對象
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); //通過格式轉(zhuǎn)換日期
System.out.println(sdf.parse(date)); //把符合格式的字符串轉(zhuǎn)回日期
? ? 集合：
? ? what:是一種存放使用數(shù)據(jù)的容器。
? ? 數(shù)組的長度是固定的，數(shù)組容器元素的類型是統(tǒng)一的
? ? 集合不需要固定長度，隨用隨漲；集合中可以存放任意類型的數(shù)據(jù)
? ? why：替代數(shù)組的方案
? ? how：? 元素的存儲，修改，提取
? ? 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");//把鍵值對放入容器
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集合對象獲取一個hs集合專用的迭代器
while(it.hasNext()){
System.out.println(it.next());
}
迭代器模式
? ? 4.集合的工具類
? ? Collections 和Collection的區(qū)別？
? ? 一個是工具類，一個是線性集合的父接口
? ? Collections.sort(al);
System.out.println(Collections.max(al));
Collections.reverse(al);
? ? 5.集合中泛型的使用
? ? 泛型：集合中的泛型用來約束元素的數(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());
//獲取絕對路徑
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ù)傳輸過程中形成的管道
? ? 三種流分類：
? ? 方向：輸入，輸出
? ? 內(nèi)容：字節(jié)，字符
? ? 能力：節(jié)點，處理（低級，高級）:高級流必須依賴低級流
? ? FileWriter f = new FileWriter(filename, append) //append 決定輸出文件是否覆蓋源文件內(nèi)容
? ? 文本文件的拷貝：
? ? //1.找到數(shù)據(jù)源
File fsr = new File("E:/timg.jpg");
//2.通過數(shù)據(jù)源獲取文件名字
String filename = fsr.getName();
//3.通過名字在另一個空間生成新文件
File newFile = new File("D:/"+filename);
newFile.createNewFile();
//4.把源數(shù)據(jù)復(fù)制新文件中
//4.1 讀取源數(shù)據(jù)（1次讀一個，往新文件中寫一個），一直讀寫到源文件結(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.通過數(shù)據(jù)源獲取文件名字
String filename = fsr.getName();
//4.1 讀取源數(shù)據(jù)（1次讀一個，往新文件中寫一個），一直讀寫到源文件結(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ū)動
Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl", "scott", "tiger");
//通過驅(qū)動和信息創(chuàng)建連接通道
Statement stat = conn.createStatement();
//給管道匹配一個空的sql對象
ResultSet? rs = stat.executeQuery("select ename,job from emp where deptno = 10");
//把sql語句綁定到對象上并且執(zhí)行,并把結(jié)果返回給結(jié)果集resultset
while(rs.next()){
//遍歷一條數(shù)據(jù)，如果還有則返回true
System.out.println(rs.getString("ename")+","+rs.getString("job"));
//根據(jù)數(shù)據(jù)的類型獲取對應(yīng)數(shù)據(jù)
}
preparestatment:
Class.forName("oracle.jdbc.driver.OracleDriver");
//加載驅(qū)動
Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl", "scott", "tiger");
//通過驅(qū)動和信息創(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ù)庫蹦蹦了");
}
}
public static Connection getConn() throws ClassNotFoundException, SQLException{
//加載驅(qū)動
Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl", "usermanager", "abc123");
conn.setAutoCommit(false);
return conn;
}
}
? ? 網(wǎng)絡(luò)? ?
