}

}

執行結果是：

2

分析：try中的return語句調用的函數先于finally中調用的函數執行，

也就是說return語句先執行，finally語句后執行，所以，返回的結果是2。

Return并不是讓函數馬上返回，而是return語句執行后，

將把返回結果放置進函數棧中，此時函數并不是馬上返回，

它要執行finally語句后才真正開始返回。

下面用一個程序來幫助分析：

public class Test {

public static void main(String[] args) {

System.out.println(new Test().test());;

}

int test()

{

try {

return func1();

}

finally {

return func2();

}

}

int func1()

{

System.out.println(“func1”);

return 1;

}

int func2()

{

System.out.println(“func2”);

return 2;

}

}

執行結果：

func1

func2

2

結論：finally中的代碼比return 和break語句后執行

---

3. final, finally, finalize的區別

• final 用于聲明屬性，方法和類，分別表示屬性不可變，方法不可覆蓋，類不可繼承。內部類要訪問局部變量，局部變量必須定義成final類型。

• finally是異常處理語句結構的一部分，表示總是執行。

• finalize是Object類的一個方法，在垃圾收集器執行的時候會調用被回收對象的此方法，可以覆蓋此方法提供垃圾收集時的其他資源回收，例如關閉文件等。JVM不保證此方法總被調用

---

4. Java中的異常處理機制的簡單原理和應用

Java對異常進行了分類，不同類型的異常分別用不同的Java類表示，所有異常的根類為java.lang.Throwable，Throwable下面又派生了兩個子類：Error和Exception。

• Error 表示應用程序本身無法克服和恢復的一種嚴重問題，程序只有死的份了，例如，說內存溢出和線程死鎖等系統問題。

• Exception表示程序還能夠克服和恢復的問題，其中又分為系統異常和普通異常，系統異常是軟件本身缺陷所導致的問題，也就是軟件開發人員考慮不周所導致的問題，軟件使用者無法克服和恢復這種問題，但在這種問題下還可以讓軟件系統繼續運行或者讓軟件死掉，例如:

數組越界（ArrayIndexOutOfBoundsException）

空指針異常（NullPointerException）

類轉換異常（ClassCastException）

找不到類（ClassNotFoundException）

普通異常是運行環境的變化或異常所導致的問題，是用戶能夠克服的問題，例如:網絡斷線，硬盤空間不夠，發生這樣的異常后，程序不應該死掉。

java為系統異常和普通異常提供了不同的解決方案，編譯器強制

• 系統異常可以處理也可以不處理，所以，編譯器不強制用try…catch處理或用throws聲明，所以系統異常也稱為unchecked異常。

• 普通異常必須try…catch處理或用throws聲明繼續拋給上層調用方法處理，所以普通異常也稱為checked異常。

提示答題者，就按照三個級別去思考：

虛擬機必須宕機的錯誤

程序可以死掉也可以不死掉的錯誤

程序不應該死掉的錯誤

---

5. sleep() 和 wait() 有什么區別?

• sleep是線程類（Thread）的方法，導致此線程暫停執行指定時間，給執行機會給其他線程，但是監控狀態依然保持，到時后會自動恢復。調用sleep不會釋放對象鎖。

• wait是Object類的方法，對此對象調用wait方法導致本線程放棄對象鎖，進入等待此對象的等待鎖定池，只有針對此對象發出notify方法（或notifyAll）后本線程才進入對象鎖定池準備獲得對象鎖進入運行狀態。）

下面用一個例子來說明：

public class Test {

public static void main(String[] args) {

new Thread(new Thread1()).start();

try {

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

new Thread(new Thread2()).start();

}

private static class Thread1 implements Runnable {

@Override

public void run() {

// 由于這里的Thread1和下面的Thread2內部run方法要用同一對象作為監視器，

// 我們這里不能用this，因為在Thread2里面的this和這個Thread1的this不是同一個對象。

// 我們用Test.class這個字節碼對象，當前虛擬機里引用這個變量時，指向的都是同一個對象。

synchronized (Test.class) {

System.out.println(“enter thread1…”);

System.out.println(“thread1 is waiting”);

try {

// 釋放鎖有兩種方式:

// 第一種方式是程序自然離開監視器的范圍，也就是離開了synchronized關鍵字管轄的代碼范圍，

// 另一種方式就是在synchronized關鍵字管轄的代碼內部調用監視器對象的wait方法。

// 這里，使用wait方法釋放鎖。

Test.class.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(“thread1 is going on…”);

System.out.println(“thread1 is being over!”);

}

}

}

private static class Thread2 implements Runnable {

@Override

public void run() {

synchronized (Test.class) {

System.out.println(“enter thread2…”);

System.out.println(“thread2 notify other thread can release wait status…”);

// 由于notify方法并不釋放鎖，

// 即使thread2調用下面的sleep方法休息了10毫秒，

// 但thread1仍然不會執行，因為thread2沒有釋放鎖，所以Thread1無法得不到鎖。

Test.class.notify();

System.out.println(“thread2 is sleeping ten millisecond…”);

try {

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(“thread2 is going on…”);

System.out.println(“thread2 is being over!”);

}

}

}

}

執行結果：

enter thread1…

thread1 is waiting

enter thread2…

thread2 notify other thread can release wait status…

thread2 is sleeping ten millisecond…

thread2 is going on…

thread2 is being over!

thread1 is going on…

thread1 is being over!

• sleep就是正在執行的線程主動讓出cpu，cpu去執行其他線程，在sleep指定的時間過后，cpu才會回到這個線程上繼續往下執行，如果當前線程進入了同步鎖，sleep方法并不會釋放鎖，即使當前線程使用sleep方法讓出了cpu，但其他被同步鎖擋住了的線程也無法得到執行。

• wait是指在一個已經進入了同步鎖的線程內，讓自己暫時讓出同步鎖，以便其他正在等待此鎖的線程可以得到同步鎖并運行，只有其他線程調用了notify()方法（notify并不釋放鎖，只是告訴調用過wait方法的線程可以去參與獲得鎖的競爭了，但不是馬上得到鎖，因為鎖還在別人手里，別人還沒釋放。如果notify方法后面的代碼還有很多，需要這些代碼執行完后才會釋放鎖，可以在notfiy方法后增加一個等待和一些代碼，看看效果），調用w

《Android學習筆記總結+最新移動架構視頻+大廠安卓面試真題+項目實戰源碼講義》

【docs.qq.com/doc/DSkNLaERkbnFoS0ZF】 完整內容開源分享

ait方法的線程就會解除wait狀態和程序可以再次得到鎖后繼續向下運行。wait()必須在synchronized內部調用。

---

6. 當一個線程進入一個對象的一個synchronized方法后，其它線程是否可進入此對象的其它方法?

分幾種情況：

其他方法前是否加了synchronized關鍵字，如果沒加，則能。

如果這個方法內部調用了wait，則可以進入其他synchronized方法。

如果其他個方法都加了synchronized關鍵字，并且內部沒有調用wait，則不能。

如果其他方法是static，它用的同步鎖是當前類的字節碼，與非靜態的方法不能同步，因為非靜態的方法用的是this。

---

7. 簡述synchronized和java.util.concurrent.locks.Lock的異同？

• 主要相同點：Lock能完成synchronized所實現的所有功能

• 主要不同點：Lock有比synchronized更精確的線程語義和更好的性能。synchronized會自動釋放鎖，而Lock一定要求程序員手工釋放，并且必須在finally從句中釋放。Lock還有更強大的功能，例如，它的tryLock方法可以非阻塞方式去拿鎖。

例子：

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class Test {

private int j;

// ReentrantLock 可重入鎖，

// 一個線程可以對已被加鎖的ReentrantLock鎖再次加鎖

private Lock lock = new ReentrantLock();

public static void main(String[] args) {

Test tt = new Test();

new Thread(tt.new Adder()).start();

new Thread(tt.new SubTractor()).start();

}

private class SubTractor implements Runnable {

@Override

public void run() {

while (true) {

// synchronized (Test.this) {

// System.out.println(“j–=” + j–);

// //這里拋異常了，鎖能釋放嗎？

// }

lock.lock();

try {

System.out.println("j-- = " + j–);

} finally {

lock.unlock();

}

}

}

}

private class Adder implements Runnable {

@Override

public void run() {

while (true) {

// synchronized (Test.this) {

// System.out.println(“j++=” + j++);

// }

lock.lock();

try {

System.out.println("j++ = " + j++);

} finally {

lock.unlock();

}

}

}

}

}

執行結果：

···

j++ = 42218

j++ = 42219

j++ = 42220

j-- = 42221

j-- = 42220

j-- = 42219

···

---

8. 設計4個線程，其中兩個線程每次對j增加1，另外兩個線程對j每次減少1。寫出程序

public class Test {

private int j;

public static void main(String args[]) {

Test tt = new Test();

Inc inc = tt.new Inc();

Dec dec = tt.new Dec();

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

Thread t = new Thread(inc);

t.start();

t = new Thread(dec);

t.start();

}

}

private synchronized void inc() {

j++;

System.out.println(Thread.currentThread().getName() + “-inc:” + j);

}

private synchronized void dec() {

j–;

System.out.println(Thread.currentThread().getName() + “-dec:” + j);

}

class Inc implements Runnable {

public void run() {

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

inc();

}

}

}

class Dec implements Runnable {

public void run() {

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

dec();

}

}

}

}

執行結果：

···

Thread-0-inc:5

Thread-0-inc:6

Thread-2-inc:7

Thread-2-inc:8

···

Thread-2-inc:105

Thread-2-inc:106

Thread-3-dec:105

Thread-3-dec:104

···

Thread-3-dec:7

Thread-3-dec:6

Thread-1-dec:5

Thread-1-dec:4

···

Thread-1-dec:-20

Thread-1-dec:-21

Thread-0-inc:-20

Thread-0-inc:-19

···

---

9. 子線程循環10次，接著主線程循環5次，接著又回到子線程循環10次，接著再回到主線程又循環5次數。如此循環50次，請寫出程序

public class Test {

public static void main(String[] args) {

new Test().init();

}

public void init() {

final Business business = new Business();

new Thread(new Runnable() {

public void run() {

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

business.SubThread(i); // 子線程

}

}

}).start();

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

business.MainThread(i); // 主線程

}

}

private class Business {

//這里相當于定義了控制該誰執行的一個信號燈

boolean isShouldSub = true;

public synchronized void MainThread(int i) {

if (isShouldSub)

try {

this.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

for (int j = 0; j < 5; j++) {

System.out.println(Thread.currentThread().getName() + “:i=” + i + “,j=” + j);

}

isShouldSub = true;

this.notify();

}

public synchronized void SubThread(int i) {

if (!isShouldSub) {

try {

this.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

for (int j = 0; j < 10; j++) {

System.out.println(Thread.currentThread().getName() + “:i=” + i + “,j=” + j);

}

isShouldSub = false;

this.notify();

}

}

}

執行結果：

···

Thread-0:i=48,j=7

Thread-0:i=48,j=8

Thread-0:i=48,j=9

main:i=48,j=0

main:i=48,j=1

main:i=48,j=2

main:i=48,j=3

main:i=48,j=4

Thread-0:i=49,j=0

Thread-0:i=49,j=1

Thread-0:i=49,j=2

Thread-0:i=49,j=3

Thread-0:i=49,j=4

Thread-0:i=49,j=5

Thread-0:i=49,j=6

Thread-0:i=49,j=7

Thread-0:i=49,j=8

Thread-0:i=49,j=9

main:i=49,j=0

總結

以上是生活随笔為你收集整理的Java 笔试：常见题目总结，android混合开发lua的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。