JDK JRE JVM

JDK:

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

JRE:

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

JVM

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

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

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

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

JVM 是 java 編程語言的核心并且具有平臺獨立性（不同的平臺有不同的VM）

JVM的好處：一次編譯，隨處運行

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

基本語法

程序結構

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

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

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

命名規(guī)范

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

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

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

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

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

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

標識符

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

不能是Java中的關鍵字。

標識符不能是true，flase和null（盡管這三個不是關鍵字）

關鍵字

變量和常量

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

常量

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

使用 final 關鍵字來定義一個常量，常量一旦初始化就不可以被修改。

變量

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

每一個變量使用前必須要先聲明，然后必須進行賦值，才能使用

分類：

按聲明位置：

局部變量：方法或語句塊內部定義的變量

成員變量：方法外部、類的內部定義的變量

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

注意：

類外面（與類對應的大括號外面）不能有變量的聲明方法體內部聲明的變量（包括形參）稱為局部變量：方法體內部是指與方法對應的大括號內部在方法體外，類體內聲明的變量稱為成員變量

按所屬類型：

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

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

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

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

java中的char一定是無符號的，不允許用unsigned char修飾

基本類型轉換：

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

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

容量小的類型自動轉換為容量大的數(shù)據(jù)類型，數(shù)據(jù)類型按照容量大小排序為：

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

byte,short,char之間不會互相轉換，三者在計算時首先轉換為int型

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

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

實數(shù)常量默認為double，整數(shù)常量默認為int

數(shù)組

數(shù)組初始化

動態(tài)初始化

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

靜態(tài)初始化

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

Java語言中聲明數(shù)組時不能指定其長度

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

a.length的值為數(shù)組a的長度（元素個數(shù)）

輸入輸出

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

運算符與語句

運算符

左移<<

"a<<b; "將二進制形式的a逐位左移b位，最低位空出的b位補0

帶符號右移

"a>>b; "將二進制形式的a逐位右移b位，最高位空出的b位補原來的符號位

無符號右移

"a>>>b;"將二進制形式的a逐位右移b位，最高位空出的b位補0

優(yōu)先順序：

語句

條件分支語句

1.if

else if

else

2.switch

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

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

case子句中的值必須是常量，且所有case子句中的值應是不同的；

循環(huán)語句

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

修飾符

訪問控制修飾符

Java中，可以使用訪問控制符來保護對類、變量、方法和構造方法的訪問。Java 支持 4 種不同的訪問權限。

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

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

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

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

非訪問修飾符

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

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

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

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

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

synchronized 關鍵字聲明的方法同一時間只能被一個線程訪問。synchronized 修飾符可以應用于四個訪問修飾符。

volatile 修飾符

volatile 修飾的成員變量在每次被線程訪問時，都強制從共享內存中重新讀取該成員變量的值

類與對象

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

1.封裝

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

2.繼承

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

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

提⾼了代碼的重⽤性

3.多態(tài)

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

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

多態(tài)的好處:

提⾼了代碼的維護性（繼承保證）；提⾼了代碼的擴展性

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

類

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

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

類可以看成一類對象的模板，對象可以看成該類的一個具體實例

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

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

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

構造方法

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

注意 ：

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

為什么？

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

2.同理，一個抽象的構造器將永遠不會被實現(xiàn)，所以它也不能聲明為abstract的。

3.構造器總是關聯(lián)一個對象而被調用，所以把它聲明為static是沒有意義的。

重載與重寫

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

重載：

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

重寫：

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

2. 重寫的⽅法可以使⽤@Override注解來標識

3. ⼦類中重寫的⽅法的訪問權限不能低于⽗類中⽅法的訪問權限

權限修飾符 : private < 默認(什么都不寫) < protected < public

常用關鍵字

this

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

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

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

2.⽅法中指調⽤該⽅法的對象；

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

在類本身的⽅法或構造器中引⽤該類的實例變量（全局變量）和⽅法

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

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

原因:static⽅法在類加載時就已經存在了，但是對象是在創(chuàng)建時才在內存中⽣成

static 關鍵字

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

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

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

包

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

JDK包介紹

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

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

java.applet——包含applet運行所需的一些類

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

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

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

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

訪問控制

子類和繼承

java中使用extends關鍵字實現(xiàn)類的繼承機制

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

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

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

一個子類只能有一個基類，一個基類可以派生出多個子類

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

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

子類的繼承性

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

如果不在同一個包，那么父類中的private和友好訪問權限的成員變量和方法不會被子類繼承。

繼承中的構造方法

子類的構造的過程必須調用其基類的構造方法

子類可以在自己的構造方法中使用super調用基類的構造方法，使用this調用本類的另外的構造方法

使用super，必須寫在子類構造方法的第一行

如果子類的構造方法沒有顯示地調用基類構造方法，則系統(tǒng)默認調用基類無參數(shù)的構造方法

如果子類構造方法中既沒有顯式調用基類構造方法，而基類中又沒有無參的構造方法，則編譯出錯

對象轉型

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

向上轉型:

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(); //通過⼦類去實例化⽗類
 a.print();
 }
}

向下轉型:

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; //向下轉型,通過⽗類實例化⼦類
 b.funcB(); //調⽤B類獨有的⽅法
 }
}

• 無繼承關系的引用類型間的轉換是非法的

多態(tài)

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

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

一個引用類型變量可能指向（引用）多種不同類型的對象

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

抽象類

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

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

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

常用關鍵字

super關鍵字

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

final

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

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

final修飾類：不能被繼承

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

final修飾變量：

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

接口

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

語法格式：

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

public interface UserService {
 //接⼝中的所有定義的⽅法中其實都是抽象的 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);
 }

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

接口和類的比較

• 接口與類相似點：

一個接口可以有多個方法。

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

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

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

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

接口不能用于實例化對象。

接口沒有構造方法。

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

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

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

接口支持多繼承。

異常類

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

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

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

異常的分類

• Error：稱為錯誤，由Java虛擬機生成并拋出，包括動態(tài)鏈接失敗、虛擬機錯誤等，程序對其不做處理

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

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

運⾏時異常：

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

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

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

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

代碼

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

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

java中的常用類

String 類

string類是不可以變序列

String不變的性質是因為每次都從String 池⾥⾯取，如果有則直接⽤，否則創(chuàng)建新的放⼊

靜態(tài)重載方法

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

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

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

• ⾃動裝箱

⾃動裝箱即⾃動將基本數(shù)據(jù)類型轉換成包裝類型

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

• ⾃動拆箱

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

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

多線程

線程和進程的區(qū)別

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

多進程：在操作系統(tǒng)中能同時運行多個任務（程序）

多線程：在同一應用程序中有多個順序流同時執(zhí)行

線程的基本概念

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

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

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接口中只有一個方法

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

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

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

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

線程控制基本方法

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

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

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

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

wait()⽅法: 不會主動蘇醒，需要另外的線程調⽤notify()/notifyAll()⽅法喚醒。

進程狀態(tài)

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

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

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

4、阻塞狀態(tài)（Blocked）：阻塞狀態(tài)是線程因為某種原因放棄CPU使用權，暫時停止運行。直到線程進入就緒狀態(tài)，才有機會轉到運行狀態(tài)。阻塞的情況分三種：

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

（二）、同步阻塞：運行的線程在獲取對象的同步鎖時，若該同步鎖被別的線程占用，則JVM會把該線程放入鎖池中。

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

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

問答題

• 面向對象的特征有哪些方面 ？

答：主要有以下四方面：

1.抽象：

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

2.繼承：

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

3.封裝：

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

4.多態(tài)性：

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

exception 表示一種設計或實現(xiàn)問題。也就是說，它表示如果程序運行正常，從不會發(fā)生的情況

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

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

總結

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

最新評論