Java基礎：

1、Object 類中的方法

registerNatives()   //私有方法
getClass()    //返回此 Object 的執行類。
hashCode()    //用於獲取物件的雜湊值。
equals(Object obj)     //用於確認兩個物件是否“相同”。
clone()    //建立並返回此物件的一個副本。
toString()   //返回該物件的字串表示。   
notify()    //喚醒在此物件監視器上等待的單個執行緒。   
notifyAll()     //喚醒在此物件監視器上等待的所有執行緒。   
wait(long timeout)    //在其他執行緒呼叫此物件的 notify() 方法或 notifyAll() 方法，或者超過指定的時間量前，導致當前執行緒等待。   
wait(long timeout, int nanos)    //在其他執行緒呼叫此物件的 notify() 方法或 notifyAll() 方法，或者其他某個執行緒中斷當前執行緒，或者已超過某個實際時間量前，導致當前執行緒等待。
wait()    //用於讓當前執行緒失去操作許可權，當前執行緒進入等待序列
finalize()    //當垃圾回收器確定不存在對該物件的更多引用時，由物件的垃圾回收器呼叫此方法。

2、hashcode 和 equals 方法常用地方；物件比較是否相同

hashCode()和equals()定義在Object類中，這個類是所有java類的基類，所以所有的java類都繼承這兩個方法。

hashCode()方法被用來獲取給定物件的唯一整數。這個整數被用來確定物件被儲存在HashTable類似的結構中的位置。預設的，Object類的hashCode()方法返回這個物件儲存的記憶體地址的編號。

1、如果兩個物件相等，那麼他們一定有相同的雜湊值（hash code）。

2、如果兩個物件的雜湊值相等，那麼這兩個物件有可能相等也有可能不相等。（需要再通過equals來判斷）

3、Object toString 方法常用的地方，為什麼要重寫該方法

java提供預設toString方法不友好，打印出來看不懂，重寫是為了程式猿自己能看懂

4、馮諾依曼體系結構

五大部件組成

1.儲存器用來存放資料和程式

2.運算器主要執行算數運算和邏輯運算，並將中間結果暫存到運算器中

3.控制器主要用來控制和指揮程式和資料的輸入執行，以及處理運算結果

4.輸入裝置用來將人們熟悉的資訊形式轉換為機器能夠識別的資訊形式，常見的有鍵盤，滑鼠等

5.輸出裝置可以將機器運算結果轉換為人們熟悉的資訊形式，如印表機輸出，顯示器輸出等

5、反向代理(Springboot,負載均衡)

       從用途上來講：正向代理的典型用途是為在防火牆內的區域網客戶端提供訪問Internet的途徑。正向代理還可以使用緩衝特性減少網路使用率。反向代理的典型用途是將防火牆後面的伺服器提供給Internet使用者訪問。反向代理還可以為後端的多臺伺服器提供負載平衡，或為後端較慢的伺服器提供緩衝服務。另外，反向代理還可以啟用高階URL策略和管理技術，從而使處於不同web伺服器系統的web頁面同時存在於同一個URL空間下。

　　從安全性來講：正向代理允許客戶端通過它訪問任意網站並且隱藏客戶端自身，因此你必須採取安全措施以確保僅為經過授權的客戶端提供服務。反向代理對外都是透明的，訪問者並不知道自己訪問的是一個代理。

　　打個比方，a,b,c三個人，正向代理是a通過b向C借錢，a知道c的存在 。反向代理是a向b借錢，b又向C借，a不知道c的存在。

6、知道java的異常嗎？

整理#直面Java#64-77

7、動態代理，反射

8、自定義註解的場景及實現

待編輯

9、兩個Integer的引用物件傳給一個swap方法在方法內部交換引用，返回後，兩個引用的值是否會發現變化

public class SwapTest {

    private void swapTest(Integer i1,Integer i2){
        Integer tem = i1;
        i1 = i2;
        i2 = tem;

    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Integer i1 = new Integer(1);
        Integer i2 = new Integer(2);
        new SwapTest().swapTest(i1, i2);
        System.out.println(i1 +":" + i2);
    }

}

執行輸出如下：
1:2

分析如下：
//這時候傳入的只是i1,i2的兩個記憶體引用
 new SwapTest().swapTest(i1, i2);

//然後在方法裡i1,i2非呼叫時的i1,i2,再怎麼去互換他的引用，也不影響在呼叫時候的引用。
    private void swapTest(Integer i1,Integer i2){
        Integer tem = i1;
        i1 = i2;
        i2 = tem;
    }


如果交換的是全域性的引用，比如這樣：

public class SwapTest {

    private static Integer i1 = new Integer(1);
    private static Integer i2 = new Integer(2);
    private void swapTest(){
        Integer tem = i1;
        i1 = i2;
        i2 = tem;
    }

    public static void main(String[] args) {
        new SwapTest().swapTest();
        System.out.println(i1 +":" + i2);
    }
 

}

執行輸出結果：
2:1

10、字串的格式化方法 ；時間的格式化方法

String format靜態方法

System.out.println(String.format("hello %s", "world"));//hello world
System.out.println(String.format("hello %c", 'a'));//hello a
System.out.println(String.format("hello %b", false));//hello false
System.out.println(String.format("hello %d", 15));//hello 15
System.out.println(String.format("hello %f", 3.14));//hello 3.140000(注意幫我們算精度了,還是我們自己處理成String型別用%s傳更好)
System.out.println(String.format("合格率 %d%%", 20));//合格率 20%

SimpleDateFormat類，String.format(),Calendar類三種方法

11、類序列化時類的版本號的用途，如果沒有指定一個版本號，系統是怎麼處理的？如果加了欄位會怎麼樣？

整理#直面Java#78-89
12、Override和Overload的區別，分別用在什麼場景

13、定時器用什麼做的

import java.util.Calendar;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;
 
public class TimeTest {
  public static void main(String[] args) {
    timer1();
    //timer2();
    //timer3();
    //timer4();
  }
 
  // 第一種方法：設定指定任務task在指定時間time執行 schedule(TimerTask task, Date time)
  public static void timer1() {
    Timer timer = new Timer();
    timer.schedule(new TimerTask() {
      public void run() {
        System.out.println("-------設定要指定任務--------");
      }
    }, 2000);// 設定指定的時間time,此處為2000毫秒
  }
 
  // 第二種方法：設定指定任務task在指定延遲delay後進行固定延遲peroid的執行
  // schedule(TimerTask task, long delay, long period)
  public static void timer2() {
    Timer timer = new Timer();
    timer.schedule(new TimerTask() {
      public void run() {
        System.out.println("-------設定要指定任務--------");
      }
    }, 1000, 5000);
  }
 
  // 第三種方法：設定指定任務task在指定延遲delay後進行固定頻率peroid的執行。
  // scheduleAtFixedRate(TimerTask task, long delay, long period)
  public static void timer3() {
    Timer timer = new Timer();
    timer.scheduleAtFixedRate(new TimerTask() {
      public void run() {
        System.out.println("-------設定要指定任務--------");
      }
    }, 1000, 2000);
  }
   
  // 第四種方法：安排指定的任務task在指定的時間firstTime開始進行重複的固定速率period執行．
  // Timer.scheduleAtFixedRate(TimerTask task,Date firstTime,long period)
  public static void timer4() {
    Calendar calendar = Calendar.getInstance();
    calendar.set(Calendar.HOUR_OF_DAY, 12); // 控制時
    calendar.set(Calendar.MINUTE, 0);    // 控制分
    calendar.set(Calendar.SECOND, 0);    // 控制秒
 
    Date time = calendar.getTime();     // 得出執行任務的時間,此處為今天的12：00：00
 
    Timer timer = new Timer();
    timer.scheduleAtFixedRate(new TimerTask() {
      public void run() {
        System.out.println("-------設定要指定任務--------");
      }
    }, time, 1000 * 60 * 60 * 24);// 這裡設定將延時每天固定執行
  }
}

14、執行緒如何退出結束

終止執行緒的三種方法
    有三種方法可以使終止執行緒。
    1.  使用退出標誌，使執行緒正常退出，也就是當run方法完成後執行緒終止。
    2.  使用stop方法強行終止執行緒（這個方法不推薦使用，因為stop和suspend、resume一樣，也可能發生不可預料的結果）。
    3.  使用interrupt方法中斷執行緒。 
1. 使用退出標誌終止執行緒
    當run方法執行完後，執行緒就會退出。但有時run方法是永遠不會結束的。如在服務端程式中使用執行緒進行監聽客戶端請求，或是其他的需要迴圈處理的任務。 在這種情況下，一般是將這些任務放在一個迴圈中，如while迴圈。如果想讓迴圈永遠執行下去，可以使用while（true）{……}來處理。但要想使 while迴圈在某一特定條件下退出，最直接的方法就是設一個boolean型別的標誌，並通過設定這個標誌為true或false來控制while迴圈 是否退出。下面給出了一個利用退出標誌終止執行緒的例子。

package chapter2; 

public class ThreadFlag extends Thread 
{ 
    public volatile boolean exit = false; 

    public void run() 
    { 
        while (!exit); 
    } 
    public static void main(String[] args) throws Exception 
    { 
        ThreadFlag thread = new ThreadFlag(); 
        thread.start(); 
        sleep(5000); // 主執行緒延遲5秒 
        thread.exit = true;  // 終止執行緒thread 
        thread.join(); 
        System.out.println("執行緒退出!"); 
    } 
} 

    在上面程式碼中定義了一個退出標誌exit，當exit為true時，while迴圈退出，exit的預設值為false.在定義exit時，使用了一個 Java關鍵字volatile，這個關鍵字的目的是使exit同步，也就是說在同一時刻只能由一個執行緒來修改exit的值，
    2. 使用stop方法終止執行緒
    使用stop方法可以強行終止正在執行或掛起的執行緒。我們可以使用如下的程式碼來終止執行緒：
thread.stop();
    雖然使用上面的程式碼可以終止執行緒，但使用stop方法是很危險的，就象突然關閉計算機電源，而不是按正常程式關機一樣，可能會產生不可預料的結果，因此，並不推薦使用stop方法來終止執行緒。
    3. 使用interrupt方法終止執行緒
    使用interrupt方法來終端執行緒可分為兩種情況：
    （1）執行緒處於阻塞狀態，如使用了sleep方法。
    （2）使用while（！isInterrupted（））{……}來判斷執行緒是否被中斷。
    在第一種情況下使用interrupt方法，sleep方法將丟擲一個InterruptedException例外，而在第二種情況下執行緒將直接退出。下面的程式碼演示了在第一種情況下使用interrupt方法。

package chapter2; 

public class ThreadInterrupt extends Thread 
{ 
    public void run() 
    { 
        try 
        { 
            sleep(50000);  // 延遲50秒 
        } 
        catch (InterruptedException e) 
        { 
            System.out.println(e.getMessage()); 
        } 
    } 
    public static void main(String[] args) throws Exception 
    { 
        Thread thread = new ThreadInterrupt(); 
        thread.start(); 
        System.out.println("在50秒之內按任意鍵中斷執行緒!"); 
        System.in.read(); 
        thread.interrupt(); 
        thread.join(); 
        System.out.println("執行緒已經退出!"); 
    } 
} 

    上面程式碼的執行結果如下：
    在50秒之內按任意鍵中斷執行緒!
    sleep interrupted 
    執行緒已經退出!
    在呼叫interrupt方法後， sleep方法丟擲異常，然後輸出錯誤資訊：sleep interrupted.
    注意：在Thread類中有兩個方法可以判斷執行緒是否通過interrupt方法被終止。一個是靜態的方法interrupted（），一個是非靜態的方 法isInterrupted（），這兩個方法的區別是interrupted用來判斷當前線是否被中斷，而isInterrupted可以用來判斷其他 執行緒是否被中斷。因此，while （！isInterrupted（））也可以換成while （！Thread.interrupted（））。

注意：當執行緒處於寫檔案的狀態時，呼叫interrupt()不會中斷執行緒

處於大資料IO讀寫中的執行緒實際上處於執行狀態，而不是等待或阻塞狀態，因此上面的interrupt機制不適用。執行緒處於IO讀寫中可以看成是執行緒執行中的一種特例。停止這樣的執行緒的辦法是強行close掉io輸入輸出流物件，使其丟擲異常，進而使執行緒停止。

        最好的建議是將大資料的IO讀寫操作放在迴圈中進行，這樣可以在每次迴圈中都有執行緒停止的時機，這也就將問題轉化為如何停止正在執行中的執行緒的問題了。
15、物件的深淺複製

16、設計模式

設計模式可以分為建立型模式、結構型模式和行為型模式。

建立型設計模式：對物件建立過程得各種問題解決方案，工廠模式，單例模式，構建器模式，原型模式

結構型模式：針對軟體設計結構的總結，關注類，物件繼承，組合方式的實踐經驗；橋接模式，介面卡模式，裝飾者模式，代理模式，組合模式，外觀模式，享元模式等

行為型模式：從類或物件之間互動，職責劃分等角度總結；策略模式，直譯器模式，命令模式，觀察者模式，迭代器模式，模板方法模式，訪問者模式。

IO框架：典型的裝飾者模式；

HttpRequest:：構建器模式；方法鏈；

Spring中設計模式：

BeanFactory和ApplicationContest應用了工廠模式。

Bean建立中，Spring也為不同scope定義的物件，提供了單例和原型等模式實現；

AOP方面使用了代理，裝飾器，介面卡模式等；

各種事件監聽器，應用觀察者模式；

JDBCTemplate等則用了模板模式。