Java基礎知識學習筆記總結

Java學習筆記總結

java基礎複習

1、抽象類可以有構造器，可以有一個非抽象的父類

2、垃圾回收機制回收的是堆裡面的記憶體，棧裡面的資料自動入棧自動出棧

3、引用型別的資料在堆當中，記憶體中操作的只有棧，new關鍵字在堆裡面分配一塊記憶體

4、 java中是值傳遞

5、 String是不可變字元，即一旦分配了記憶體，此記憶體的值將不會改變，又將String賦值是，會重新分配一塊記憶體，字串池： StringBuffer

6、 在堆中的東西叫物件

Ø 執行時異常：

ArithmeticException 當出現異常的運算條件時，丟擲此異常。例如，一個整數“除以零”時，丟擲此類的一個例項。

ArrayIndexOutOfBoundsException用非法索引訪問陣列時丟擲的異常。如果索引為負或大於等於陣列大小，則該索引為非法索引。

ArrayStoreException試圖將錯誤型別的物件儲存到一個物件陣列時丟擲的異常。如：

Objectx[] = new String[3];

x[0]= new Integer(0);

ClassCastException檢視將物件轉換為不是例項的子類時，丟擲該異常。如：

Objectx = new Integer(0);

System.out.println((String)x);

illegalArgumentException表明向方法傳遞了一個不合法或不正確的引數

NegativeArraySizeException如果應用程式檢視建立大小為負的陣列，則丟擲該異常

Ø 編譯時異常：

NoSuchMethodException無法找到某一特定方法時，丟擲該異常

7、 unicode碼範圍

漢字：[\u4e00,\u9fa5]

數字：[0x30,0x39]

小寫字母：[0x61,0x7a]

大寫字母：[0x41,0x5a]

8、 final類

final類能夠修飾非抽象類、非抽象類成員方法和變數（靜態變數、例項變數、區域性變數）

final類不能被繼承，沒有子類

final方法可以被繼承，但不能被子類的方法覆蓋

final成員變數表示常量，宣告成員變數時，必須賦值（要麼在宣告的時候賦值，要麼在構造器中賦值），賦值後不能被改變

publicfinalint E; //final空白,必須在初始化物件的時候賦初值
        public Test3(int x) {
                E= x;
        }

final不能用於修飾構造方法2.5

9、 static只能修飾成員變數，表示所有物件共享這個資料

static能夠修飾成員變數和方法，內部類，也可以形成靜態static程式碼塊，不能修飾區域性變數

被static修飾的成員變數可以直接用類名來呼叫，語法如下：

類名.靜態放大名（）；

類名.靜態變數名；

靜態方法中不能用this和super關鍵字，不能直接訪問不帶static的成員變數和成員方法

因為static方法獨立於任何例項，因此static方法必須被實現，而不能是抽象的abstract

先執行靜態程式碼塊，再執行構造器

10、static和final一塊表示什麼

staticfinal用來修飾成員變數和成員方法，可理解為全域性變數（java中沒有全域性變數的概念）

staticfinal修飾變數，表示一旦給值就不可修改，並且通過類名就可以訪問

staticfinal修飾方法，表示不可覆蓋，並可通過類名直接訪問

staticfinal修飾一些容器型別（ArrayList、HashMap）的變數，不可以改變容器變數本省，但可以修改容器中存放的物件

11、類成員變數分類

被static修飾的變數叫靜態變數或者類變數；

沒有被static修飾的變數叫例項變數。

12、命令列引數

java主類引數（即命令列引數）

eclipse中java輸入命令列引數，在選定的類中，點選右鍵run as—Runconfigurations—Arguments-Program arguments-Variables-選擇string_prompt

13、Integer.valueOf(String)將字串轉換成Integer包裝類

14、一個.java檔案中可以有很多類。不過注意以下幾點：

a、public 許可權的類只能有一個（也可以一個都沒有，但最多隻有1個）

b、這個.java檔案的檔名必須是public類的類名（一般的情況下，這裡放置main方法是程式的入口。）

c、若這個檔案中沒有public的類，則檔名隨便是一個類的名字即可

d、用javac 編譯這個.java檔案的時候，它會給每一個類生成一個.class檔案

15、物件導向、程式導向

物件導向的三大特性：封裝、繼承、多型

程式導向：C語言的底層語言的特性

16、類和物件：

一個類中可以有多個物件，類是對物件的描述

一個類中的成員：

欄位：封裝private

方法：類的行為

構造器：與類同名，沒有返回值。作用：初始化成員變數。預設構造器：無參且同名沒有返回值，當一個類顯示的表明構

造器，則類不自己建立預設構造器

內部類

17、類之間的關係：繼承耦合度最高

A．繼承（is-a）: 單繼承多實現 extends 優點：減少了程式碼的冗餘、缺點：耦合度太高

B．實現:

C．組合(has-a):

合成:個體和整體的關係，個體與整體生命週期相同，公司和部門的關係

聚合：個體和整體的關係，生命週期不同，學生和學校的關係

關聯：雙向關聯

Class Person{

Petpet;}

ClassPet{

Personowner;

}

D．依賴(use-a):一個類作為另一個類方法的引數或者是返回值，稱為依賴

18、java設計原則

低耦合高內聚

可擴充套件性和可維護性

19、繼承：

子類中的成員：

1）從父類中繼承的視覺化（非私有的）的成員（欄位、方法），不能繼承父類的構造器

2）子類所特有的成員（欄位、方法、構造器）

3）過載父類的成員（方法）多型

過載的條件：

a）發生在同一個類或者父子類之間

b）方法名稱相同，引數列表（引數的個數，引數的資料型別、引數的順序）不同

c）返回值無所謂

d）訪問許可權無所謂

歧義過載：

ma(12,34)//歧義過載，編譯錯誤

publicvoid ma(int i,double j){//列印1}

publicvoid ma(double i,int j){//列印2}

構造器過載：

this：

this.成員（欄位、方法）：呼叫本類的欄位、方法

this(引數列表):呼叫本類的其他構造方法，必須在構造方法的第一句

public Person(int age){

this(age,””);//呼叫下面那個構造器

}

publicPerson(int age,String name){

this.age= age;//呼叫本類的欄位

this.name= name;

}

super：父類的物件

super.成員：呼叫父類的成員（方法、欄位）

super(引數列表)：呼叫父類的構造方法，必須位於子類構造方法的第一句

如果父類中沒有無參的構造器，在子類中必須顯式的呼叫父類帶引數的構造方法（super（引數類表或者this（引數列表）））；如果父類有無參的構造器，則子類中可以不用顯式呼叫父類的構造器，因為系統預設呼叫super（）;

4）重寫父類的成員（方法）多型

重寫的條件：

a）發生在父子類之間

b）方法名稱相同，引數列表（引數的個數，引數的資料型別、引數的順序）相同

c）返回值必須相同

d）子類覆蓋方法的訪問許可權大於等於父類被覆蓋方法的訪問許可權

e）子類不能丟擲比父類異常更大的異常（RuntimeException例外）

5）隱藏父類的成員（欄位）

多型物件：呼叫隱藏成員，呼叫的是父類的

呼叫覆蓋成員，呼叫的是子類的

20、static:類成員

欄位：所有物件共享

方法：靜態方法不能直接訪問非靜態的成員，如果需要訪問，產生例項訪問；

非靜態方法能夠直接訪問靜態成員和非靜態成員

靜態方法中不能有this、super關鍵字

塊：記憶體中只執行一次，通常用來初始化靜態成員

內部類

21、final：終態的

變數：不能第二次賦值，而且必須有初始值

方法：不能被重寫

類：不能被繼承

22、abstract：

抽象方法必須在抽象類中，抽象類中不一定要有抽象方法

抽象類沒有例項

抽象類可以有父類，父類可以是抽象類也可以是非抽象類

抽象類有構造器，不能用來產生本類例項，構造器用來間接產生子類例項時使用

abstract不能與static、final、private一起使用

23、異常處理：

1）try{}catch（）finally{}

2）throws 方法宣告後 throws 異常類

3）throw 句子（通常是if）後throw 異常類的例項

4）自定義異常類 extends Exception或者RuntimeException

24、方法重寫(override)和過載(overlord)的區別

重寫override：子類中出現與父類中籤名相同的方法、訪問修飾符要等於高於父類、返回值型別，引數列表都相同

過載overlord：一個類內部出現兩個及兩個以上方法名相同、引數列表不同(引數型別，引數個數，引數型別的順序)的方法

25、動態多型和靜態多型

動態多型（執行時多型）：執行過程中才知道呼叫那個方法，指的是方法重寫

靜態多型（編譯時多型）：編譯時就知道所呼叫的方法，指的是方法過載

26、如果父類中沒有空參構造

那麼子類必須同super()的方式顯示的呼叫父類構造

建議：如果父類中出現帶參構造，那麼必須手動新增空參構造

例：下列程式碼的執行結果是（ B）

classA{

public A(int a){System.out.println（“A”）;}

}

class B extends A{

publicB(){

super(5);//必須加上這一塊，用super（）顯示的呼叫父類中的方法

}

public voidma(){System.out.println(“ma”);}

}

public class test{

public static void main(String[]args){

B b=new B（）;

b.ma();

}

A. 列印輸出ma

B. 編譯錯誤

C. 列印輸出A

D. 列印輸出A ma

27、 static：

表示靜態的，修飾的內容屬於類成員；被該類的所有物件共享，建議使用類名.的方式訪問；修飾的內容在類載入的時候，執行；只能訪問被static修飾的內容；修飾的內容只在類載入的時候執行一次。

可以修飾的內容：修飾屬性、修飾方法、作為程式碼塊使用 jdbc 載入驅動的時候

static{

Class.forName("");//作為程式碼塊使用

}

特點：

1.修飾的內容屬於類成員

2.修飾的方法，不能被重寫，可以被過載

3.修飾的內容，執行一次

例：public class HelloWorld{

public staticvoid main(String args[]){

method();

}

public voidmethod(){

try{

System.out.println("hello我執行");

}

finally{

System.out.println("我就不執行");

}

編譯執行後，輸出結果是什麼？(D )

A."hello 我執行"

B."我就不執行"

C."hello 我執行"

"我就不執行"

D.程式碼不能編譯

因為main方法是用static修飾的靜態方法，呼叫的方法也必須用static修飾，而method();方法沒有被static修飾

28、hashcode()返回的是物件的記憶體地址對應的int型別資料，但是我們可以重寫hashCode()方法，返回的就不再是記憶體地址。

hashcode()相同的物件，這兩個物件不一定相同；如果兩個物件相同，則hashcode()一定相同。

29、java中的訪問修飾符

public：所有

protected：自己、同一包中、子類可以訪問

default：預設什麼都不加，就是default，自己、同一包中可以訪問，但是比protected級別要低即限制更多

friendly：自己、同一包中可以訪問

private：自己

例：以下程式碼的執行結果是：( C )

1. abstract class abstrctIt {

2. abstractfloat getFloat ();

3. }

4. public class AbstractTest extends AbstractIt {

5. privatefloat f1 = 1.0f;

6. privatefloat getFloat () {return f1;}

7. }

A. 編譯成功

B. 第6行產生錯誤，導致執行失敗

C. 第6行產生錯誤，導致編譯失敗

D. 第5行產生錯誤，導致編譯失敗

預設什麼不加的訪問修飾符是default，default比private限制少（即更高階），比protected限制多，所有第六行重寫方法用的private訪問修飾符比父類低階，所有會出現編譯失敗

30、Math.random()獲取[0,1)的值，取不到1；

用法：（int）Math.random()*n+1;取到1到n之間的整數

31、陣列、集合、字串之間的轉換

a. Arrays.asList() //將陣列轉換成集合

例：List list = Arrays.asList(names);//將陣列轉換成集合。

b.String.valueOf() //將陣列轉換成字串、也可將整數轉換成字串

例：char []ch1 = {'a','c','a','b','a'};

String str2 = String.valueOf(ch1);

例：int num = 123456;

String str =String.valueOf(num);

c.toCharArray()將字串轉換成陣列

例：String str = "gdfgdfgd";

char[] ch = str.toCharArray();

d.Arrays.toString()將字元陣列變成字串特定格式輸出，如[1,2,3]

例：String str1 = Arrays.toString(ch);

System.out.println(str1);

e.str.reverse();將字串反轉

例：StringBuffersb =new StringBuffer("adfsdsd");

sb.reverse();

f.

32、replace();函式

例1：//將字串"abcdabcdabdcadcbadcb"的字元出現的次數輸出

Stringnum = "abcdabcdabdcadcbadcb";

String t = num.replace("a","");

System.out.println(num.length()-t.length());

replaceAll()，用正規表示式

例2：//將字串中的數字去除

String num1 = "ab23c7da45bc5da65bd5c67ad7cb9adcb";

String t1 = num1.replaceAll("[0-9]", "");

System.out.println(t1);

例3：//計算字串的長度，一個字元算兩個

byte[]b =str.getBytes();

System.out.println(b.length);//若出現一個漢字代表3個位元組的情況，將Utf-8換成GBK就可以了

String m = str.replaceAll("[\u4e00-\u9fa5]", "xx");

System.out.println(m.length());

33、DecimalFormat（）;將數字轉換成特定的格式

例：//陣列格式化 int num = 1234567; 換成123，4567

int num = 1234567;

DecimalFormat f =new DecimalFormat("#,####");

String t =f.format(num);

System.out.println(t);

例： //將陣列轉換成123,4567.89的格式

doubled = 1234567.88898890;

DecimalFormat f =new DecimalFormat("#,####.##");

System.out.println(f.format(d));

34、String型別是否可以被繼承，為什麼？

不能被繼承，因為是被final修飾的類

35、String型別是否是基本型別，比較String型別變數時，== 和equals有何區別？

不是，是引用型別

a.如果 String型別是直接賦值 == 和 equals 效果相同

String a = “abc “;

String b = “abc”;

a ==b 和 a.equals(b)都為true

b.如果String是通過new構建的 == 和equals效果不同

String a = new String（“abc”）；

String b = new String（“abc”）；

a ==b 結果為false

a．equals（b）結果為true

36、char型別中是否可以存放一個漢字，為什麼？

可以，char型別中存放的資料以Unicode碼存放。

37、Random()函式

//獲取1-35之間的隨機數

//第一種方法

Random r = new Random();

int n = r.nextInt(35)+1;

//第二種方法Math.random()是取得[0,1)之間的隨機小數，取不到1。

int n =(int) (Math.random()*35+1);

java工具類

Object：引用型別的根，是所有類的超類，是java中唯一一個沒有父類的類

1、toString():將物件轉成字串

2、equals（）和==的區別：

==：可以判斷基本資料型別和引用資料型別

引用資料型別，表示兩個物件的引用是否相等，即棧裡面引用的地址是否相等

equals：可以判斷引用資料型別

引用資料型別：表示兩個物件的引用是否相等，但是包裝類、String、Date、File除外（這些判斷的是物件的值是否相等，即堆記憶體裡面的值是否相等）

Stringstr1 = “abc”；

//建立一個字串池中的物件，如果裡面有此物件了就不再建立了，直接用即可

Stringstr2 = “abc”；

Stringstr3 = new String(“abc”)；

Stringstr4 = new String(“abc”)；

//可能產生兩個或一個物件，在堆記憶體中首先new出一個物件，再複製到字串池當中，如果字串池中有此物件，即不復制。所有堆記憶體中的物件是肯定存在的，字串池中的物件不一定

System.out.println(str1==str2)；true

System.out.println(str3==str4)；false

//str3在堆記憶體中new出一個記憶體、str4在堆記憶體中重新new出一個記憶體，在堆記憶體中相當於等號的右邊。在棧記憶體中，指向堆記憶體中的引用值不一樣，所有為false

System.out.println(str1==str3)；false

//str1是在堆記憶體中的字串池裡，為“abc”，str3在堆記憶體new出一個物件‘abc‘佔用一塊記憶體，並且複製到字串池中，如果字串池中有abc了，即不復制。

System.out.println(str1.equals(str2));true

System.out.println(str3.equals(str4));true

System.out.println(str1.equals(str3));true

//equals在String型別比較的堆記憶體的值是否相等，str1字串池中的記憶體為abc，str3在堆記憶體中new出的物件是abc，這兩個物件雖然分配的記憶體不同，但是值相等，所以為true

3、重寫equals方法必須先重寫hashcode方法

相等的物件必須具有相同的雜湊碼，具有相同雜湊碼的物件不一定相等

3、clone（）克隆

淺表克隆：複製原物件的所有變數的備份,但是引用型別的變數指向原物件的資料

必須實現一個介面implements Cloneable

重寫Object類的克隆方法clone()

深表克隆：複製原物件的所有變數的備份，包括引用型別

4、反射Class.forName(“com.A”);

破壞了底層的封裝性

5、包裝類

byteByte

shortShort

longLong

floatFloat

doubleDouble

BooleanBoolean

intIntegar

charCharacter

包裝類與字串轉換：

xxxValue（）：轉換成其他基本型別

包裝類-à字串 toString（）

System.out.println(i.toString());

字串-à整形 parseXxx（）

int i4 =Integer.parseInt(“123”);

double i5 =Double.parseDouble(“123.456”);

裝箱和拆箱：JDK1.5只會自動裝箱和拆箱

裝箱：基本資料型別轉換為引用資料型別

Integer i5 = 10;

拆箱：引用資料型別轉換為基本資料型別

Integer i5 = 10;

int i6 = i5;

6、String類

charAt（）方法：一般與for迴圈一起，遍歷字串

Stringstr = “Hello Java,Hello World”;

for(int i=0;i<str.length();i++){

System.out.println(charAt(i));

}

concat()方法;拼接字串，將指定字串連線到此字串的結尾

str.concat(“s”); //得到Hello Java,Hello Worlds

startWith()方法;測試此字串是否已指定的字首開始，boolean

str. startWith(“Hello”); //true

format()方法:將字串按照某種格式輸出

inti=1;intj=2;

System.out.println(String.format("%d+%d=%d",i,j,i+j));//1+2=3

indexOf(String)方法:輸出字串第一次出現的索引，沒有的話輸出-1

System.out.println(str.indexOf("Hello"));//0

lastIndexOf()方法:輸出字串最後一次出現的索引

replace(old String, new String)方法:替換字串

split()方法:分割字串

substring(int start,int end)方法:擷取字串

toCharArray()方法:變成字元陣列

trim()方法:去掉字串兩端的空格，字串中間的去不掉

toUpperCase()方法:將字串轉化為大寫

7、StringBuffer和StringBuilder區別

StringBuffer執行緒安全的，同步的，效率比較低，JDK1.0之後出現

StringBuilder執行緒不安全，不同步的，效率比較高，JDK1.5之後出現

8、StringBuffer方法

StringBuffersb = new StringBuffer（“aaa”）;

append 追加字串

sb.append(“bb”).append(“bb”);

delete 刪除

sb.delete(1,2).delete(1,2);

insert 插入

sb.insert(1,”22”).insert(1,false);

setCharAt 修改

sb.setCharAt(1,’Q’);

replace 替換

sb.replace(1,3,”MMM”);

reverse 反轉

sb.reverse();

10、Math方法

Math.ceil(2.4);//3取比值大的最小整數

Math.ceil(-2.4);//-2

Math.floor(2.5);//2取比值小的最大整數

Math.round(2.5);//3四捨五入

Math.round(-2.5);//-2

Math.random()//範圍是[0,1)

Math.random()*40+60;//取60到99的成績

Random方法：範圍是[0,1)

Randomran = new Random();

for(inti=0;i<10;i++){

intscore = ran.nextInt(41)+60;//從60到100

System.out.println(score);

}

11、Date方法

SimpleDateFormat類：改變時間的格式

SimpleDateFormatsdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");

Datedate = new Date();

//將日期格式轉換成指定的字串

Stringtime = sdf.format(date);

System.out.println(time);//現在的時間以yyyy/MM/dd HH:mm:ss格式輸出

//將格式化的字串轉換成日期物件

Datedate = sdf.parse(“1995/07/12 03:00:00”);

System.out.println(date);

TimeZone（）設定時區

TimeZonetime=TimeZone.getTimeZone("America/Los_Angeles");

Calendar c2=Calendar.getInstance(time,Locale.US);

Date d=c2.getTime();

GregorianCalendar單獨獲取年、月、日

GregorianCalendar gc =newGregorianCalendar(2017,3,5);

System.out.println(gc.get(Calendar.MONTH));

System.currentTimeMillis();通常用於迴圈運算的時間

long startTime = System.currentTimeMillis();

for(){}

longendTime = System.currentTimeMillis();

longtime = endTime- startTime//計算出運算的時間

集合：

1、集合和陣列的區別：

陣列：可以包含基本資料型別或者引用資料型別的物件，資料定長的，訪問較快

集合：只能包含引用資料型別的物件，不定長。

2、集合分類：

Set:集無序，不重複，父介面為Collection

add（）;新增元素

addAll（Collection）;新增子集合

contains（）;是否包括元素

containsAll（）;是否包含子集合

isEmpty();Boolean判斷集合長度是否為0

remove（）;移除元素

removeAll（）;移除一個子集合

size（）;集合的大小

toArray（）;將集合轉換成資料

Set集合的遍歷 Iterator 迭代器

Setset = new HashSet();

Iteratorit = set.iterator();

while(it.hasNext()){

Objectobj = it.next();

System.out.println(obj);

}

Set集合的遍歷增強for迴圈

for(Object obj:set){

System.out.println(obj);

}

HashSet和TreeSet的區別：

HashSet：內部物件雜湊存取，順序和輸入的順序不同

TreeSet：元素會進行升序排序（元素是可比較的），順序和輸入的順序也不同

List:列表有序，重複，父介面為Collection

add（）;新增元素

addAll（Collection）;新增子集合

add（key，元素）;插入元素

get（key）;獲取元素

indexOf(元素);返回元素的索引值，如果沒有則返回-1

remove(key);移除元素

removeAll（）;移除一個子集合

set（key,元素）;修改元素

toArray();轉換成陣列

List集合的遍歷普通for迴圈

Listlist = new ArrayList();

for(inti;i<list.size();i++){

Object obj = list.get(i);

System.out.println(obj);

}

List集合的遍歷增強for迴圈

for(Object obj:list){

System.out.println(obj);

}

List集合的遍歷 Iterator 迭代器

Iterator it = list.iterator();

while(it.hasNext()){

Objectobj = it.next();

System.out.println(obj);

}

ArrayList和LinkedList區別：

ArrayList底層物理儲存為線性的（陣列的儲存方式），查詢效率高，刪除、新增等操作效率比較低

LinkedList底層物理儲存為連結串列的，查詢效率低，刪除、新增效率高

ArrayList和Vector區別：

兩者底層物理儲存為線性的

ArrayList：執行緒不安全，不同步的，資料不安全，效率比較高

Vector：執行緒安全的，同步的，資料安全，效率比較低

Map:字典鍵值對儲存 key唯一，value可重複

put(key,values);新增元素

putAll(map);新增集合

remove（key）;移除一對元素

size();集合長度

containkey(key);是否包含某個鍵

containvalue（value）;是否包含某個值

Map集合的遍歷 keySet()

Set set = map.keySet();

Iterator it = set.iterator();

while(it.hasNext){

Object key = it.next();

Object value = map.get(key);

System.out.println(key+”:”+value);

}

Map集合的遍歷 entrySet()

Iterator it = map.entrySet().iterator();

while(it.hasNext()){

Map.Entry entry = (Map.Entry)it.next();

System.out.println(entry.getKey()+”:”+entry.getValue());

}

HashMap和Hashtable的區別：

HashMap：鍵值對允許為null，執行緒不安全，不同步，效率比較高

Hashtable：鍵值對不允許為null，執行緒安全，同步，效率比價低

HashMap和TreeMap的區別：

HashMap：基於雜湊，是無序的

TreeMap：基於樹型結構的，按照鍵升序排序

3、Collections類：

Collections.sort():只針對List集合，集合中的元素必須是可比較的，如果為引用型別，則必須實現Comparator、Compareable（常用）介面

Collections.shuffle（list）：打亂順序

Collections.rotate（list,int i）:根據指定的長度，輪換指定列表中的長度

Collections.reverse(list):反轉集合

泛型：資料型別引數化

1、public<T> void arr(T t1,T t2){

Ttemp = t1;

t1= t2;

t2= temp;

}

2、泛型：安全的，避免了資料型別轉換的風險

3、泛型約束：entends：如果有多個約束則使用&連線，約束只能有一個類，可以有多個介面

4、萬用字元？

上屆萬用字元：？ extends A：表示A或者A的子類

下屆萬用字元：？ super A：表示A或者A的父類型別

List<String>list = new ArrayList<String>();

List<?extends Object> listobj = list;//成立

List<Object>listobj = list;//不成立在泛型中<String>和<Object>是同級關係

檔案

1、構造方法

Filefile1 =new File("D:\\a.txt");

File file2 =new File("d:\\UI","a.txt");

File file3 = new File("D:\\UI");

Filefile4 =new File(file3,"a.txt");

2、mkdirs()建立多層資料夾

File file5 = new File("D:\\UI\\aaa");

if(!file5.exists()){

file5.mkdirs();

}

3、getAbsolutePath()列印檔案路徑

getPath()列印檔案路徑

System.out.println(file5.getAbsolutePath());//D:\UI\aaa

4、getName()()獲取檔名//aaa

5、getParent()獲取檔案目錄，不包含檔名//D:\UI

6、isHidden()檔案是否被隱藏//false

7、isDirectory()判斷是否是資料夾//true

8、isFile() 判斷是否是檔案

9、exists() 判斷是否存在

10、newDate(file5.lastModified()) 獲取最後一次修改的日期

11、length() 檔案的位元組數

12、file5.list() 檔名的遍歷

String[]str =file5.list();

for(String s :str){

System.out.println(s);

}// 3.doc

5.FEM

e.txt

13、file5.listFiles() 檔案的遍歷

File[]files = file5.listFiles();

for(File f :files){

if(f.isFile()){

System.out.println("檔案"+f.getName()+"\t"+new Date(f.lastModified()));

}else{

System.out.println("資料夾"+f.getName());

}

}//檔案3.docFri Feb 24 10:33:28 CST2017

檔案5.FEM Fri Feb 24 10:33:37 CST 2017

檔案e.txt Fri Feb 24 10:33:32 CST 2017

14、File.listRoots(); 碟符的遍歷

File[] f1 = File.listRoots();

for(Filef :f1){

System.out.println(f.toString());

}// C:\

D:\

檔案IO流

1、位元組流

FileInputStream 輸入流讀檔案

BufferedInputStream輸入流讀檔案

FileOutputStream輸出流寫入檔案

BufferedOutputStream輸出流寫入檔案

字元流

FileReader輸入流讀檔案

DataInputStream輸入流讀檔案

FileWriter輸出流寫入檔案

DataOutputStream輸出流寫入檔案

2、FileInputStream 讀取英文檔案

FileInputStreamfis = new FileInputStream("D:\\UI\\bbb.txt");

intch = 0;

while((ch= fis.read()) != -1){ //read從此輸入流中讀取一個資料位元組，返回值為int

System.out.print((char)ch);

}

fis.close();//此程式不能讀中文

3、FileInputStream 讀取中文檔案

FileInputStreamfis = new FileInputStream(“D:\\UI\\bbb.txt”);

byte[]bt = new byte[1024]; //將位元組讀入位元組陣列

intlen = 0;

while((len= fis.read(bt))!=-1){

System.out.print(newString(bt,0,len));

}

4、FileOutputStream 寫入檔案

//搭建管道

FileOutputStream fos = new FileOutputStream(“D:\\UI\\bbb.txt”);

//讀寫操作

fos.write(98);//相當於b

fos.write('a');

String str = "ssdsdfsf"; //寫入字串

byte[] b = str.getBytes();

fos.write(b);

fos.flush();//強制性的重新整理緩衝區

//關閉流

if(fos !=null){

fos.close();

}

5、DataOutputStream 寫入boolean、double等型別的檔案

FileOutputStream fos = null;

DataOutputStream dos = null;

fos =new FileOutputStream("D:\\UI\\bbb.txt");

dos =new DataOutputStream(fos);

dos.writeBoolean(true);

dos.write('a');

dos.writeDouble(12.34);

for(inti=0;i<10;i++){

doubled = Math.random();

dos.writeDouble(d);

}

dos.flush();

dos.close();

fos.close();

6、DataInputStream讀取boolean、double等型別的檔案

FileInputStream fis =null;

DataInputStream dis = null;

fis =new FileInputStream("D:\\UI\\bbb.txt");

dis =new DataInputStream(fis);

booleanbool =dis.readBoolean();

System.out.println(bool);// true

for(inti=0;i<10;i++){

doubleb =dis.readDouble();

System.out.println(b+"\t");

}

dis.close();

fis.close();

// -6.414939283240485E-86

4.7384486223731214E285

7.602269187305488E-298

-1.4027415471626017E-278

9.32553721042958E-38

-1.0852988920338364E40

4.6544251087746895E49

1.0777059597027002E40

4.954807472569955E232

4.957881657894938E232

7、序列化和反序列化

序列化：將物件的資料儲存到檔案 ObjectOutputStream

反序列化：將檔案中的資料重新讀到物件 ObjectInputStream

例題：在程式中建立一個Student型別的物件，並把物件資訊儲存到d:\\io\\student.txt檔案中，然後再從檔案中把Student物件的資訊讀出顯示在控制檯上。

//先建立Student類

publicclassStudentimplementsSerializable {//編寫一個可序列化的類 implements Serializable

privateintid;

private String name;

private String birth;

public Student(intid, Stringname, String birth) {

super();

this.id = id;

this.name = name;

this.birth = birth;

}

@Override

public String toString() {

returnid+""+name+" "+birth;

}

//再進行序列化，即將Student物件寫入檔案，直接丟擲異常範例

publicclass SObjectOutputStreamTest throws IOException{

publicstaticvoid main(String[] args) {

Students1 = new Student(1,"we","1987-3-4");

Students2 = new Student(2,"you","1988-3-9");

FileOutputStreamfos = null;

ObjectOutputStreamoos = null;

fos = new FileOutputStream("D:\\io\\student.txt");

oos = new ObjectOutputStream(fos);

oos.writeObject(s1);

oos.writeObject(s2);

oos.close();

fos.close();

}

//進行反序列化，將檔案中的語句讀出到控制檯，用try catch抓住異常範例

publicclass SObjectInputStreamTest {

publicstaticvoid main(String[]args) {

FileInputStream fis = null;

ObjectInputStream ois = null;

try {

fis =new FileInputStream("D:\\io\\student.txt");

ois =new ObjectInputStream(fis);

Student s1 = (Student)ois.readObject();

Student s2 = (Student)ois.readObject();

System.out.println(s1.toString());

System.out.println(s2.toString());

} catch (FileNotFoundException e) {

e.printStackTrace();

}catch (IOException e) {

e.printStackTrace();

}catch (ClassNotFoundException e) {

e.printStackTrace();

}finally{

try {

if(ois!=null){

ois.close();

}

}catch (IOException e) {

e.printStackTrace();

}

try {

if(fis!=null){

fis.close();

}

}catch (IOException e) {

e.printStackTrace();

}

多執行緒

1、程式：一個應用程式的一次執行，包含多執行緒

多執行緒：一個應用程式執行過程中的某些獨立的片段

2、程式與執行緒的區別（優缺點）

程式：程式間切換耗費系統資源，資料安全（獨立的程式碼和資料空間）

執行緒：執行緒間切換系統耗費比較小，資料不安全（共享程式碼和資料空間）

3、編寫執行緒（掌握）

a．繼承Thread類

publicclass ThreadTest1 {

publicstaticvoid main(String[] args) {

ThreadDemotd = new ThreadDemo();

td.start();

for(inti=0;i<1000;i++){

System.out.println("the main is:"+i);

}

publicclass ThreadDemoextends Thread {

@Override

publicvoid run() {

for(inti=0;i<1000;i++){

System.out.println("the run is:"+i);

}

b．實現Runnable介面（推薦，因為java類和類是單繼承的）

publicclass RunnableTest {

publicstaticvoid main(String[] args) {

RunnableDemord = new RunnableDemo();

Threadthread = new Thread(rd);

thread.start();

for(inti=0;i<1000;i++){

System.out.println("the main is:"+i);

Thread.sleep(500);

}

publicclass RunnableDemoimplementsRunnable{

@Override

publicvoid run() {

for(inti=0;i<1000;i++){

System.out.println("the run is:"+i);

Thread.sleep(500);

}

4、CPU排程

搶佔式

輪時間片

5、讓執行緒從執行狀態進入到阻塞狀態

Thread.yield();//暫停

Thread.sleep(500);//休眠

join();//在A執行緒中加入B執行緒，待B執行緒執行完後，再執行A執行緒

6、執行緒其他方法

setName（）：給執行緒起名字，預設的名字Thread-X；x從0開始

getName（）：得到執行緒的名字

Thread.currentThread().getName()：得到當前執行執行緒的名字

setPriority();設定執行緒的優先順序數值

getPriority();獲得執行緒的優先順序數值

setDaemon(true);設定為守護執行緒

7、使用者執行緒和守護執行緒的區別

使用者執行緒（前臺執行緒）：必須執行完畢

守護執行緒（精靈執行緒、後臺執行緒）：執行緒體執行完畢也可，執行不完畢也可以，例如垃圾回收

8、執行緒同步：

加鎖同步：一個物件只能有一把鎖

語句加鎖 synchronized（物件）{}：可以對本類物件（this）和其他類物件（new 類）加鎖；某個方法中的某些句子加鎖，無法得知哪些方法是被synchronized保護的

方法加鎖 synchronized void methodA（）{}：只能對本類物件加鎖；整個方法的所有語句加鎖；可以顯示得知方法是被synchronized保護的

9、死鎖：兩個執行緒，彼此在等待對方佔據的鎖

鎖的幾種歸還方式：

a．基本上執行完同步的程式程式碼後，鎖會自動歸還

b．用break語句跳出同步的語句塊，不過這對於寫在方法宣告的synchronized沒有作用

c．遇到return語句

d．遇到了異常

10、執行緒的生命週期

網路程式設計（java.net）

1、七層協議：

2、兩臺電腦之間的通訊

ip：ipv4（32位）、ipv6（128位）

埠:1521（oracle）、8080（Tomcat預設的埠）、21（ftp）、80（預設的）

協議：

UDP：傳輸層，使用者資料的協議，無連線的協議，不可靠的，不能夠準確到達，效率比較高，適用於資料量比較大並且允許出錯的，比如網路視訊

TCP/IP:傳輸層，有連線的協議，可靠的、準確的到達，效率比較低

http：https：ftp等在應用層

http協議：明文無狀態的

https：密文

3、客戶端和伺服器端

基於UDP的

客戶端：

Socket client = new Socket("10.25.116.222",8088);

伺服器端：

ServerSocketserver =ServerSocket(8088);ji

Socket s =server.accept();

4、埠號範圍是0-65535，使用者普通網路程式用1024以上

5、 InetAddress此類表示網際網路協議ip地址

InetAddress address = InetAddress.getByName(“主機名”);

6、getHostName（）獲取此IP地址的主機名

getHostAddress（）獲取IP地址字串

getByName()通過主機名獲取ip地址

getLocalPort()獲取本程式所用介面

JAVA7新特性

1、數值型的資料賦值可以使用下劃線_ 增加可讀性

不能寫在小數點後;

不能在數值型資料的開始

不能在數值型資料的最後新增

Doublepi = 3.1415_9265

Intbillion = 1_000_000_000

2、可以宣告n進位制資料

Int i1= 0b0100;//4二進位制前方放0b

Inti2 = 07; //7八進位制前方放0

Inti3 = 0x00ad;//十六進位制前方放0x

3、switch:表示式：

jdk1.7以下byte、short、char、int；

jdk1.7以上在上面基礎上加上String

4、try（IO流）{

Stringstr=br.readLine();

}catch (ArithmeticException | IOException e) {//catch裡可以有多個異常類，不能是父子關係

e.printStackTrace();

}//不用關閉流了，自動資源管理器

5、泛型

List<String>list = new List<String>();//jdk1.7以下

List<String>list = new List< >(); //jdk1.7以上

6、新加G1垃圾回收器 提高效率

7、NIO2

Files.copy(Paths.get(檔案一),Paths.get(檔案二));//直接複製檔案

File.createFile();//建立新檔案

File.move();//移動

File.delete();

//用WatchService型別實現檔案監控

WatchServicewatchService = FileSystems.getDefault().newWatchService();

JDBC

1、編寫jdbc程式的步驟：

1）新增資料庫的驅動jar包 ojbc5.jar或者ojdbc6.jar或者classes12.jar

工程名右擊—Build Path—Add External Archives—資料庫安裝路徑—jdbc-ojdbc6.jar

2）建立驅動類物件 OracleDriver物件

//建立反射機制

Class.forName(“oracle.jdbc.driver.OracleDriver”);

3）連線資料庫 Connection

Stringutl = “jdbc:oracle:thin:@YLMF123-3131857:1521:orcl”;

Stringuser = “scott”;

Stringpassword = “tiger”;

Connectionconn = DriverManager.getConnection(url,user,password);

4）運算元據庫

//第一種方法Statement會引起注入，不推薦使用

String sql = "select deptno,dname,loc from dept";

Statement stmt = conn.createStatement();

ResultSet rs =stmt.executeQuery(sql);//傳送sql語句到資料庫，然後將查詢到的結果返回到ResultSet

//int I = stmt.executeUpdate(sql);//查詢影響的行數

while(rs.next()){

intdeptno =rs.getInt(1);//列的索引從1開始計

String dname =rs.getString(2);

String loc =rs.getString(3);

System.out.println(deptno+"\t"+dname+"\t"+loc);

}

//第二種方法PreparedStatement防止注入推薦使用

String sql = "insert into dept(deptno,dname,loc) values(?,?,?)";

pstmt = conn.prepareStatement(sql);

intdeptno = 35;

String dname = "sdfs";

String loc = "北京";

pstmt.setInt(1, deptno);//第一個問號放deptno

pstmt.setString(2, dname);

pstmt.setString(3, loc);

pstmt.executeUpdate();//執行刪除、插入、修改語句，executeQuery執行查詢語句

5）關閉資料庫

rs.close();

stmt.close();

conn.close();

2、批處理：

stmt.addBatch(sql1);

stmt.addBatch(sql2);//可以執行多句sql語句

executeBatch();//執行

String sql="insert intodept(deptno,dname,loc) values(?,?,?)";

pstmt=conn.prepareStatement(sql);

pstmt.setInt(1, 51);

pstmt.setString(2, "電信部");

pstmt.setString(3, "上海");

pstmt.addBatch();

pstmt.setInt(1, 52);

pstmt.setString(2, "實施部");

pstmt.setString(3, "廣州");

pstmt.addBatch();

pstmt.executeBatch();

3、事務

conn.setAutoCommit（false）：設定為手動提交事務

conn.commit()：提交

conn.rollback()：回滾,catch裡面

4、後設資料

DatabaseMetaData：資料庫的後設資料

DatabaseMetaDatadmd = conn.getMetaData();

dmd.getUserName();//獲得資料庫名稱

dmd.getURL();//獲得介面名jdbc:oracle:thin:@YLMF123-2141651:1521:orcl dmd.getDriverName();//當前驅動Oracle JDBC driver

ParameterMetaData：引數的後設資料

ResultSetMetaData：結果集的後設資料

ResultSetMetaDatarmd = rs.getMetaData();

intcount = rmd.getColumnCount();//獲取結果集有多少列

for(int i=0;i<count;i++){

System.out.println(“列標題”+rmd.getColumnLable(i)+”資料型別”+rmd.getColumnTypeName(i));

}

5、DAO:

1)實體類：一個物件相當於資料庫表中的一行

privateintdeptno;

public Dept() {}

publicint getDeptno() {

returndeptno;

}

publicvoid setDeptno(intdeptno) {

this.deptno =deptno;

}

@Override

public String toString() {

return"Dept [deptno=" +deptno +",dname=" +dname +", loc=" +loc +"]";

}

2)操作介面：可擴充套件

publicinterface DeptDao {

void insertDept(Dept dept);

void updateDept(Dept dept);

void deleteDept(intdeptno);

List<Dept> getAllDepts();

DeptgetDeptByDeptno(intdeptno);

}

3)操作類：

publicclass DeptDaoImplimplementsDeptDao {

@Override

publicvoid insertDept(Dept dept) {

Connection conn = null;

PreparedStatement pstmt = null;

try {

conn = DbUtils.getConnection();

String sql ="insert into dept(deptno,dname,loc)values(?,?,?)";

pstmt =conn.prepareStatement(sql);

pstmt.setInt(1, dept.getDeptno());

pstmt.setString(2, dept.getDname());

pstmt.setString(3, dept.getLoc());

pstmt.executeUpdate();

} catch (SQLException e) {

e.printStackTrace();

}finally{

DbUtils.closeStatement(pstmt);

DbUtils.closeConnection(conn);

}

4)工具類：將重複的程式碼包裝成工具類

publicclass DbUtils {

privatestaticfinal StringURL ="jdbc:oracle:thin:@YLMF123-2141651:1521:orcl";

privatestaticfinal StringUSER ="scott";

privatestaticfinal StringPASSWORD="tiger";

private DbUtils(){}//構造方法

static{

try {

Class.forName("oracle.jdbc.driver.OracleDriver");

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

publicstatic Connection getConnection(){

Connection conn = null;

try {

conn = DriverManager.getConnection(URL,USER,PASSWORD);

} catch (SQLException e) {

e.printStackTrace();

}

returnconn;

}

publicstaticvoid closeConnection(Connectionconn){

try {

if (conn !=null) {

conn.close();

}

} catch (SQLException e) {

e.printStackTrace();

}

Html

1、屬性

align：對齊方式

bgcolor：背景顏色

target:

_blank在新視窗開啟 _self預設，在相同的框架開啟

_parent在父框架集中開啟 _top在整個視窗開啟

framename在指定的視窗開啟

2、註釋

3、檔案路徑

同一目錄下：檔名

上級目錄：../

4、表格

tr行、td列、th表頭

<tableborder="1" align="center" width="80%"bordercolor="green" cellspacing="0" cellpadding="10pt"><!—cellpadding代表文字和行之間的距離-->

<caption>學生成績表</caption>

</table>

5、表單form

表單域input

type：text文字框、password密碼、radio單選按鈕、checkbox：核取方塊

是否需要在本書再版時立即通知您：

<input type="radio"checked="true">是

<input type="radio">否

submit提交按鈕、reset重置按鈕、button普通按鈕

hidden隱藏域（用來傳送資料，不安全）

file：檔案上傳（兩個條件：method=”post”、enctype=”multipart/form-data”）

name：表單域的名字

value：表單域的初始值

size：表單元素的長度，只適用於text、password

maxlength：表單元素中可以輸入的最大字元數，只適用於text、password

checked：boolean屬性，指定按鈕是否是被選中的，只適用於radio、checkbox

readonly：只讀的，只適用於text，資料能提交到後臺

disabled：表示表單域不能用，資料不能提交到後臺

多行文字textarea

<textarea cols=”20” rows=”5”></textarea>//表示可以輸入5行20列

下拉選單框select

<select name=”city” multiple>//可以選中多項

<optionvalue=”beijing”>北京</option>

<optionvalue=”shanghai”>上海</option>

<optionvalue=”qingdao” selected=”true”>青島</option>//預設選中

</select>

域容器fieldset

使用者名稱：<inputtype=”text”>

密碼：<inputtype=”password”>

</fieldset>

6、框架frame

frameset：分割視窗

rows分割行cols分割列

frameborder：是否顯示框架，0不顯示、1顯示，預設為1

framespacing：框架間的間距

frame:框架

src：指定框架顯示的HTML檔案的位置

noresize：設定不可以調整視窗的大小

bordercolor：框架邊框的顏色

<framesrc=”header.html” noresize>

<framesetcols=”20%,*”>

<framesrc=”left.html” noresize>

</frameset>

<framesrc=”footer.html” noresize>

</frameset>

<body>瀏覽器版本較低，請升級後訪問</body>

</noframes>

marginwidth：視窗內的內容與視窗左右邊緣的距離

marginheigth：視窗內的內容與視窗上下邊緣的距離

scrolling：是否顯示滾動條，no-不顯示、yes-顯示、auto-預設自動設定

noframes不支援框架的瀏覽器

注意：<body></body>標籤與<frameset></frameset>標籤不能同時使用，不過，如果新增包含一段文字的

<noframes>標籤，就必須將這一段文字巢狀於<body></body>標籤內

JavaScript

1、增強程式碼可讀性

<-- JavaScript程式碼 //-->

2、語法結構

1）大小寫敏感

2）一句話結束最好加;

3）註釋 // /**/

4）弱型別

3、變數命名

1）以字母、下劃線_或美元符號$開頭

2）餘下的字元可以是字母、下劃線_或美元符號$、數字

3）最長為255個字元

4）不能有空格、大小寫敏感

5）不能使用JavaScript中的關鍵字或者保留字命名

4、JS變數型別

Undefined：未定義的型別、String、Boolean、Null、Number五種

可以使用typeof（object）來獲取變數型別

5、宣告 var 變數名[=初始值]

vari = 10;

varj;

alert(typeof(i));//判斷i的型別 number

docement.write(123);

6、型別轉換

字串>數值>布林值低階與高階相加，強制轉換成高階的

字串à數值

parseInt（）、parseFloat（）、Number（）

7、運算子

算術運算子+、-、*、/、%、++、--(前置先自增再運算、後置先運算後自增)

比較運算子 ==、>、>=、<、<=、!=

邏輯運算子 &&、||、!非

賦值運算子 =、+=、-=、*=、/=

8、try{}catch(){}

try{vara=c}catch(e){alert(e);}

Java基礎知識學習筆記總結

相關文章