一篇文章帶你復習java知識點

Posted on by

JDK JRE JVM

JDK:

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

JRE:

Java運⾏環境，⽤於解釋執⾏Java的字節碼⽂件。

JVM

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

區別聯系:(問答題會考可能)

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

JDK用於開發，JRE 用於運⾏java程序

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

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

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

基本語法

程序結構

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

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

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

在這裡插入圖片描述

命名規范

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

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

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

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

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

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

標識符

在這裡插入圖片描述

不能以數字開頭。

不能是Java中的關鍵字。

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

關鍵字

在這裡插入圖片描述

在這裡插入圖片描述

變量和常量

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

常量

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

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

變量

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

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

分類：

按聲明位置：

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

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

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

註意：

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

按所屬類型：

基本數據類型變量（8種）引用數據類型變量

在這裡插入圖片描述

在這裡插入圖片描述

數據類型

在這裡插入圖片描述

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

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

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

基本類型轉換：

boolean類型不可以轉換為其他的數據類型

整型、字符型、浮點型的數據在混合運算中相互轉換，轉換規則：

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

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

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

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

有多種類型的數據混合運算時，系統首先自動將所有數據類型轉換為容量最大的那一種數據類型，然後在進行計算

實數常量默認為double，整數常量默認為int

數組

數組初始化

動態初始化

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

靜態初始化

在定義數組的同時為數組元素分配空間並賦值

在這裡插入圖片描述

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

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

a.length的值為數組a的長度（元素個數）

輸入輸出

輸⼊
 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

優先順序：

在這裡插入圖片描述

語句

條件分支語句

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子句中的值應是不同的；

循環語句

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

修飾符

訪問控制修飾符

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

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

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

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

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

非訪問修飾符

為瞭實現一些其他的功能，Java 也提供瞭許多非訪問修飾符。

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

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

abstract 修飾符，用來創建抽象類和抽象方法。

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

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

volatile 修飾符

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

類與對象

面對對象三⼤特征：封裝、繼承、多態

1.封裝

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

2.繼承

實現數據項和⽅法的隱藏

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

提⾼瞭代碼的重⽤性

3.多態

⼀個對象變量可以指向多種實際類型對象的現象被稱為“多態”

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

多態的好處:

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

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

類

類是用於描述同一類型的對象的一個抽象的概念，類中定義瞭這一類對象所應具有的靜態和動態屬性

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

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

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

在這裡插入圖片描述

對象的創建和使用

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

構造方法

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

註意 ：

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

為什麼？

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

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

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

重載與重寫

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

重載：

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

重寫：

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

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

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

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

常用關鍵字

this

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

1.構造⽅法中指該構造器所創建的新對象；

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隻能在類中的⾮靜態⽅法中使⽤，靜態⽅法和靜態的代碼塊中絕對不能出現this

原因:static⽅法在類加載時就已經存在瞭，但是對象是在創建時才在內存中⽣成

static 關鍵字

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

  • 在類的定義體中、方法的外部可包含static語句塊
  • static語句塊僅在其所屬的類被載入時執行一次
  • 用static聲明的方法為靜態方法，在調用方法時，不會將對象的引用傳遞給它，所以在static方法中不可訪問非static的成員。
  • 靜態方法不再是針對某個對象調用，所以不能訪問非靜態成員
  • 被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——包含執行與網絡相關的操作的類

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

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

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

訪問控制

在這裡插入圖片描述

子類和繼承

java中使用extends關鍵字實現類的繼承機制

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

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

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

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

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

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

子類的繼承性

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

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

繼承中的構造方法

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

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

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

如果子類的構造方法沒有顯示地調用基類構造方法，則系統默認調用基類無參數的構造方法

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

在這裡插入圖片描述

在這裡插入圖片描述

對象轉型

  • 一個基類的引用類型變量可以“指向”其子類的對象
  • 一個基類的引用不可以訪問其子類對象新增加的成員（屬性和方法）
  • 可以使用引用變量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類獨有的⽅法
 }
}
  • 無繼承關系的引用類型間的轉換是非法的

多態

定義：多態是同⼀個⾏為具有多個不同表現形式或形態的能⼒。

一個對象隻能有一種確定數據類型

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

實現繼承方法重寫父類引用指向子類對象

抽象類

public abstract class Action {
 public abstract void doSomething(); //抽象⽅法
 public void test(){
 };
 }
  • 用abstract關鍵字來修飾一個類時，這個類叫做抽象類，用abstract來修飾一個方法時，該方法叫做抽象方法
  • 含有抽象方法的類必須被聲明為抽象類，抽象類必須被繼承，抽象方法必須被重寫
  • 抽象類不能被實例化

抽象方法隻需聲明，而不需實現

常用關鍵字

super關鍵字

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

final

在這裡插入圖片描述

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

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

final修飾類：不能被繼承

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

final修飾變量：

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

接口

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

語法格式：

< 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 結尾的文件中，文件名使用接口名。

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

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

  • 接口與類的區別：

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

接口沒有構造方法。

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

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

接口不是被類繼承瞭，而是要被類實現。

接口支持多繼承。

實體類 抽象類 接口
常量 常量 常量
變量 變量 抽象方法
方法 方法
抽象方法

異常類

異常是在運行期出現的錯誤

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

在這裡插入圖片描述

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

異常的分類

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

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

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

運⾏時異常：

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

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

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

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

代碼

try{
//可能拋出異常的語句
}catch(SomeException1 e){
……
}catch(SomeException2 e){
......
}finally{
……
}
  • try代碼塊包含可能產生異常的代碼
  • try代碼段後跟有一個或多個catch代碼段
  • 每個catch代碼段聲明其能處理的一種特定類型的異常並提供處理的方法
  • 當異常發生時，程序會中止當前的流程，根據獲取異常的類型去執行相應的catch代碼段
  • finally代碼段無論是否發生異常都要執行

java中的常用類

String 類

string類是不可以變序列

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

靜態重載方法

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

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

基本數據類型包裝類

在這裡插入圖片描述

  • ⾃動裝箱

⾃動裝箱即⾃動將基本數據類型轉換成包裝類型

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

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

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

多線程

線程和進程的區別

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

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

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

線程的基本概念

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

線程的創建

Java中線程的創建常⻅有如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、實現Runnable接⼝，並重寫該接⼝的run()⽅法，該run()⽅法同樣是線程執⾏體，創建Runnable實現類的實例，並以此實例作為Thread類的target來創建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接口可以為多個線程提供共享的數據

在實現Runnable接口的類的run方法定義中可以使用Thread的靜態方法

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

線程控制基本方法

在這裡插入圖片描述

由於是靜態方法，sleep可以由類名直接調用

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

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

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

進程狀態

1、新建狀態（New）：新創建瞭一個線程對象。

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

3、運行狀態（Running）：就緒狀態的線程獲取瞭CPU，執行程序代碼。

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

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

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

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

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

問答題

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

答：主要有以下四方面：

1.抽象：

抽象就是忽略一個主題中與當前目標無關的那些方面，以便更充分地註意與當前目標有關的方面。抽象並不打算瞭解全部問題，而隻是選擇其中的一部分，暫時不用部分細節。抽象包括兩個方面，一是過程抽象，二是數據抽象。

2.繼承：

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

3.封裝：

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

4.多態性：

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

String是最基本的數據類型嗎？

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

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

int 和 Integer 有什麼區別？

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

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

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

闡述實體類、抽象類和接口的區別

1、類隻能繼承類，接口隻能繼承接口，類可以實現接口，其它都不行。

2、java中支持單繼承，多實現規則。

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

重載和重寫的區別

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

throws 關鍵字和 throw 關鍵字有什麼區別和聯系？

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

什麼是多態？如何實現多態？

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

error和exception有什麼區別

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

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

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

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

總結

本篇文章就到這裡瞭，希望更夠給你帶來幫助，也希望您能夠多多關註WalkonNet的更多內容！

推薦閱讀：