JDK JRE JVM

JDK:

Java標(biāo)準(zhǔn)開發(fā)包，它提供了編譯、運(yùn)行Java程序所需的各種工具和資源，包括Java編譯器、Java運(yùn)行時(shí)環(huán)境，以及常用的Java類庫(kù)等。

JRE:

Java運(yùn)⾏環(huán)境，⽤于解釋執(zhí)⾏Java的字節(jié)碼⽂件。

JVM

Java虛擬機(jī)，是JRE的一部分。負(fù)責(zé)解釋執(zhí)行字節(jié)碼文件，是可運(yùn)⾏java字節(jié)碼文件的虛擬計(jì)算機(jī)

區(qū)別聯(lián)系:(問答題會(huì)考可能)

JDK包含JRE，JDK 和 JRE 中都包含 JVM。JDK出了包含jre還包含⼀些常⽤開發(fā)⼯具和基礎(chǔ)類庫(kù)

JDK用于開發(fā)，JRE 用于運(yùn)⾏java程序

JVM 是 java 編程語(yǔ)言的核心并且具有平臺(tái)獨(dú)立性（不同的平臺(tái)有不同的VM）

JVM的好處：一次編譯，隨處運(yùn)行

javac: 編譯 java源文件->class字節(jié)碼文件(0,1) java: 解釋

基本語(yǔ)法

程序結(jié)構(gòu)

一個(gè)源文件中最多只能有一個(gè)public類，其他類的個(gè)數(shù)不限，如果源文件中包含一個(gè)public類，它必須按該類名命名

Java應(yīng)用程序的執(zhí)行入口時(shí)main()方法。它有固定的書寫格式：

public static void main(String args[]){…..}

命名規(guī)范

包名，包名是全小寫的名詞，中間可以由點(diǎn)分隔開，例如：java.awt.event;

類名，首字母大寫，通常由多個(gè)單詞合成一個(gè)類名，要求每個(gè)單詞的首字母也要大寫，例如class WelcomeToJava;

接口名，命名規(guī)則與類名相同，例如interface Collection;

方法名，往往由多個(gè)單詞合成，第一個(gè)單詞通常為動(dòng)詞，首字母小寫，中間的每個(gè)單詞的首字母都要大寫，例如：balanceAccount，　isButtonPressed;

變量名，全小寫，一般為名詞，例如：length;

常量名，基本數(shù)據(jù)類型的常量名為全大寫，如果是由多個(gè)單詞構(gòu)成，可以用下劃線隔開，例如：int YEAR, int WEEK_OF_MONTH；如果是對(duì)象類型的常量，則是大小寫混合，由大寫字母把單詞隔開。

標(biāo)識(shí)符

不能以數(shù)字開頭。

不能是Java中的關(guān)鍵字。

標(biāo)識(shí)符不能是true，flase和null（盡管這三個(gè)不是關(guān)鍵字）

關(guān)鍵字

變量和常量

只有public, protected, private, static, final, transient 和 volatile 能修飾成員變量

常量

JAVA常量就是在程序中固定不變的值，是不能改變的數(shù)據(jù)。例如數(shù)字1、字符“a”、浮點(diǎn)數(shù)3.2等。在Java中，常量包括整型常量、浮點(diǎn)數(shù)常量、布爾常量、字符常量等。

使用 final 關(guān)鍵字來定義一個(gè)常量，常量一旦初始化就不可以被修改。

變量

變量是程序中最基本的存儲(chǔ)單元，其要素包括變量名，變量類型和作用域

每一個(gè)變量使用前必須要先聲明，然后必須進(jìn)行賦值，才能使用

分類：

按聲明位置：

局部變量：方法或語(yǔ)句塊內(nèi)部定義的變量

成員變量：方法外部、類的內(nèi)部定義的變量

在類體內(nèi)定義的變量稱為成員變量，它的作⽤域是整個(gè)類在⼀個(gè)⽅法或⽅法內(nèi)代碼塊中定義的變量稱為局部變量

注意：

類外面（與類對(duì)應(yīng)的大括號(hào)外面）不能有變量的聲明方法體內(nèi)部聲明的變量（包括形參）稱為局部變量：方法體內(nèi)部是指與方法對(duì)應(yīng)的大括號(hào)內(nèi)部在方法體外，類體內(nèi)聲明的變量稱為成員變量

按所屬類型：

基本數(shù)據(jù)類型變量（8種）引用數(shù)據(jù)類型變量

數(shù)據(jù)類型

boolean類型數(shù)據(jù)只允許取值true或false，不可以0或非0的整數(shù)替代true和false，這點(diǎn)和C語(yǔ)言不通

Java字符采用Unicode編碼，每個(gè)字符占兩個(gè)字節(jié)，因而可用十六進(jìn)制編碼形式表示

java中的char一定是無符號(hào)的，不允許用unsigned char修飾

基本類型轉(zhuǎn)換：

boolean類型不可以轉(zhuǎn)換為其他的數(shù)據(jù)類型

整型、字符型、浮點(diǎn)型的數(shù)據(jù)在混合運(yùn)算中相互轉(zhuǎn)換，轉(zhuǎn)換規(guī)則：

容量小的類型自動(dòng)轉(zhuǎn)換為容量大的數(shù)據(jù)類型，數(shù)據(jù)類型按照容量大小排序?yàn)椋?/p>

byte,short,char->int,->long->float->double

byte,short,char之間不會(huì)互相轉(zhuǎn)換，三者在計(jì)算時(shí)首先轉(zhuǎn)換為int型

容量大的數(shù)據(jù)類型轉(zhuǎn)換為容量小的數(shù)據(jù)類型時(shí)，要加上強(qiáng)制轉(zhuǎn)換符，但可能造成精度降低或溢出

有多種類型的數(shù)據(jù)混合運(yùn)算時(shí)，系統(tǒng)首先自動(dòng)將所有數(shù)據(jù)類型轉(zhuǎn)換為容量最大的那一種數(shù)據(jù)類型，然后在進(jìn)行計(jì)算

實(shí)數(shù)常量默認(rèn)為double，整數(shù)常量默認(rèn)為int

數(shù)組

數(shù)組初始化

動(dòng)態(tài)初始化

數(shù)組定義與為數(shù)組元素分配空間和賦值的操作分開進(jìn)行

靜態(tài)初始化

在定義數(shù)組的同時(shí)為數(shù)組元素分配空間并賦值

Java語(yǔ)言中聲明數(shù)組時(shí)不能指定其長(zhǎng)度

每個(gè)數(shù)組都有一個(gè)屬性length指明它的長(zhǎng)度

a.length的值為數(shù)組a的長(zhǎng)度（元素個(gè)數(shù)）

輸入輸出

輸⼊
 Scanner s=new Scanner(System.in);
 s.nextInt()
 s.nextLine()
 s.nextFloat()
 scanner.next()
 輸出
System.out.println("XX"）

運(yùn)算符與語(yǔ)句

運(yùn)算符

左移<<

"a<<b; "將二進(jìn)制形式的a逐位左移b位，最低位空出的b位補(bǔ)0

帶符號(hào)右移

"a>>b; "將二進(jìn)制形式的a逐位右移b位，最高位空出的b位補(bǔ)原來的符號(hào)位

無符號(hào)右移

"a>>>b;"將二進(jìn)制形式的a逐位右移b位，最高位空出的b位補(bǔ)0

優(yōu)先順序：

語(yǔ)句

條件分支語(yǔ)句

1.if

else if

else

2.switch

switch(XX){ //java特有 枚舉 short byte C語(yǔ)⾔:字符,int
case 1 : XX ;break;
case 2: XX ;break;
default(可有可⽆): XX break;
}

switch表達(dá)式的返回值必須是下述幾種類型之一：int, byte, char, short；

case子句中的值必須是常量，且所有case子句中的值應(yīng)是不同的；

循環(huán)語(yǔ)句

1. while
2. for
3. do while
4. for each

修飾符

訪問控制修飾符

Java中，可以使用訪問控制符來保護(hù)對(duì)類、變量、方法和構(gòu)造方法的訪問。Java 支持 4 種不同的訪問權(quán)限。

default (即默認(rèn)，什么也不寫）: 在同一包內(nèi)可見，不使用任何修飾符。使用對(duì)象：類、接口、變量、方法。

private : 在同一類內(nèi)可見。使用對(duì)象：變量、方法。 注意：不能修飾類（外部類）

public : 對(duì)所有類可見。使用對(duì)象：類、接口、變量、方法

protected : 對(duì)同一包內(nèi)的類和所有子類可見。使用對(duì)象：變量、方法。 注意：不能修飾類（外部類）。

非訪問修飾符

為了實(shí)現(xiàn)一些其他的功能，Java 也提供了許多非訪問修飾符。

static 修飾符，用來修飾類方法和類變量。

final 修飾符，用來修飾類、方法和變量，final 修飾的類不能夠被繼承，修飾的方法不能被繼承類重新定義，修飾的變量為常量，是不可修改的。

abstract 修飾符，用來創(chuàng)建抽象類和抽象方法。

synchronized 和 volatile 修飾符，主要用于線程的編程。

synchronized 關(guān)鍵字聲明的方法同一時(shí)間只能被一個(gè)線程訪問。synchronized 修飾符可以應(yīng)用于四個(gè)訪問修飾符。

volatile 修飾符

volatile 修飾的成員變量在每次被線程訪問時(shí)，都強(qiáng)制從共享內(nèi)存中重新讀取該成員變量的值

類與對(duì)象

面對(duì)對(duì)象三⼤特征：封裝、繼承、多態(tài)

1.封裝

通過 private、default 、protected、 public 關(guān)鍵字實(shí)現(xiàn)屬性或⽅法的封裝, 僅對(duì)外提供公共訪問⽅式。 “⾼內(nèi)聚，低耦合”

2.繼承

實(shí)現(xiàn)數(shù)據(jù)項(xiàng)和⽅法的隱藏

實(shí)現(xiàn)隱藏隔離，允許外部對(duì)類做有限的訪問,開發(fā)者可以⾃由的改變類的內(nèi)部實(shí)現(xiàn)

提⾼了代碼的重⽤性

3.多態(tài)

⼀個(gè)對(duì)象變量可以指向多種實(shí)際類型對(duì)象的現(xiàn)象被稱為“多態(tài)”

三個(gè)必要條件:繼承、⽅法的重寫、⽗類⼸|⽤指向⼦類對(duì)象

多態(tài)的好處:

提⾼了代碼的維護(hù)性（繼承保證）；提⾼了代碼的擴(kuò)展性

Java中多態(tài)的實(shí)現(xiàn)⽅式:接⼝實(shí)現(xiàn)，繼承⽗類進(jìn)⾏⽅法重寫，同個(gè)類中進(jìn)⾏⽅法重載。⽗類⼸|⽤指向⼦類對(duì)象

類

類是用于描述同一類型的對(duì)象的一個(gè)抽象的概念，類中定義了這一類對(duì)象所應(yīng)具有的靜態(tài)和動(dòng)態(tài)屬性

類的定義包括：類聲明，類體

類可以看成一類對(duì)象的模板，對(duì)象可以看成該類的一個(gè)具體實(shí)例

對(duì)象可以看成是靜態(tài)屬性（成員變量）和動(dòng)態(tài)屬性（方法）的封裝體

對(duì)象的創(chuàng)建和使用

• 必須使用new關(guān)鍵字創(chuàng)建對(duì)象
• 使用對(duì)象（引用）.成員變量或來引用對(duì)象的成員變量
• 使用對(duì)象（引用）.方法（參數(shù)列表）來調(diào)用對(duì)象的方法
• 同一類的每個(gè)對(duì)象有不同的成員變量存儲(chǔ)空間
• 同一類的每個(gè)對(duì)象共享該類的方法

構(gòu)造方法

作用：主要⽤來在創(chuàng)建對(duì)象時(shí)初始化對(duì)象， 即為對(duì)象成員變量賦初始值，總與new運(yùn)算符⼀起使⽤在創(chuàng)建對(duì)象的語(yǔ)句中。

注意 ：

• ⼀個(gè)類可以有多個(gè)構(gòu)造函數(shù) ，可根據(jù)其參數(shù)個(gè)數(shù)的不同或參數(shù)類型的不同來區(qū)分它們,即構(gòu)造函數(shù)的重載
• 使用new+構(gòu)造方法創(chuàng)建一個(gè)新的對(duì)象
• 構(gòu)造函數(shù)的名字必須和所在類名字完全相同
• 構(gòu)造函數(shù)與類同名且沒有返回值
• 如果沒有編寫指定構(gòu)造函數(shù)時(shí)，編譯會(huì)自動(dòng)添加無參數(shù)的構(gòu)造函數(shù)
• 特別： 構(gòu)造函數(shù)不能用final，static，abstract修飾

為什么？

1.final修飾函數(shù)的主要目的是避免函數(shù)被重寫，構(gòu)造器不是通過繼承得到的，所以沒有必要把它聲明為final的。

2.同理，一個(gè)抽象的構(gòu)造器將永遠(yuǎn)不會(huì)被實(shí)現(xiàn)，所以它也不能聲明為abstract的。

3.構(gòu)造器總是關(guān)聯(lián)一個(gè)對(duì)象而被調(diào)用，所以把它聲明為static是沒有意義的。

重載與重寫

方法的重載是指一個(gè)類中可以定義有相同的名字，但參數(shù)不同的多個(gè)方法。調(diào)用時(shí)，系統(tǒng)會(huì)根據(jù)不同的參數(shù)表選擇對(duì)應(yīng)的方法

重載：

1. 必須載同⼀個(gè)類中
2. ⽅法名相同
3. ⽅法的參數(shù)的個(gè)數(shù)、順序或類型不同
4. 與⽅法的修飾符和或返回值沒有關(guān)系
5. 可以有同的返回類型，只要參數(shù)列表不同就可以了；
6. 可以有不同的訪問修飾符；

重寫：

1. 重寫的⽅法必須要和⽗類⼀模⼀樣(包括返回值類型,⽅法名,參數(shù)列表)

2. 重寫的⽅法可以使⽤@Override注解來標(biāo)識(shí)

3. ⼦類中重寫的⽅法的訪問權(quán)限不能低于⽗類中⽅法的訪問權(quán)限

權(quán)限修飾符 : private < 默認(rèn)(什么都不寫) < protected < public

常用關(guān)鍵字

this

Java中為解決變量的命名沖突和不確定性問題，引⼊關(guān)鍵字this代表其所在⽅法的當(dāng)前對(duì)象的引⽤,使用this可以處理方法中成員變量和參數(shù)重名的情況

1.構(gòu)造⽅法中指該構(gòu)造器所創(chuàng)建的新對(duì)象；

public class B{
 	A a; //A是⼀個(gè)類
  	public B(A a){
 		this.a = a;
 	}
}

2.⽅法中指調(diào)⽤該⽅法的對(duì)象；

 public class Baby{
 	public void wakeUp(){
 		System.out.println("寶寶醒啦");
 	}
 	public void eat(){
 		this.wakeUp();
 		System.out.println("吃東⻄");
 	}

在類本身的⽅法或構(gòu)造器中引⽤該類的實(shí)例變量（全局變量）和⽅法

public void setName(String name){
 	this.name=name
}

this只能在類中的⾮靜態(tài)⽅法中使⽤，靜態(tài)⽅法和靜態(tài)的代碼塊中絕對(duì)不能出現(xiàn)this

原因:static⽅法在類加載時(shí)就已經(jīng)存在了，但是對(duì)象是在創(chuàng)建時(shí)才在內(nèi)存中⽣成

static 關(guān)鍵字

在類中，用static聲明的成員變量為靜態(tài)成員變量，它是該類的公用變量，在第一次使用時(shí)被初始化，對(duì)應(yīng)該類的所有對(duì)象來說，static成員變量只有一份

• 在類的定義體中、方法的外部可包含static語(yǔ)句塊
• static語(yǔ)句塊僅在其所屬的類被載入時(shí)執(zhí)行一次
• 用static聲明的方法為靜態(tài)方法，在調(diào)用方法時(shí)，不會(huì)將對(duì)象的引用傳遞給它，所以在static方法中不可訪問非static的成員。
• 靜態(tài)方法不再是針對(duì)某個(gè)對(duì)象調(diào)用，所以不能訪問非靜態(tài)成員
• 被static修飾的變量屬于類變量，可以通過類名.變量名直接引⽤，⽽不需要new出⼀個(gè)類來
• 被static修飾的⽅法屬于類⽅法，可以通過類名.⽅法名直接引⽤，⽽不需要new出⼀個(gè)類來

類的成員變量包括實(shí)例變量和類變量，實(shí)例變量在不同對(duì)象互不相同，類變量被所用對(duì)象共享。

包

package語(yǔ)句作為java源文件的第一條語(yǔ)句，指明該文件中定義的類所在的包（若缺省該語(yǔ)句，則指定為無名包）

JDK包介紹

java.lang——包含一些java語(yǔ)言的核心類，如String、Math、Integer、System和Thread，提供常用功能

java.awt——包含了構(gòu)成抽象窗口工具包（abstract window toolkits）的多個(gè)類，這些類被用來構(gòu)建和管理應(yīng)用程序的圖形用戶界面（GUI）

java.applet——包含applet運(yùn)行所需的一些類

java.net——包含執(zhí)行與網(wǎng)絡(luò)相關(guān)的操作的類

java.io——包含能提供多種輸入/輸出功能的類

java.util——包含一些使用工具類，如定義系統(tǒng)特性，使用與日期日歷相關(guān)的函數(shù)

打包命令：jar –cvf xx.jar .

訪問控制

子類和繼承

java中使用extends關(guān)鍵字實(shí)現(xiàn)類的繼承機(jī)制

通過繼承，子類自動(dòng)擁有了基類（superclass）的所有成員（成員變量和方法）

Object類是所有Java類的最高層父類

java只支持單繼承，不允許多繼承

一個(gè)子類只能有一個(gè)基類，一個(gè)基類可以派生出多個(gè)子類

子類繼承的方法只能操作子類繼承和隱藏的成員變量。

子類重寫或新增的方法可以操作子類繼承和新聲明的成員變量，但是不能直接操作隱藏的成員變量

子類的繼承性

如果子類和父類在同一個(gè)包，那么子類可以繼承父類中的所有的非private變量和方法。

如果不在同一個(gè)包，那么父類中的private和友好訪問權(quán)限的成員變量和方法不會(huì)被子類繼承。

繼承中的構(gòu)造方法

子類的構(gòu)造的過程必須調(diào)用其基類的構(gòu)造方法

子類可以在自己的構(gòu)造方法中使用super調(diào)用基類的構(gòu)造方法，使用this調(diào)用本類的另外的構(gòu)造方法

使用super，必須寫在子類構(gòu)造方法的第一行

如果子類的構(gòu)造方法沒有顯示地調(diào)用基類構(gòu)造方法，則系統(tǒng)默認(rèn)調(diào)用基類無參數(shù)的構(gòu)造方法

如果子類構(gòu)造方法中既沒有顯式調(diào)用基類構(gòu)造方法，而基類中又沒有無參的構(gòu)造方法，則編譯出錯(cuò)

對(duì)象轉(zhuǎn)型

• 一個(gè)基類的引用類型變量可以“指向”其子類的對(duì)象
• 一個(gè)基類的引用不可以訪問其子類對(duì)象新增加的成員（屬性和方法）
• 可以使用引用變量instanceof類名來判斷該引用型變量所“指向”的對(duì)象是否屬于該類或該類的子類
• 子類的對(duì)象可以當(dāng)做基類的對(duì)象來使用稱作向上轉(zhuǎn)型（upcasting)，反之稱為向下轉(zhuǎn)型（downcasting）

向上轉(zhuǎn)型:

class A {
 public void print() {
 System.out.println("A:print");
 }
}
class B extends A {
 public void print() { 
 System.out.println("B:print");
 }
}
public class Test{
 public static void main(String args[])
 {
 A a = new B(); //通過⼦類去實(shí)例化⽗類
 a.print();
 }
}

向下轉(zhuǎn)型:

class A {
 public void print() {
 System.out.println("A:print");
 }
}
class B extends A {
 public void print() { 
 System.out.println("B:print");
 }
 public void funcB(){System.out.println("funcB");
 }
}
public class Test{
 public static void main(String args[])
 {
 B b = (B)a; //向下轉(zhuǎn)型,通過⽗類實(shí)例化⼦類
 b.funcB(); //調(diào)⽤B類獨(dú)有的⽅法
 }
}

• 無繼承關(guān)系的引用類型間的轉(zhuǎn)換是非法的

多態(tài)

定義：多態(tài)是同⼀個(gè)⾏為具有多個(gè)不同表現(xiàn)形式或形態(tài)的能⼒。

一個(gè)對(duì)象只能有一種確定數(shù)據(jù)類型

一個(gè)引用類型變量可能指向（引用）多種不同類型的對(duì)象

實(shí)現(xiàn)繼承方法重寫父類引用指向子類對(duì)象

抽象類

public abstract class Action {
 public abstract void doSomething(); //抽象⽅法
 public void test(){
 };
 }

• 用abstract關(guān)鍵字來修飾一個(gè)類時(shí)，這個(gè)類叫做抽象類，用abstract來修飾一個(gè)方法時(shí)，該方法叫做抽象方法
• 含有抽象方法的類必須被聲明為抽象類，抽象類必須被繼承，抽象方法必須被重寫
• 抽象類不能被實(shí)例化

抽象方法只需聲明，而不需實(shí)現(xiàn)

常用關(guān)鍵字

super關(guān)鍵字

• super關(guān)鍵字主要存在于⼦類⽅法中，⽤于指向⼦類對(duì)象中的⽗類對(duì)象；可以訪問⽗類的屬性、函數(shù)以及構(gòu)造函數(shù)。
• ⼦⽗類存在著同名的成員（包括變量和⽅法）時(shí)，在⼦類中默認(rèn)是訪問⼦類的成員，可以通過super關(guān)鍵字指定訪問⽗類的成員；
• 默認(rèn)會(huì)先調(diào)⽤⽗類⽆參的構(gòu)造⽅法，可以通過super關(guān)鍵字指定調(diào)⽤⽗類的構(gòu)造⽅法。

final

可以修飾：類，成員變量和方法中的局部變量

final的變量的值不能夠被改變

final修飾類：不能被繼承

Final修飾⽅法： 不能被重寫，但是⼦類可以⽤⽗類中final修飾的⽅法

final修飾變量：

1. 基本類型變量使⽤final修飾了就不可變了，成員變量或局部變量被修飾為final就是常量，聲明常量時(shí)必須指定常量的值
2. 對(duì)于引⽤類型變量被final修飾了:引⽤變量引⽤不可變，但是引⽤對(duì)象的內(nèi)容可以改變。

接口

• 接口中只能有常量和abstract方法
• 多個(gè)無關(guān)的類可以實(shí)現(xiàn)同一個(gè)接口
• 一個(gè)類可以實(shí)現(xiàn)多個(gè)無關(guān)的接口
• 與繼承關(guān)系類似，接口與實(shí)現(xiàn)類之間存在多態(tài)性

語(yǔ)法格式：

< modifier > class < name > [ extends< superclass > ] [ implements < interface > ,< interface > ]

public interface UserService {
 //接⼝中的所有定義的⽅法中其實(shí)都是抽象的 public abstract
 //變量只能為 public static final 類型的
 //public abstract void add();
 //等效于 void add();
 //int age = 99; 等效于
 //public static final int age = 99;
 int age = 99;
 void add(String name);
 void delete(String name);
 void update(String name);
 void query(String name);
 }

• 接口中聲明屬性默認(rèn)為public static final的；也只能是public static final的；
• 接口中只能定義抽象方法，而且這些方法默認(rèn)為public的、也只能是public的
• 接口可以繼承其他的接口，并添加新的屬性和抽象方法

接口和類的比較

• 接口與類相似點(diǎn)：

一個(gè)接口可以有多個(gè)方法。

接口文件保存在 .java 結(jié)尾的文件中，文件名使用接口名。

接口的字節(jié)碼文件保存在 .class 結(jié)尾的文件中。

接口相應(yīng)的字節(jié)碼文件必須在與包名稱相匹配的目錄結(jié)構(gòu)中。

• 接口與類的區(qū)別：

接口不能用于實(shí)例化對(duì)象。

接口沒有構(gòu)造方法。

接口中所有的方法必須是抽象方法。

接口不能包含成員變量，除了 static 和 final 變量。

接口不是被類繼承了，而是要被類實(shí)現(xiàn)。

接口支持多繼承。

異常類

異常是在運(yùn)行期出現(xiàn)的錯(cuò)誤

• Java異常是Java提供的用于處理程序中錯(cuò)誤的一種機(jī)制
• 所謂錯(cuò)誤是指在程序運(yùn)行的過程中發(fā)生的一些異常事件（如：除0溢出，數(shù)組下標(biāo)越界，所要讀取的文件不存在）
• 設(shè)計(jì)良好的程序應(yīng)該在異常發(fā)生時(shí)提供處理這些錯(cuò)誤的地方，使得程序不會(huì)因?yàn)楫惓５陌l(fā)生而阻斷或產(chǎn)生不可預(yù)見的結(jié)果
• Java程序的執(zhí)行過程中如出現(xiàn)異常事件，可以生成一個(gè)異常類對(duì)象，該異常對(duì)象封裝了異常事件的信息并將被提交給Java運(yùn)行時(shí)系統(tǒng)，這個(gè)過程稱為拋出（throw）異常
• 當(dāng)Java運(yùn)行時(shí)系統(tǒng)接收到異常對(duì)象時(shí)，會(huì)尋求能處理這一異常的代碼并把當(dāng)前異常對(duì)象交給其處理，這一過程稱為捕獲（catch）異常

異常和錯(cuò)誤的區(qū)別是：異常能被程序本身可以處理，錯(cuò)誤是⽆法處理。

異常的分類

• Error：稱為錯(cuò)誤，由Java虛擬機(jī)生成并拋出，包括動(dòng)態(tài)鏈接失敗、虛擬機(jī)錯(cuò)誤等，程序?qū)ζ洳蛔鎏幚?/li>

Exception：所有異常類的父類，其子類對(duì)應(yīng)了各種各樣可能出現(xiàn)的異常事件，一般需要用戶顯式的聲明或捕獲

Exception（異常）分兩⼤類：運(yùn)⾏時(shí)異常和⾮運(yùn)⾏時(shí)異常(編譯異常)。

運(yùn)⾏時(shí)異常：

如NullPointerException(空指針異常)、 IndexOutOfBoundsException(下標(biāo)越界異常)

等，這些異常是不檢查異常，程序中可以選擇捕獲處理，也可以不處理 ⾮運(yùn)⾏時(shí)異常 （編譯異常）：

是RuntimeException以外的異常，類型上都屬于Exception類及其⼦類。從程序語(yǔ)法⻆度講是必須進(jìn)⾏ 處理的異常，如果不處理，程序就不能編譯通過。如IOException、SQLException等以及⽤戶⾃定義的Exception異常.

• Runtime Exception：一類特殊的異常，如被0除、數(shù)組下標(biāo)越界等，其產(chǎn)生比較頻繁，處理麻煩，如果顯式的聲明或捕獲將會(huì)對(duì)程序可讀性和運(yùn)行效率影響很大，因此由系統(tǒng)自動(dòng)檢測(cè)并將它們交給缺省的異常處理程序（用戶可不必對(duì)其處理）

代碼

try{
//可能拋出異常的語(yǔ)句
}catch(SomeException1 e){
……
}catch(SomeException2 e){
......
}finally{
……
}

• try代碼塊包含可能產(chǎn)生異常的代碼
• try代碼段后跟有一個(gè)或多個(gè)catch代碼段
• 每個(gè)catch代碼段聲明其能處理的一種特定類型的異常并提供處理的方法
• 當(dāng)異常發(fā)生時(shí)，程序會(huì)中止當(dāng)前的流程，根據(jù)獲取異常的類型去執(zhí)行相應(yīng)的catch代碼段
• finally代碼段無論是否發(fā)生異常都要執(zhí)行

java中的常用類

String 類

string類是不可以變序列

String不變的性質(zhì)是因?yàn)槊看味紡腟tring 池⾥⾯取，如果有則直接⽤，否則創(chuàng)建新的放⼊

靜態(tài)重載方法

public static String valueOf(…)可以將基本類型數(shù)據(jù)轉(zhuǎn)換為字符串

String類初始化

String str1 = “HelloWorld”;
Sting str2 = new String();
str2="HelloWorld"
String str3 = new String(“HelloWorld”);

String 類的常見操作

1 char charAt(int index)
返回指定索引處的 char 值。
String concat(String str)
將指定字符串連接到此字符串的結(jié)尾。
int indexOf(char ch)
返回指定字符在此字符串中第⼀次出現(xiàn)處的索引
boolean equals(Object anObject)
將此字符串與指定的對(duì)象⽐較。
 String replace(char oldChar, char newChar)
返回⼀個(gè)新的字符串，它是通過⽤ newChar 替換此字符串中出現(xiàn)的所有 oldChar 得到的。
String replaceAll(String regex, String replacement)
使⽤給定的 replacement 替換此字符串所有匹配給定的正則表達(dá)式的⼦字符串。
int compareTo( NumberSubClass referenceName )
如果指定的數(shù)與參數(shù)相等返回0。
如果指定的數(shù)小于參數(shù)返回 -1。
如果指定的數(shù)大于參數(shù)返回 1。

基本數(shù)據(jù)類型包裝類

• ⾃動(dòng)裝箱

⾃動(dòng)裝箱即⾃動(dòng)將基本數(shù)據(jù)類型轉(zhuǎn)換成包裝類型

//早期基本數(shù)據(jù)類型->包裝類型
Integer i1 = new Integer(8); //int->Integer
Integer i2 = Integer.valueOf(8); //int->Integer
//現(xiàn)在是⾃動(dòng)裝箱(⾃動(dòng)基本數(shù)據(jù)類型->包裝類型轉(zhuǎn)換)
Integer i3 = 8;//8是int類型

• ⾃動(dòng)拆箱

⾃動(dòng)拆箱即⾃動(dòng)將包裝類型轉(zhuǎn)換成基本數(shù)據(jù)類型，與⾃動(dòng)裝箱相反 //早期包裝數(shù)據(jù)類型->基本類型轉(zhuǎn)換

Float i=3.3;
float i5 = i.floatValue();
Integer i2=3;
int m=i2.intValue();
// ⾃動(dòng)拆箱(⾃動(dòng)包裝數(shù)據(jù)類型->基本類型轉(zhuǎn)換)
Integer i=3;
int i4 = i;

多線程

線程和進(jìn)程的區(qū)別

• 每個(gè)進(jìn)程都有獨(dú)立的代碼和數(shù)據(jù)空間（進(jìn)程上下文），進(jìn)程間的切換會(huì)有較大的開銷
• 線程可以看成是輕量級(jí)的進(jìn)程，同一類線程共享代碼和數(shù)據(jù)空間，每個(gè)線程都有獨(dú)立的運(yùn)行棧和程序計(jì)數(shù)器（PC），線程切換開銷小

多進(jìn)程：在操作系統(tǒng)中能同時(shí)運(yùn)行多個(gè)任務(wù)（程序）

多線程：在同一應(yīng)用程序中有多個(gè)順序流同時(shí)執(zhí)行

線程的基本概念

• Java的線程通過java.lang.Thread類來實(shí)現(xiàn)的
• VM啟動(dòng)時(shí)，會(huì)有一個(gè)由主方法（public static void main())定義的線程
• 可以通過創(chuàng)建Thread類的實(shí)例來創(chuàng)建線程
• 每個(gè)線程都是通過某個(gè)特定Thread對(duì)象所對(duì)應(yīng)的方法run()來完成其操作的，方法run()稱為線程體
• 通過調(diào)用Thread類的start()方法來啟動(dòng)一個(gè)線程

線程的創(chuàng)建

Java中線程的創(chuàng)建常⻅有如2種基本形式

1.繼承Thread類，重寫該類的run()⽅法

class MyThread extends Thread {
	private int i = 0;
	 @Override
 	public void run() {
 		for (i = 0; i < 100; i++) {
 			System.out.println(Thread.currentThread().getName() + " " + i);
		}
 	}
}

2、實(shí)現(xiàn)Runnable接⼝，并重寫該接⼝的run()⽅法，該run()⽅法同樣是線程執(zhí)⾏體，創(chuàng)建Runnable實(shí)現(xiàn)類的實(shí)例，并以此實(shí)例作為Thread類的target來創(chuàng)建Thread對(duì)象，該Thread對(duì)象才是真正的線程對(duì)象

class MyRunnable implements Runnable {
	private int i = 0;
 	@Override
 	public void run() {
	 	for (i = 0; i < 100; i++) {
	 		System.out.println(Thread.currentThread().getName() + " " + i);
	 	}
 	}
 }

Thread myThread=new Thread(target);//target為Runnable接口類型

Runnabel接口中只有一個(gè)方法

public void run();//用以定義線程運(yùn)行體

使用Runnable接口可以為多個(gè)線程提供共享的數(shù)據(jù)

在實(shí)現(xiàn)Runnable接口的類的run方法定義中可以使用Thread的靜態(tài)方法

public static Thread currentThread()獲取當(dāng)前線程的引用

線程控制基本方法

由于是靜態(tài)方法，sleep可以由類名直接調(diào)用

sleep()⽅法和wait()⽅法：

• 相同點(diǎn)：⼀旦執(zhí)⾏⽅法以后，都會(huì)使得當(dāng)前的進(jìn)程進(jìn)⼊阻塞狀態(tài)。
• 不同點(diǎn)：

1. ⽅法聲明⽅式不同，sleep()⽅法在Thread類中聲明，wait()⽅法在Object類中聲明。
2. 調(diào)⽤的條件不同，sleep可以在任何需要的場(chǎng)景下調(diào)⽤，wait必須使⽤在同步代碼塊或者同步⽅法中。
3. 是否釋放鎖，sleep不會(huì)釋放，wait會(huì)釋放
4. sleep()⽅法 :sleep()使當(dāng)前線程進(jìn)⼊阻塞狀態(tài)，在指定時(shí)間內(nèi)不會(huì)執(zhí)⾏。⾃動(dòng)蘇醒

wait()⽅法: 不會(huì)主動(dòng)蘇醒，需要另外的線程調(diào)⽤notify()/notifyAll()⽅法喚醒。

進(jìn)程狀態(tài)

1、新建狀態(tài)（New）：新創(chuàng)建了一個(gè)線程對(duì)象。

2、就緒狀態(tài)（Runnable）：線程對(duì)象創(chuàng)建后，其他線程調(diào)用了該對(duì)象的start()方法。該狀態(tài)的線程位于可運(yùn)行線程池中，變得可運(yùn)行，等待獲取CPU的使用權(quán)。

3、運(yùn)行狀態(tài)（Running）：就緒狀態(tài)的線程獲取了CPU，執(zhí)行程序代碼。

4、阻塞狀態(tài)（Blocked）：阻塞狀態(tài)是線程因?yàn)槟撤N原因放棄CPU使用權(quán)，暫時(shí)停止運(yùn)行。直到線程進(jìn)入就緒狀態(tài)，才有機(jī)會(huì)轉(zhuǎn)到運(yùn)行狀態(tài)。阻塞的情況分三種：

（一）、等待阻塞：運(yùn)行的線程執(zhí)行wait()方法，JVM會(huì)把該線程放入等待池中。

（二）、同步阻塞：運(yùn)行的線程在獲取對(duì)象的同步鎖時(shí)，若該同步鎖被別的線程占用，則JVM會(huì)把該線程放入鎖池中。

（三）、其他阻塞：運(yùn)行的線程執(zhí)行sleep()或join()方法，或者發(fā)出了I/O請(qǐng)求時(shí)，JVM會(huì)把該線程置為阻塞狀態(tài)。當(dāng)sleep()狀態(tài)超時(shí)、join()等待線程終止或者超時(shí)、或者I/O處理完畢時(shí)，線程重新轉(zhuǎn)入就緒狀態(tài)。

5、死亡狀態(tài)（Dead）：線程執(zhí)行完了或者因異常退出了run()方法，該線程結(jié)束生命周期。

問答題

• 面向?qū)ο蟮奶卣饔心男┓矫?？

答：主要有以下四方面：

1.抽象：

抽象就是忽略一個(gè)主題中與當(dāng)前目標(biāo)無關(guān)的那些方面，以便更充分地注意與當(dāng)前目標(biāo)有關(guān)的方面。抽象并不打算了解全部問題，而只是選擇其中的一部分，暫時(shí)不用部分細(xì)節(jié)。抽象包括兩個(gè)方面，一是過程抽象，二是數(shù)據(jù)抽象。

2.繼承：

繼承是一種聯(lián)結(jié)類的層次模型，并且允許和鼓勵(lì)類的重用，它提供了一種明確表述共性的方法。對(duì)象的一個(gè)新類可以從現(xiàn)有的類中派生，這個(gè)過程稱為類繼承。新類繼承了原始類的特性，新類稱為原始類的派生類（子類），而原始類稱為新類的基類（父類）。派生類可以從它的基類那里繼承方法和實(shí)例變量，并且類可以修改或增加新的方法使之更適合特殊的需要。

3.封裝：

封裝是把過程和數(shù)據(jù)包圍起來，對(duì)數(shù)據(jù)的訪問只能通過已定義的界面。面向?qū)ο笥?jì)算始于這個(gè)基本概念，即現(xiàn)實(shí)世界可以被描繪成一系列完全自治、封裝的對(duì)象，這些對(duì)象通過一個(gè)受保護(hù)的接口訪問其他對(duì)象。

4.多態(tài)性：

多態(tài)性是指允許不同類的對(duì)象對(duì)同一消息作出響應(yīng)。多態(tài)性包括參數(shù)化多態(tài)性和包含多態(tài)性。多態(tài)性語(yǔ)言具有靈活、抽象、行為共享、代碼共享的優(yōu)勢(shì)，很好的解決了應(yīng)用程序函數(shù)同名問題。

String是最基本的數(shù)據(jù)類型嗎？

答：基本數(shù)據(jù)類型包括byte、int、char、long、float、double、boolean和short。（8個(gè)）

java.lang.String類是final類型的，因此不可以繼承這個(gè)類、不能修改這個(gè)類。為了提高效率節(jié)省空間，我們應(yīng)該用StringBuffer類

int 和 Integer 有什么區(qū)別？

答：Java 提供兩種不同的類型：引用類型和原始類型（或內(nèi)置類型）。Int是java的原始數(shù)據(jù)類型，Integer是java為int提供的封裝類。Java為每個(gè)原始類型提供了封裝類。

一個(gè)".java"源文件中是否可以包括多個(gè)類（不是內(nèi)部類）？有什么限制？

答：可以。必須只有一個(gè)類名與文件名相同。

闡述實(shí)體類、抽象類和接口的區(qū)別

1、類只能繼承類，接口只能繼承接口，類可以實(shí)現(xiàn)接口，其它都不行。

2、java中支持單繼承，多實(shí)現(xiàn)規(guī)則。

抽象類與接口都用于抽象，但是抽象類(JAVA中)可以有自己的部分實(shí)現(xiàn)，而接口則完全是一個(gè)標(biāo)識(shí)(同時(shí)有多重繼承的功能)。

重載和重寫的區(qū)別

• 方法的重寫Overriding和重載Overloading是Java多態(tài)性的不同表現(xiàn)。
• 重寫Overriding是父類與子類之間多態(tài)性的一種表現(xiàn)，重載Overloading是一個(gè)類中多態(tài)性的一種表現(xiàn)。如果在子類中定義某方法與其父類有相同的名稱和參數(shù)，我們說該方法被重寫 (Overriding)。子類的對(duì)象使用這個(gè)方法時(shí)，將調(diào)用子類中的定義，對(duì)它而言，父類中的定義如同被"屏蔽"了。如果在一個(gè)類中定義了多個(gè)同名的方法，它們或有不同的參數(shù)個(gè)數(shù)或有不同的參數(shù)類型，則稱為方法的重載(Overloading)。Overloaded的方法是可以改變返回值的類型

throws 關(guān)鍵字和 throw 關(guān)鍵字有什么區(qū)別和聯(lián)系？

• throw⽤來在⽅法體內(nèi)拋出異常，⽽throws⽤來在⽅法聲明處聲明異常。
• 這兩個(gè)關(guān)鍵字有著⼀定的聯(lián)系。如果⼀個(gè)⽅法中使⽤了throw關(guān)鍵字拋出了異常，那么要么⽴即⽤try/catch語(yǔ)句進(jìn)⾏捕獲，要么就是⽤throws進(jìn)⾏聲明，否則將出現(xiàn)編譯錯(cuò)誤。
• 然⽽， 并不是只有使⽤了throw關(guān)鍵字之后才能使⽤throws關(guān)鍵字，語(yǔ)法上來說，任何⼀個(gè)⽅法都可以直接使⽤throws關(guān)鍵字，抽象⽅法也可以使⽤。

什么是多態(tài)？如何實(shí)現(xiàn)多態(tài)？

• 多態(tài)性(Polymorphism)是指在基類中定義的屬性或⽅法被派⽣類繼承后，可以具有不同的數(shù)據(jù)類型，或表現(xiàn)出不同的⾏為，從⽽使得同⼀個(gè)屬性或⽅法在基類及其各個(gè)派⽣類中具有不同的語(yǔ)義。
• Java的多態(tài)性體現(xiàn)在兩個(gè)⽅⾯：(1) ⽅法重載實(shí)現(xiàn)的靜態(tài)多態(tài)性，⼜稱為編譯時(shí)多態(tài)；(2) ⽅法覆蓋/重寫實(shí)現(xiàn)的動(dòng)態(tài)多態(tài)性，⼜稱為運(yùn)⾏時(shí)多態(tài)。

error和exception有什么區(qū)別

• error 表示恢復(fù)不是不可能但很困難的情況下的一種嚴(yán)重問題。比如說內(nèi)存溢出。不可能指望程序能處理這樣的情況

exception 表示一種設(shè)計(jì)或?qū)崿F(xiàn)問題。也就是說，它表示如果程序運(yùn)行正常，從不會(huì)發(fā)生的情況

接口是否可繼承接口? 抽象類是否可實(shí)現(xiàn)(implements)接口? 抽象類是否可繼承實(shí)體類(concrete class)

• 接口可以繼承接口。抽象類可以實(shí)現(xiàn)(implements)接口，抽象類是否可繼承實(shí)體類，但前提是實(shí)體類必須有明確的構(gòu)造函數(shù)

總結(jié)

本篇文章就到這里了，希望更夠給你帶來幫助，也希望您能夠多多關(guān)注腳本之家的更多內(nèi)容！

最新評(píng)論