💂 個人主頁: Java程式魚

💬 如果文章對你有幫助，歡迎關注、點贊、收藏(一鍵三連)和訂閱專欄

👤 微信號：hzy1014211086，想加入技術交流群的小伙伴可以加我好友，群里會分享學習資料、學習方法

一、第一個Java程式

public class HelloWorld {
    public static void main(String[] args) {
    	System.out.println("hello world");
    }
}

我給大家介紹下上述代碼：

• class：這是一個關鍵字，用于在Java中宣告一個類，
• public：這是一個關鍵字，表示公開的訪問修飾符，這意味著它對所有人可見，
• static：這是是一個關鍵字，如果我們將任何方法宣告為靜態方法，則稱為靜態方法，靜態方法的核心優點是，不需要創建物件來呼叫靜態方法，main方法由JVM執行，因此不需要創建物件來呼叫main方法，這樣可以節省記憶體，
• void：是方法的回傳型別，意味著它不回傳任何值，
• main：代表程式的起點，
• String[] args：用于命令列引數，我們稍后會學習，
• System.out.println()：用于列印輸出的陳述句，System是一個類，out是PrintStream類的物件，println() 是PrintStream類的方法，

二、八種基本資料型別

Java 中有 8 種基本資料型別，分別為：
4 種「 整數 」型別：byte、short、int、long
2 種「 浮點 」型別 ：float、double
1 種「 字符 」型別：char
1 種「 布爾 」型：boolean

這 8 種基本資料型別的默認值以及所占空間的大小如下：

boolean 只有兩個值：true、false，可以使用 1 bit 來存盤，但是官方未明確定義，它依賴于 JVM 廠商的具體實作，

三、包裝型別

每個基本型別都有對應的包裝型別，基本型別與其對應的包裝型別之間的賦值使用自動裝箱與拆箱完成，

Integer x = 100;     // 裝箱 呼叫了 Integer.valueOf(100)
int y = x;         // 拆箱 呼叫了 x.intValue()

裝箱：將基本型別用它們對應的參考型別包裝起來；
拆箱：將包裝型別轉換為基本資料型別；

Integer x = 100 等價于 Integer x = Integer.valueOf(100);
int y = x 等價于 int y = x.intValue();

四、快取池

Java 基本型別的包裝類的大部分都實作了常量池技術，Byte、Short、Integer、Long 這 4 種包裝類默認創建了數值 [-128，127] 的相應型別的快取資料，Character 創建了數值在[0,127]范圍的快取資料，Boolean 直接回傳 True Or False，

Integer 快取原始碼：

/**
 * 此方法將始終快取-128 到 127（包括端點）范圍內的值，并可以快取此范圍之外的其他值，
 * @param i
 * @return
 */
public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];
} 

public static void main(String[] args) {
	Integer i1 = 100;
	Integer i2 = 100;
	System.out.println(i1 == i2); // 輸出 true
	
	Integer y1 = 128;
	Integer y2 = 128;
	System.out.println(y1 == y2); // 輸出 false
}

如果超出對應范圍仍然會去創建新的物件，快取的范圍區間的大小只是在性能和資源之間的權衡，

public static void main(String[] args) {
	Float i1 = 1f;
	Float i2 = 1f;
	System.out.println(i1 == i2);// 輸出 false

	Double y1 = 1.2;
	Double y2 = 1.2;
	System.out.println(y1 == y2);// 輸出 false
}

兩種浮點數型別的包裝類 Float、Double 「 并沒有實作常量池技術 」，

public static void main(String[] args) {
	Integer i1 = 100;
	Integer i2 = new Integer(100);
	System.out.println(i1 == i2); // false
}

new Integer(100) 與 Integer.valueOf(100) 的區別在于：

• new Integer(100) 「 每次都會新建一個物件 」，
• Integer.valueOf(100) 會使用快取池中的物件，「 多次呼叫會取得同一個物件的參考 」，

五、String

字串就是一系列字符，在Java中，字串可以包含任意 Unicode 字符，例如，字串Java?或字串Java\u2122 是由5個Unicode字符J、a、v、a和?組成的，最后一個字符是"U+211商標"，

public static void main(String[] args) {
    System.out.println("Java\u2122");
}

列印結果：Java?

在 Java 8 中，String 內部使用 char 陣列存盤資料，

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];
}

在 Java 9 之后，String 類的實作改用 byte 陣列存盤字串，同時使用 coder 來標識使用了哪種編碼，

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final byte[] value;

    /** The identifier of the encoding used to encode the bytes in {@code value}. */
    private final byte coder;
}

value 陣列被宣告為 final，這意味著 value 陣列初始化之后就不能再參考其它陣列，并且 String 內部沒有改變 value 陣列的方法，「 因此可以保證 String 不可變 」，

1.常用API

這塊大家可以自行上官網查看，然后自己動手寫一寫，這塊比較簡單，

Java官網 String：https://docs.oracle.com/javase/8/docs/api/java/lang/String.html

2.字串池（String Pool）

在作業中，String類是我們使用頻率非常高的一種物件型別，JVM為了提升性能和減少記憶體開銷，避免字串的重復創建，其維護了一塊特殊的記憶體空間，即字串池（String Pool），字串池由 String 類私有的維護，

我們知道，在Java中有兩種創建字串物件的方式：

• 采用字面值的方式賦值
• 采用new關鍵字新建一個字串物件，

這兩種方式在性能和記憶體占用方面存在著差別，

public static void main(String[] args) {
	String str1 = "abc";
	String str2 = "abc";
	System.out.println(str1 == str2); // true
}

采用字面值的方式創建一個字串時， 「 首先會去字串池中查找是否存在"abc"這個物件 」，如果不存在，則在字串池中創建"abc"這個物件，然后將池中"abc"這個物件的參考地址回傳給字串常量str，這樣str會指向池中"abc"這個字串物件；如果存在，則不創建任何物件，直接將池中"abc"這個物件的地址回傳，賦給字串常量，因此，上面案例中，str1==str2 得到的結果是 true，

public static void main(String[] args) {
	String str3 = new String("abc");
	String str4 = new String("abc");
	System.out.println(str3 == str4); // false
}

采用new關鍵字新建一個字串物件時，JVM首先在字串池中查找有沒有"abc"這個字串物件，如果有，則不在池中再去創建"abc"這個物件了，直接在堆中創建一個"abc"字串物件，然后將堆中的這個"abc"物件的地址回傳賦給參考str3，這樣，str3就指向了堆中創建的這個"abc"字串物件；如果沒有，則首先在字串池中創建一個"abc"字串物件，然后再在堆中創建一個"abc"字串物件，然后將堆中這個"abc"字串物件的地址回傳賦給str3參考，這樣，str3指向了堆中創建的這個"abc"字串物件，因此，上面案例中，str3==str4 得到的結果是 false，

字串池的實作有一個前提條件：「 String物件是不可變的 」，因為這樣可以保證多個參考可以同事指向字串池中的同一個物件，如果字串是可變的，那么一個參考操作改變了物件的值，對其他參考會有影響，這樣顯然是不合理的，

3.字串拼接操作

@Test
public void test2(){
    String s1 = "javaEE";
    String s2 = "hadoop";

    String s3 = "javaEEhadoop";
    String s4 = "javaEE" + "hadoop";//編譯期優化（在編譯時得到的結果，s4會指向字串常量池）
    //如果拼接符號的前后出現了變數，則相當于在堆空間中new String()，具體的內容為拼接的結果：javaEEhadoop（在運行時得到的結果）
    String s5 = s1 + "hadoop";
    String s6 = "javaEE" + s2;
    String s7 = s1 + s2;

    System.out.println(s3 == s4);//true
    System.out.println(s3 == s5);//false
    System.out.println(s3 == s6);//false
    System.out.println(s3 == s7);//false
    System.out.println(s5 == s6);//false
    System.out.println(s5 == s7);//false
    System.out.println(s6 == s7);//false
    
    //intern():判斷字串常量池中是否存在javaEEhadoop值，如果存在，則回傳常量池中javaEEhadoop的地址；
    //如果字串常量池中不存在javaEEhadoop，則在常量池中加載一份javaEEhadoop，并回傳次物件的地址，
    String s8 = s6.intern();
    System.out.println(s3 == s8);//true
    final String s9 = "a";
    final String s10 = "b";
    String s11 = "ab";
    String s12 = s9 + s10;
    System.out.println(s11 == s12);//true
}

• 常量與常量的拼接結果在常量池，原理是編譯期優化
• 拼接程序中，只要其中有一個是變數，結果就在堆中（相當于在堆空間中new String），變數拼接的原理是StringBuilder
• intern()：判斷字串常量池中是否存在javaEEhadoop這個值，如果存在，則回傳常量池中地址，如果不存在，則在常量池中加載一份并回傳地址
• 如果拼接符左右兩邊都是字串常量或常量參考，則仍然使用編譯期優化

這部分內容可能比較難理解，如果有小伙伴理解不了，可以先記錄下來，跳過去學習其他的內容，等你有一定的代碼量積累了，在反過頭來看就簡單了，

4.拼接操作與append操作的效率對比

public void test1(int highLevel){
    String src = "";
    for (int i = 0; i < highLevel; i++) {
        src = src + "a";
    }
}

public void test2(int highLevel){
    StringBuilder src = new StringBuilder();
    for (int i = 0; i < highLevel; i++) {
        src.append("a");
    }
}

通過StringBuilder的append()的方式添加字串的效率要遠高于使用String的字串拼接方式，

• StringBuilder的append方式，自始至終只創建一個StringBuilder的物件，使用String的字串拼接方式會創建多個StringBuilder物件和String物件
• 使用 String 的字串拼接方式會創建多個 StringBuilder 物件和 String 物件，記憶體占用更大，如果進行GC，需要花費額外的時間

改進空間：如果基本確定長度，建議使用構造器指定StringBuilder底層陣列的長度，避免多次擴容消耗

這部分內容可能比較難理解，如果有小伙伴理解不了，可以先記錄下來，跳過去學習其他的內容，等你有一定的代碼量積累了，在反過頭來看就簡單了，

5.為什么 String 在 Java 中是不可變的？

• 提供程式運行效率，只有字串是不可變時，我們才能實作JVM中的字串常量池，字串常量池可以為我們快取字串，提供程式運行效率
• 安全，比如在核心業務操作之前，可能會有一系列校驗，校驗String字串的合法性，如果是可變的話，在校驗過后，它的內部值又被改變了，這可能會引發一系列問題，這是迫使String類設計成不可變的一個重要原因，
• 快取hashCode，字串的 hashCode 在 Java 中經常使用，例如，在 HashMap 或 HashSet 中，不可變保證了 hashcode 始終相同，這意味著只需要計算一次hashCode就行了，這樣效率更高，
• 執行緒安全，String 不可變性天生具備執行緒安全，可以在多個執行緒中安全地使用，

6.String、StringBuffer、StringBuilder的區別

String、StringBuffer、StringBuilder 三個都可以存盤字串，其中String只讀字串，它的值不可改變長度也是固定的，而StringBuffer、StringBuilder類表示的字串可以直接進行修改，StringBuilder是JDK1.5中引入的，他和StringBuffer的方法完全相同，區別在于StringBuilder是單執行緒環境下使用的，因為它的所有方法都沒有被synchronized修飾，因此它的效率比StringBuffer高，

五、變數

變數是在執行Java程式時保存值的容器，變數分配有資料型別，

變數是記憶體位置的名稱，Java中存在三種型別的變數：區域變數，實體變數和靜態變數，

1.區域變數

• 區域變數宣告在方法、構造方法或者陳述句塊中
• 區域變數在「 方法、構造方法、或者陳述句塊被執行的時候創建」，當它們執行完成后，變數將會被銷毀
• 區域變數只在宣告它的方法、構造方法或者陳述句塊中可見
• 區域變數沒有默認值，所以區域變數被宣告后，必須經過初始化，才可以使用
• 區域變數不能用「 static 」關鍵字定義

2.實體變數

在類內部但在方法主體外部宣告的變數稱為「 實體變數 」，它沒有宣告為static，

• 實體變數宣告在一個類中，但在方法、構造方法和陳述句塊之外
• 實體變數在「 物件創建的時候創建 」，在物件被銷毀的時候銷毀
• 實體變數對于類中的方法、構造方法或者陳述句塊是可見的，一般情況下應該把實體變數設為私有，通過使用訪問修飾符可以使實體變數對子類可見
• 實體變數具有默認值

3.靜態變數

• 類變數也稱為靜態變數，在類中以static關鍵字宣告，但必須在方法構造方法和陳述句塊之外
• 無論一個類創建了多少個物件，類只擁有類變數的一份拷貝
• 靜態變數在「 第一次被訪問時創建 」，在程式結束時銷毀
• 與實體變數具有相似的可見性，但為了對類的使用者可見，大多數靜態變數宣告為public型別
• 靜態變數具有默認值

靜態變數和實體變數的區別：

• 呼叫方式
  • 可以直接通過類名呼叫，也可以通過物件實體呼叫，這個變數屬于類，（new Student().name、Student.name）
  • 只能通過物件實體呼叫，這個變數屬于物件，（new Student().name）
• 生命周期
  • 靜態變數隨著類的加載而存在，隨著類的消失而消失，生命周期長，
  • 實體變數隨著物件的創建而存在，隨著物件的消失而消失，
• 與物件的相關性
  • 靜態變數是所有物件共享一份資料，
  • 實體變數是每個物件獨享一份資料，

public class HelloWorld {
	int x = 50;	// 實體變數
	static int y = 100;	// 靜態變數

	void method() {
		int z = 90;	// 區域變數
	}
}

五、運算子

1.賦值運算子

賦值運算子（=）用于為變數賦值

int count = 1;

2.算術運算子

public static void main(String[] args) {
	int x = 1 + 2;
	int y = 2 - 1;
	int z = 2 * 1;
	int i = 4 / 2;
	int t = 9 % 3; // 結果是0，取余
	int k = -i; // 結果是-2，取反運算
	
	// ++和--運算子可以放在變數之前，也可以放在變數之后，當運算子放在變數之前時(前綴)，先自增/減，再賦值；當運算子放在變數之后時(后綴)，先賦值，再自增/減，
	int q = 0;
	System.out.println(q++); // 0
	int w = 0;
	System.out.println(++w); // 1
}

3.關系運算子

4.邏輯運算子

• && 與 & 區別：&和&&都可以用作邏輯與的運算子，表示邏輯與（and），當運算子兩邊的運算式的結果都為true時，整個運算結果才為true，否則，只要有一方為false，則結果為false，&&還具有短路的功能，即如果第一個運算式為false，則不再計算第二個運算式
• || 與 | 區別：短路或與短路與同理，

5.位運算子

A = 0011 1100
B = 0000 1101
--------------
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011

下表列出了位運算子的基本運算，假設整數變數 A 的值為 60 和變數 B 的值為 13：

public class Test {
  public static void main(String[] args) {
     int a = 60; /* 60 = 0011 1100 */ 
     int b = 13; /* 13 = 0000 1101 */
     int c = 0;
     c = a & b;       /* 12 = 0000 1100 */
     System.out.println("a & b = " + c );
 
     c = a | b;       /* 61 = 0011 1101 */
     System.out.println("a | b = " + c );
 
     c = a ^ b;       /* 49 = 0011 0001 */
     System.out.println("a ^ b = " + c );
 
     c = ~a;          /*-61 = 1100 0011 */
     System.out.println("~a = " + c );
  }
} 

6.位移運算子

（1）<<

左移位運算子為 << ，其運算規則是：按二進制形式把所有的數字向左移動對應的位數，高位移出（舍棄），低位的空位補零，

例如，將整數 11 向左位移 1 位的程序如下圖所示，

從上圖可以看到，原來數的所有二進制位都向左移動 1 位，原來位于左邊的最高位 0 被移出舍棄，再向尾部追加 0 補位，最終到的結果是 22，相當于原來數的 2 倍，

（2）>>

右位移運算子為 >> ，其運算規則是：按二進制形式把所有的數字向右移動對應的位數，低位移出（舍棄），高位的空位補零，

例如，將整數 11 向右位移 1 位的程序如下圖所示，

從上圖可以看到，原來數的所有二進制位都向右移動 1 位，原來位于右邊的最低位 1 被移出舍棄，再向最高位追加 0 補位，最終到的結果是 5，相當于原數整除 2 的結果，

（3）>>>

無符號右移運算子

無符號右移運算子和右移運算子是一樣的，不過無符號右移運算子在右移的時候是補0的，而右移運算子是補符號位的，

7.三元運算子

條件運算子也被稱為三元運算子，該運算子有3個運算元，并且需要判斷布爾運算式的值，該運算子的主要是決定哪個值應該賦值給變數，

variable x = (expression) ? value if true : value if false

public class Test {
   public static void main(String[] args){
      int a , b;
      a = 10;
      // 如果 a 等于 1 成立，則設定 b 為 20，否則為 30
      b = (a == 1) ? 20 : 30;
      System.out.println( "Value of b is : " +  b );
 
      // 如果 a 等于 10 成立，則設定 b 為 20，否則為 30
      b = (a == 10) ? 20 : 30;
      System.out.println( "Value of b is : " + b );
   }
}

六、條件陳述句

一個 if 陳述句包含一個布爾運算式和一潭訓多條陳述句，

1.if

if(布爾運算式)
{
   //如果布爾運算式為true將執行的陳述句
}

2.if…else

if 陳述句后面可以跟 else 陳述句，當 if 陳述句的布爾運算式值為 false 時，else 陳述句塊會被執行，

if(布爾運算式){
   //如果布爾運算式的值為true
}else{
   //如果布爾運算式的值為false
}

3.if…else if…else

if(布爾運算式 1){
   //如果布爾運算式 1的值為true執行代碼
}else if(布爾運算式 2){
   //如果布爾運算式 2的值為true執行代碼
}else if(布爾運算式 3){
   //如果布爾運算式 3的值為true執行代碼
}else {
   //如果以上布爾運算式都不為true執行代碼
}

4.嵌套的 if…else

if(布爾運算式 1){
	  如果布爾運算式 1的值為true執行代碼
   if(布爾運算式 2){
      如果布爾運算式 2的值為true執行代碼
   }else{
	  如果布爾運算式 2的值為false執行代碼
   }
}

八、switch case

switch case 陳述句判斷一個變數與一系列值中某個值是否相等，每個值稱為一個分支，

switch(運算式){
    case 值1 :
       //陳述句塊1
       break; //可選
    case 值2 :
       //陳述句塊2
       break; //可選
    //你可以有任意數量的case陳述句
    default : //可選
       //陳述句
}

switch case 陳述句有如下規則：

• switch運算式，運算式的值必須為 byte、short、int 或者 char，從 Java SE 7 開始，switch 支持字串 String 型別了，同時 case 標簽必須為字串常量或字面量，
• switch 陳述句可以擁有多個 case 陳述句，每個 case 后面跟一個要比較的值和冒號，
• case的值資料型別必須與運算式的值的資料型別相同，而且只能是常量或者字面常量；case值必須唯一，如果值重復，則會產生編譯時錯誤，
• 當變數的值與 case 陳述句的值相等時，那么 case 陳述句之后的陳述句開始執行，直到 break 陳述句出現才會跳出 switch 陳述句，
• 當遇到 break 陳述句時，switch 陳述句終止，程式跳轉到 switch 陳述句后面的陳述句執行，case 陳述句不必須要包含 break 陳述句，如果沒有 break 陳述句出現，程式會繼續執行下一條 case 陳述句，直到出現 break 陳述句，
• switch 陳述句可以包含一個 default 分支，該分支一般是 switch 陳述句的最后一個分支（可以在任何位置，但建議在最后一個），default 在沒有 case 陳述句的值和變數值相等的時候執行，default 分支不需要 break 陳述句，

switch case 執行時，一定會先進行匹配，匹配成功回傳當前 case 的值，再根據是否有 break，判斷是否繼續輸出，或是跳出判斷，

public class Test {
	public static void main(String[] args) {
		int score = 90;
		switch (score) {
		case 10:
			System.out.println("學神");
			break;
		case 9:
			System.out.println("成績為A");
			break;
		case 8:
			System.out.println("成績為B");
			break;
		case 7:
			System.out.println("成績為C");
			break;
		case 6:
			System.out.println("成績為D");
			break;
		default:
			System.out.println("成績為E");
			break;
		}
	}
}

九、回圈

在Java語言中，回圈用于重復執行一組指令/功能，Java中有三種主要的回圈結構：

• for回圈
• while回圈
• do-while回圈

1.while回圈

// 列印1-10
public class Test {
	public static void main(String[] args) {
		int i = 1;
		// 只要布爾運算式(i<=10)為true，回圈就會一直執行下去，
		while (i <= 10) {
			System.out.println(i++);
		}
	}
}

2.do…while 回圈

對于 while 陳述句而言，如果不滿足條件，則不能進入回圈，但有時候我們需要即使不滿足條件，也至少執行一次，

do…while 回圈和 while 回圈相似，不同的是，do…while 回圈至少會執行一次，

public class Test {
	public static void main(String[] args) {
		int i = 1;
		do {
			System.out.println(i++);
		} while (i < 0);
	}
}

布爾運算式在回圈體的后面，所以陳述句塊在檢測布爾運算式之前已經執行了， 如果布爾運算式的值為 true，則陳述句塊一直執行，直到布爾運算式的值為 false，

3.for 回圈

for(初始化; 布爾運算式; 更新) {
    //代碼陳述句
}

關于 for 回圈有以下幾點說明：

• 最先執行初始化步驟，可以宣告一種型別，但可初始化一個或多個回圈控制變數，也可以是空陳述句，
• 然后，檢測布爾運算式的值，如果為 true，回圈體被執行，如果為false，回圈終止，開始執行回圈體后面的陳述句，
• 執行一次回圈后，更新回圈控制變數，
• 再次檢測布爾運算式，回圈執行上面的程序，

// 列印1-10
public class Test {
	public static void main(String args[]) {
		for (int i = 1; i <= 10; i++) {
			System.out.println(i);
		}
	}
}

Java5 引入了一種主要用于陣列的增強型 for 回圈，

for(宣告陳述句 : 運算式)
{
   //代碼句子
}

宣告陳述句：宣告新的區域變數，該變數的型別必須和陣列元素的型別匹配，其作用域限定在回圈陳述句塊，其值與此時陣列元素的值相等，

運算式：運算式是要訪問的陣列名，或者是回傳值為陣列的方法，

public class Test {
	public static void main(String args[]) {
		int[] numbers = { 10, 20, 30, 40, 50 };
		for (int number : numbers) {
			System.out.println(number);
		}
	}
}

4.break 關鍵字

break 主要用在回圈陳述句或者 switch 陳述句中，用來跳出整個陳述句塊，

break 跳出最里層的回圈，并且繼續執行該回圈下面的陳述句，

public class Test {
	public static void main(String args[]) {
		for (int i = 1; i <= 10; i++) {
			System.out.println(i);
			// 執行到i==5就停止
			if(i == 5){
				break;
			}
		}
	}
}

如果有兩層for回圈，我們想讓最外層的for停止怎么辦？

方案一：

public static void main(String args[]) {
	outCycle: for (int i = 0; i < 10; i++) {
		for (int j = 0; j < 10; j++) {
			if (j == i) {
				break outCycle;
			}
		}
	}
}

方案二：

public static void main(String args[]) {
	boolean outCycle = true;
	boolean innerCycel = true;

	for (int i = 0; i < 10 && outCycle; i++) {
		for (int j = 0; j < 10 && innerCycel; j++) {
			if (j == i) {
				outCycle = false;
			}
		}
	}
}

想要停止內層的for回圈，我們可以直接break或者把 innerCycel=false，停止外層的for回圈只需要把outCycle=false;

5.continue

continue 適用于任何回圈控制結構中，作用是讓程式立刻跳轉到下一次回圈的迭代，

在 for 回圈中，continue 陳述句使程式立即跳轉到更新陳述句，

在 while 或者 do…while 回圈中，程式立即跳轉到布爾運算式的判斷陳述句，

// 列印1-10
public class Test {
	public static void main(String args[]) {
		for (int i = 1; i <= 10; i++) {
			System.out.println(i);
			// 跳過i等于5的列印，其他的數字正常列印
			if(i == 5){
				break;
			}
		}
	}
}

?? 彩蛋

「粉絲福利、三連送書 」

「 粉絲專屬福利（包郵送書2本，書單里5本書可任選一本） 」

「 抽獎方式：截止到10月10日 14:00，留言獲贊最高的兩位同學，將獲得圖書一本，上述5本書可以任選一本 」

Spring Boot 企業級應用開發實戰 - 京東圖書

Spring Boot 企業級應用開發實戰 - 當當圖書

作者：柳偉衛（英文名Way Lau），關注編程、系統架構、性能優化，在大型IT公司擔任過專案經理、架構師、高級開發顧問等職位，具有多年軟體開發管理及系統架構經驗，負責過多個大型分布式系統的設計與研發，參與了多個大型專案的微服務架構的技術改造，在實際作業中積累了大量的微服務架構經驗，

亮點：

• 「 新 」，本書基于新的Spring Boot 2.0版本撰寫，深入淺出地講解了Spring與Spring Boot，
• 「 實戰 」，跳脫純理論講述，案例貫穿全書，一步步講述使用Spring Boot開發企業系統的方法，讀者不僅能全面學到軟體開發技能，還能學到專案實戰經驗，
• 「 全 」，彌補市面上有關 Spring Boot 學習資料的不足，重新撰寫整個教學案例，使讀者輕松脫離“Hello World”階段，向Spring Boot企業級快速應用開發躍遷，

「 沒中的小伙伴可以等下期，或者自行購買哈 」

Spring Boot 企業級應用開發實戰 - 京東圖書

Spring Boot 企業級應用開發實戰 - 當當圖書

億級流量Java高并發與網路編程實戰 - 京東圖書

億級流量Java高并發與網路編程實戰 - 當當圖書

Java高并發編程指南 - 京東圖書

Java高并發編程指南 - 當當圖書

Java核心技術及面試指南 - 京東圖書

Java核心技術及面試指南 - 當當圖書

Spring Cloud 微服務架構開發實戰 - 京東圖書

Spring Cloud 微服務架構開發實戰 - 當當圖書

參考文獻：
《Java核心技術卷I》
《Oracle Java tutorial》：https://docs.oracle.com/javase/tutorial/java/index.html

因為篇幅問題，面向物件、例外、反射、IO、集合等內容下篇文章發，大家可以持續關注，