轉載自https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/basis/Java%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86.md#1121-jvm

Java 基本功

• 1.1. Java 入門（基礎概念與常識）
• • 1.1.1. Java 語言有哪些特點?
  • 1.1.2. 關于 JVM JDK 和 JRE 最詳細通俗的解答
  • • 1.1.2.1. JVM
    • 1.1.2.2. JDK 和 JRE
  • 1.1.3. Oracle JDK 和 OpenJDK 的對比
  • 1.1.4. Java 和 C++的區別?
  • 1.1.5. 什么是 Java 程序的主類 應用程序和小程序的主類有何不同?
  • 1.1.6. import java 和 javax 有什么區別？
  • 1.1.7. 為什么說 Java 語言“編譯與解釋并存”？
• 1.2. Java 語法
• • 1.2.1. 字符型常量和字符串常量的區別?
  • 1.2.2. 關于注釋？
  • 1.2.3. 標識符和關鍵字的區別是什么？
  • 1.2.4. Java中有哪些常見的關鍵字？
  • 1.2.5. 自增自減運算符
  • 1.2.6. continue、break、和return的區別是什么？
  • 1.2.7. Java泛型了解么？什么是類型擦除？介紹一下常用的通配符？
  • 1.2.8. ==和equals的區別
  • 1.2.9. hashCode()與 equals()
  • • 1)hashCode()介紹:
    • 2)為什么要有 hashCode？
    • 3)為什么重寫 equals 時必須重寫 hashCode 方法？
    • 4)為什么兩個對象有相同的 hashcode 值，它們也不一定是相等的？
• 1.3. 基本數據類型
• • 1.3.1. Java中的幾種基本數據類型是什么？對應的包裝類型是什么？各自占用多少字節呢？
  • 1.3.2. 自動裝箱與拆箱
  • 1.3.3. 8種基本類型的包裝類和常量池
• 1.4. 方法（函數）
• • 1.4.1. 什么是方法的返回值?返回值在類的方法里的作用是什么?
  • 1.4.2. 為什么 Java 中只有值傳遞？
  • 1.4.3. 重載和重寫的區別
  • 1.4.4. 深拷貝 vs 淺拷貝
  • 1.4.5. 方法的四種類型

1.1. Java 入門（基礎概念與常識）

1.1.1. Java 語言有哪些特點?

簡單易學；

面向對象（封裝，繼承，多態）；

平臺無關性（ Java 虛擬機實現平臺無關性）；

可靠性；

安全性；

支持多線程（ C++ 語言沒有內置的多線程機制，因此必須調用操作系統的多線程功能來進行多線程程序設計，而 Java 語言卻提供了多線程支持）；

支持網絡編程并且很方便（ Java 語言誕生本身就是為簡化網絡編程設計的，因此 Java 語言不僅支持網絡編程而且很方便）；

編譯與解釋并存；
修正（參見： issue#544）：C++11 開始（2011 年的時候）,C++就引入了多線程庫，在 windows、linux、macos 都可以使用std::thread和std::async來創建線程。

參考鏈接：http://www.cplusplus.com/reference/thread/thread/?kw=thread

1.1.2. 關于 JVM JDK 和 JRE 最詳細通俗的解答

1.1.2.1. JVM

Java 虛擬機（JVM）是運行 Java 字節碼的虛擬機。JVM 有針對不同系統的特定實現（Windows，Linux，macOS），目的是使用相同的字節碼，它們都會給出相同的結果。

什么是字節碼?采用字節碼的好處是什么?

在 Java 中，JVM 可以理解的代碼就叫做字節碼（即擴展名為 .class 的文件），它不面向任何特定的處理器，只面向虛擬機。Java 語言通過字節碼的方式，在一定程度上解決了傳統解釋型語言執行效率低的問題，同時又保留了解釋型語言可移植的特點。所以 Java 程序運行時比較高效，而且，由于字節碼并不針對一種特定的機器，因此，Java 程序無須重新編譯便可在多種不同操作系統的計算機上運行。

Java 程序從源代碼到運行一般有下面 3 步：

Java程序運行過程

我們需要格外注意的是 .class->機器碼 這一步。在這一步 JVM 類加載器首先加載字節碼文件，然后通過解釋器逐行解釋執行，這種方式的執行速度會相對比較慢。而且，有些方法和代碼塊是經常需要被調用的(也就是所謂的熱點代碼)，所以后面引進了 JIT 編譯器，而 JIT 屬于運行時編譯。當 JIT 編譯器完成第一次編譯后，其會將字節碼對應的機器碼保存下來，下次可以直接使用。而我們知道，機器碼的運行效率肯定是高于 Java 解釋器的。這也解釋了我們為什么經常會說 Java 是編譯與解釋共存的語言。

HotSpot 采用了惰性評估(Lazy Evaluation)的做法，根據二八定律，消耗大部分系統資源的只有那一小部分的代碼（熱點代碼），而這也就是 JIT 所需要編譯的部分。JVM 會根據代碼每次被執行的情況收集信息并相應地做出一些優化，因此執行的次數越多，它的速度就越快。JDK 9 引入了一種新的編譯模式 AOT(Ahead of Time Compilation)，它是直接將字節碼編譯成機器碼，這樣就避免了 JIT 預熱等各方面的開銷。JDK 支持分層編譯和 AOT 協作使用。但是 ，AOT 編譯器的編譯質量是肯定比不上 JIT 編譯器的。

總結：

Java 虛擬機（JVM）是運行 Java 字節碼的虛擬機。JVM 有針對不同系統的特定實現（Windows，Linux，macOS），目的是使用相同的字節碼，它們都會給出相同的結果。字節碼和不同系統的 JVM 實現是 Java 語言“一次編譯，隨處可以運行”的關鍵所在。

1.1.2.2. JDK 和 JRE

JDK 是 Java Development Kit 縮寫，它是功能齊全的 Java SDK。它擁有 JRE 所擁有的一切，還有編譯器（javac）和工具（如 javadoc 和 jdb）。它能夠創建和編譯程序。

JRE 是 Java 運行時環境。它是運行已編譯 Java 程序所需的所有內容的集合，包括 Java 虛擬機（JVM），Java 類庫，java 命令和其他的一些基礎構件。但是，它不能用于創建新程序。

如果你只是為了運行一下 Java 程序的話，那么你只需要安裝 JRE 就可以了。如果你需要進行一些 Java 編程方面的工作，那么你就需要安裝 JDK 了。但是，這不是絕對的。有時，即使您不打算在計算機上進行任何 Java 開發，仍然需要安裝 JDK。例如，如果要使用 JSP 部署 Web 應用程序，那么從技術上講，您只是在應用程序服務器中運行 Java 程序。那你為什么需要 JDK 呢？因為應用程序服務器會將 JSP 轉換為 Java servlet，并且需要使用 JDK 來編譯 servlet。

1.1.3. Oracle JDK 和 OpenJDK 的對比

可能在看這個問題之前很多人和我一樣并沒有接觸和使用過 OpenJDK 。那么 Oracle 和 OpenJDK 之間是否存在重大差異？下面我通過收集到的一些資料，為你解答這個被很多人忽視的問題。

對于 Java 7，沒什么關鍵的地方。OpenJDK 項目主要基于 Sun 捐贈的 HotSpot 源代碼。此外，OpenJDK 被選為 Java 7 的參考實現，由 Oracle 工程師維護。關于 JVM，JDK，JRE 和 OpenJDK 之間的區別，Oracle 博客帖子在 2012 年有一個更詳細的答案：

問：OpenJDK 存儲庫中的源代碼與用于構建 Oracle JDK 的代碼之間有什么區別？

答：非常接近 - 我們的 Oracle JDK 版本構建過程基于 OpenJDK 7 構建，只添加了幾個部分，例如部署代碼，其中包括 Oracle 的 Java 插件和 Java WebStart 的實現，以及一些封閉的源代碼派對組件，如圖形光柵化器，一些開源的第三方組件，如 Rhino，以及一些零碎的東西，如附加文檔或第三方字體。展望未來，我們的目的是開源 Oracle JDK 的所有部分，除了我們考慮商業功能的部分。

總結：

1.Oracle JDK 大概每 6 個月發一次主要版本，而 OpenJDK 版本大概每三個月發布一次。但這不是固定的，我覺得了解這個沒啥用處。詳情參見：https://blogs.oracle.com/java-platform-group/update-and-faq-on-the-java-se-release-cadence 。
2.OpenJDK 是一個參考模型并且是完全開源的，而 Oracle JDK 是 OpenJDK 的一個實現，并不是完全開源的；
3.Oracle JDK 比 OpenJDK 更穩定。OpenJDK 和 Oracle JDK 的代碼幾乎相同，但 Oracle JDK 有更多的類和一些錯誤修復。因此，如果您想開發企業/商業軟件，我建議您選擇 Oracle JDK，因為它經過了徹底的測試和穩定。某些情況下，有些人提到在使用 OpenJDK 可能會遇到了許多應用程序崩潰的問題，但是，只需切換到 Oracle JDK 就可以解決問題；
4.在響應性和 JVM 性能方面，Oracle JDK 與 OpenJDK 相比提供了更好的性能；
5.Oracle JDK 不會為即將發布的版本提供長期支持，用戶每次都必須通過更新到最新版本獲得支持來獲取最新版本；
6.Oracle JDK 根據二進制代碼許可協議獲得許可，而 OpenJDK 根據 GPL v2 許可獲得許可。

1.1.4. Java 和 C++的區別?

我知道很多人沒學過 C++，但是面試官就是沒事喜歡拿咱們 Java 和 C++ 比呀！沒辦法！！！就算沒學過 C++，也要記下來！

• 都是面向對象的語言，都支持封裝、繼承和多態
• Java 不提供指針來直接訪問內存，程序內存更加安全
• Java 的類是單繼承的，C++ 支持多重繼承；雖然 Java 的類不可以多繼承，但是接口可以多繼承。
• Java 有自動內存管理垃圾回收機制(GC)，不需要程序員手動釋放無用內存
• 在 C 語言中，字符串或字符數組最后都會有一個額外的字符’\0’來表示結束。但是，Java 語言中沒有結束符這一概念。 這是一個值得深度思考的問題，具體原因推薦看這篇文章： https://blog.csdn.net/sszgg2006/article/details/49148189

1.1.5. 什么是 Java 程序的主類 應用程序和小程序的主類有何不同?

一個程序中可以有多個類，但只能有一個類是主類。在 Java 應用程序中，這個主類是指包含 main() 方法的類。而在 Java 小程序中，這個主類是一個繼承自系統類 JApplet 或 Applet 的子類。應用程序的主類不一定要求是 public 類，但小程序的主類要求必須是 public 類。主類是 Java 程序執行的入口點。

1.1.6. import java 和 javax 有什么區別？

剛開始的時候 JavaAPI 所必需的包是 java 開頭的包，javax 當時只是擴展 API 包來使用。然而隨著時間的推移，javax 逐漸地擴展成為 Java API 的組成部分。但是，將擴展從 javax 包移動到 java 包確實太麻煩了，最終會破壞一堆現有的代碼。因此，最終決定 javax 包將成為標準 API 的一部分。

所以，實際上 java 和 javax 沒有區別。這都是一個名字。

1.1.7. 為什么說 Java 語言“編譯與解釋并存”？

高級編程語言按照程序的執行方式分為編譯型和解釋型兩種。簡單來說，編譯型語言是指編譯器針對特定的操作系統將源代碼一次性翻譯成可被該平臺執行的機器碼；解釋型語言是指解釋器對源程序逐行解釋成特定平臺的機器碼并立即執行。比如，你想閱讀一本英文名著，你可以找一個英文翻譯人員幫助你閱讀， 有兩種選擇方式，你可以先等翻譯人員將全本的英文名著（也就是源碼）都翻譯成漢語，再去閱讀，也可以讓翻譯人員翻譯一段，你在旁邊閱讀一段，慢慢把書讀完。

Java 語言既具有編譯型語言的特征，也具有解釋型語言的特征，因為 Java 程序要經過先編譯，后解釋兩個步驟，由 Java 編寫的程序需要先經過編譯步驟，生成字節碼（*.class 文件），這種字節碼必須由 Java 解釋器來解釋執行。因此，我們可以認為 Java 語言編譯與解釋并存。

1.2. Java 語法

1.2.1. 字符型常量和字符串常量的區別?

1.形式上: 字符常量是單引號引起的一個字符; 字符串常量是雙引號引起的0個或若干個字符
2.含義上: 字符常量相當于一個整型值( ASCII 值),可以參加表達式運算; 字符串常量代表一個地址值(該字符串在內存中存放位置)
3.占內存大小 字符常量只占 2 個字節; 字符串常量占若干個字節 (注意： char 在 Java 中占兩個字節),

字符封裝類 Character 有一個成員常量 Character.SIZE 值為16,單位是bits,該值除以8(1byte=8bits)后就可以得到2個字節

java 編程思想第四版：2.2.2 節

1.2.2. 關于注釋？

Java 中的注釋有三種：

1.單行注釋

2.多行注釋

3.文檔注釋。

在我們編寫代碼的時候，如果代碼量比較少，我們自己或者團隊其他成員還可以很輕易地看懂代碼，但是當項目結構一旦復雜起來，我們就需要用到注釋了。注釋并不會執行(編譯器在編譯代碼之前會把代碼中的所有注釋抹掉,字節碼中不保留注釋)，是我們程序員寫給自己看的，注釋是你的代碼說明書，能夠幫助看代碼的人快速地理清代碼之間的邏輯關系。因此，在寫程序的時候隨手加上注釋是一個非常好的習慣。

《Clean Code》這本書明確指出：

代碼的注釋不是越詳細越好。實際上好的代碼本身就是注釋，我們要盡量規范和美化自己的代碼來減少不必要的注釋。

若編程語言足夠有表達力，就不需要注釋，盡量通過代碼來闡述。

舉個例子：

去掉下面復雜的注釋，只需要創建一個與注釋所言同一事物的函數即可

// check to see if the employee is eligible for full benefits if ((employee.flags & HOURLY_FLAG) && (employee.age > 65)) 應替換為if (employee.isEligibleForFullBenefits())

1.2.3. 標識符和關鍵字的區別是什么？

在我們編寫程序的時候，需要大量地為程序、類、變量、方法等取名字，于是就有了標識符，簡單來說，標識符就是一個名字。但是有一些標識符，Java 語言已經賦予了其特殊的含義，只能用于特定的地方，這種特殊的標識符就是關鍵字。因此，關鍵字是被賦予特殊含義的標識符。比如，在我們的日常生活中 ，“警察局”這個名字已經被賦予了特殊的含義，所以如果你開一家店，店的名字不能叫“警察局”，“警察局”就是我們日常生活中的關鍵字。

1.2.4. Java中有哪些常見的關鍵字？

1.2.5. 自增自減運算符

在寫代碼的過程中，常見的一種情況是需要某個整數類型變量增加 1 或減少 1，Java 提供了一種特殊的運算符，用于這種表達式，叫做自增運算符（++)和自減運算符（–）。

++和–運算符可以放在變量之前，也可以放在變量之后，當運算符放在變量之前時(前綴)，先自增/減，再賦值；當運算符放在變量之后時(后綴)，先賦值，再自增/減。例如，當 b = ++a 時，先自增（自己增加 1），再賦值（賦值給 b）；當 b = a++ 時，先賦值(賦值給 b)，再自增（自己增加 1）。也就是，++a 輸出的是 a+1 的值，a++輸出的是 a 值。用一句口訣就是：“符號在前就先加/減，符號在后就后加/減”。

1.2.6. continue、break、和return的區別是什么？

在循環結構中，當循環條件不滿足或者循環次數達到要求時，循環會正常結束。但是，有時候可能需要在循環的過程中，當發生了某種條件之后 ，提前終止循環，這就需要用到下面幾個關鍵詞：

• continue ：指跳出當前的這一次循環，繼續下一次循環。

• break ：指跳出整個循環體，繼續執行循環下面的語句。
  return 用于跳出所在方法，結束該方法的運行。return 一般有兩種用法：

• return; ：直接使用 return 結束方法執行，用于沒有返回值函數的方法

• return value; ：return 一個特定值，用于有返回值函數的方法

1.2.7. Java泛型了解么？什么是類型擦除？介紹一下常用的通配符？

Java 泛型（generics）是 JDK 5 中引入的一個新特性, 泛型提供了編譯時類型安全檢測機制，該機制允許程序員在編譯時檢測到非法的類型。泛型的本質是參數化類型，也就是說所操作的數據類型被指定為一個參數。

Java的泛型是偽泛型，這是因為Java在編譯期間，所有的泛型信息都會被擦掉，這也就是通常所說類型擦除 。 更多關于類型擦除的問題，可以查看這篇文章：《Java泛型類型擦除以及類型擦除帶來的問題》 。

List<Integer> list = new ArrayList<>();list.add(12); //這里直接添加會報錯 list.add("a"); Class<? extends List> clazz = list.getClass(); Method add = clazz.getDeclaredMethod("add", Object.class); //但是通過反射添加，是可以的 add.invoke(list, "kl");System.out.println(list)

泛型一般有三種使用方式:泛型類、泛型接口、泛型方法。

1.泛型類：

//此處T可以隨便寫為任意標識，常見的如T、E、K、V等形式的參數常用于表示泛型 //在實例化泛型類時，必須指定T的具體類型 public class Generic<T>{ private T key;public Generic(T key) { this.key = key;}public T getKey(){ return key;} } 如何實例化泛型類：Generic<Integer> genericInteger = new Generic<Integer>(123456);

2.泛型接口 ：

public interface Generator<T> {public T method(); } 實現泛型接口，不指定類型：class GeneratorImpl<T> implements Generator<T>{@Overridepublic T method() {return null;} } 實現泛型接口，指定類型：class GeneratorImpl<T> implements Generator<String>{@Overridepublic String method() {return "hello";} }

3.泛型方法 ：

public static < E > void printArray( E[] inputArray ){ for ( E element : inputArray ){ System.out.printf( "%s ", element );}System.out.println();} 使用：// 創建不同類型數組： Integer, Double 和 Character Integer[] intArray = { 1, 2, 3 }; String[] stringArray = { "Hello", "World" }; printArray( intArray ); printArray( stringArray );

常用的通配符為： T，E，K，V，？

• ？ 表示不確定的 java 類型
• T (type) 表示具體的一個java類型
• K V (key value) 分別代表java鍵值中的Key Value
• E (element) 代表Element
• 更多關于Java 泛型中的通配符可以查看這篇文章：《聊一聊-JAVA 泛型中的通配符 T，E，K，V，？》

1.2.8. ==和equals的區別

== : 它的作用是判斷兩個對象的地址是不是相等。即判斷兩個對象是不是同一個對象。(基本數據類型比較的是值，引用數據類型比較的是內存地址)

因為 Java 只有值傳遞，所以，對于 == 來說，不管是比較基本數據類型，還是引用數據類型的變量，其本質比較的都是值，只是引用類型變量存的值是對象的地址。

equals() : 它的作用也是判斷兩個對象是否相等，它不能用于比較基本數據類型的變量。equals()方法存在于Object類中，而Object類是所有類的直接或間接父類。

Object類equals()方法：

public boolean equals(Object obj) {return (this == obj); }

equals() 方法存在兩種使用情況：

• 情況 1：類沒有覆蓋 equals()方法。則通過 equals()比較該類的兩個對象時，等價于通過“==”比較這兩個對象。使用的默認是 Object類equals()方法。
• 情況 2：類覆蓋了 equals()方法。一般，我們都覆蓋 equals()方法來兩個對象的內容相等；若它們的內容相等，則返回 true(即，認為這兩個對象相等)。
  舉個例子：

public class test1 {public static void main(String[] args) {String a = new String("ab"); // a 為一個引用String b = new String("ab"); // b為另一個引用,對象的內容一樣String aa = "ab"; // 放在常量池中String bb = "ab"; // 從常量池中查找if (aa == bb) // trueSystem.out.println("aa==bb");if (a == b) // false，非同一對象System.out.println("a==b");if (a.equals(b)) // trueSystem.out.println("aEQb");if (42 == 42.0) { // trueSystem.out.println("true");}} }

說明：

• String 中的 equals 方法是被重寫過的，因為 Object 的 equals 方法是比較的對象的內存地址，而 String 的 equals 方法比較的是對象的值。
• 當創建 String 類型的對象時，虛擬機會在常量池中查找有沒有已經存在的值和要創建的值相同的對象，如果有就把它賦給當前引用。如果沒有就在常量池中重新創建一個 String 對象。
  String類equals()方法：

public boolean equals(Object anObject) {if (this == anObject) {return true;}if (anObject instanceof String) {String anotherString = (String)anObject;int n = value.length;if (n == anotherString.value.length) {char v1[] = value;char v2[] = anotherString.value;int i = 0;while (n-- != 0) {if (v1[i] != v2[i])return false;i++;}return true;}}return false; }

1.2.9. hashCode()與 equals()

面試官可能會問你：“你重寫過 hashcode 和 equals 么，為什么重寫 equals 時必須重寫 hashCode 方法？”

1)hashCode()介紹:

hashCode() 的作用是獲取哈希碼，也稱為散列碼；它實際上是返回一個 int 整數。這個哈希碼的作用是確定該對象在哈希表中的索引位置。hashCode() 定義在 JDK 的 Object 類中，這就意味著 Java 中的任何類都包含有 hashCode() 函數。另外需要注意的是： Object 的 hashcode 方法是本地方法，也就是用 c 語言或 c++ 實現的，該方法通常用來將對象的 內存地址 轉換為整數之后返回。

public native int hashCode();
散列表存儲的是鍵值對(key-value)，它的特點是：能根據“鍵”快速的檢索出對應的“值”。這其中就利用到了散列碼！（可以快速找到所需要的對象）

2)為什么要有 hashCode？

我們以“HashSet 如何檢查重復”為例子來說明為什么要有 hashCode？

當你把對象加入 HashSet 時，HashSet 會先計算對象的 hashcode 值來判斷對象加入的位置，同時也會與其他已經加入的對象的 hashcode 值作比較，如果沒有相符的 hashcode，HashSet 會假設對象沒有重復出現。但是如果發現有相同 hashcode 值的對象，這時會調用 equals() 方法來檢查 hashcode 相等的對象是否真的相同。如果兩者相同，HashSet 就不會讓其加入操作成功。如果不同的話，就會重新散列到其他位置。（摘自我的 Java 啟蒙書《Head First Java》第二版）。這樣我們就大大減少了 equals 的次數，相應就大大提高了執行速度。

3)為什么重寫 equals 時必須重寫 hashCode 方法？

如果兩個對象相等，則 hashcode 一定也是相同的。兩個對象相等,對兩個對象分別調用 equals 方法都返回 true。但是，兩個對象有相同的 hashcode 值，它們也不一定是相等的 。因此，equals 方法被覆蓋過，則 hashCode 方法也必須被覆蓋。

hashCode()的默認行為是對堆上的對象產生獨特值。如果沒有重寫 hashCode()，則該 class 的兩個對象無論如何都不會相等（即使這兩個對象指向相同的數據）

4)為什么兩個對象有相同的 hashcode 值，它們也不一定是相等的？

在這里解釋一位小伙伴的問題。以下內容摘自《Head Fisrt Java》。

因為 hashCode() 所使用的雜湊算法也許剛好會讓多個對象傳回相同的雜湊值。越糟糕的雜湊算法越容易碰撞，但這也與數據值域分布的特性有關（所謂碰撞也就是指的是不同的對象得到相同的 hashCode。

我們剛剛也提到了 HashSet,如果 HashSet 在對比的時候，同樣的 hashcode 有多個對象，它會使用 equals() 來判斷是否真的相同。也就是說 hashcode 只是用來縮小查找成本。

更多關于 hashcode() 和 equals() 的內容可以查看：Java hashCode() 和 equals()的若干問題解答

1.3. 基本數據類型

1.3.1. Java中的幾種基本數據類型是什么？對應的包裝類型是什么？各自占用多少字節呢？

Java中有8種基本數據類型，分別為：

• 6種數字類型 ：byte、short、int、long、float、double
• 1種字符類型：char
• 1種布爾型：boolean。
  這八種基本類型都有對應的包裝類分別為：Byte、Short、Integer、Long、Float、Double、Character、Boolean

對于boolean，官方文檔未明確定義，它依賴于 JVM 廠商的具體實現。邏輯上理解是占用 1位，但是實際中會考慮計算機高效存儲因素。

注意：

• Java 里使用 long 類型的數據一定要在數值后面加上 L，否則將作為整型解析：
• char a = 'h’char :單引號，String a = “hello” :雙引號

1.3.2. 自動裝箱與拆箱

• 裝箱：將基本類型用它們對應的引用類型包裝起來；
• 拆箱：將包裝類型轉換為基本數據類型；
  更多內容見：深入剖析 Java 中的裝箱和拆箱

1.3.3. 8種基本類型的包裝類和常量池

Java 基本類型的包裝類的大部分都實現了常量池技術，即 Byte,Short,Integer,Long,Character,Boolean；前面 4 種包裝類默認創建了數值[-128，127] 的相應類型的緩存數據，Character創建了數值在[0,127]范圍的緩存數據，Boolean 直接返回True Or False。如果超出對應范圍仍然會去創建新的對象。 為啥把緩存設置為[-128，127]區間？（參見issue/461）性能和資源之間的權衡。

public static Boolean valueOf(boolean b) {return (b ? TRUE : FALSE); } private static class CharacterCache { private CharacterCache(){}static final Character cache[] = new Character[127 + 1]; static { for (int i = 0; i < cache.length; i++) cache[i] = new Character((char)i); } }

兩種浮點數類型的包裝類 Float,Double 并沒有實現常量池技術。**

Integer i1 = 33;Integer i2 = 33;System.out.println(i1 == i2);// 輸出 trueInteger i11 = 333;Integer i22 = 333;System.out.println(i11 == i22);// 輸出 falseDouble i3 = 1.2;Double i4 = 1.2;System.out.println(i3 == i4);// 輸出 false

Integer 緩存源代碼：

/**
*此方法將始終緩存-128 到 127（包括端點）范圍內的值，并可以緩存此范圍之外的其他值。

*/public static Integer valueOf(int i) {if (i >= IntegerCache.low && i <= IntegerCache.high)return IntegerCache.cache[i + (-IntegerCache.low)];return new Integer(i);}

應用場景：

Integer i1=40；Java 在編譯的時候會直接將代碼封裝成 Integer i1=Integer.valueOf(40);，從而使用常量池中的對象。 Integer i1 = new Integer(40);這種情況下會創建新的對象。Integer i1 = 40;Integer i2 = new Integer(40);System.out.println(i1 == i2);//輸出 false

Integer 比較更豐富的一個例子:

Integer i1 = 40;Integer i2 = 40;Integer i3 = 0;Integer i4 = new Integer(40);Integer i5 = new Integer(40);Integer i6 = new Integer(0);System.out.println("i1=i2 " + (i1 == i2));System.out.println("i1=i2+i3 " + (i1 == i2 + i3));System.out.println("i1=i4 " + (i1 == i4));System.out.println("i4=i5 " + (i4 == i5));System.out.println("i4=i5+i6 " + (i4 == i5 + i6)); System.out.println("40=i5+i6 " + (40 == i5 + i6)); 結果：i1=i2 true i1=i2+i3 true i1=i4 false i4=i5 false i4=i5+i6 true 40=i5+i6 true

解釋：

語句 i4 == i5 + i6，因為+這個操作符不適用于 Integer 對象，首先 i5 和 i6 進行自動拆箱操作，進行數值相加，即 i4 == 40。然后 Integer 對象無法與數值進行直接比較，所以 i4 自動拆箱轉為 int 值 40，最終這條語句轉為 40 == 40 進行數值比較。

1.4. 方法（函數）

1.4.1. 什么是方法的返回值?返回值在類的方法里的作用是什么?

方法的返回值是指我們獲取到的某個方法體中的代碼執行后產生的結果！（前提是該方法可能產生結果）。返回值的作用是接收出結果，使得它可以用于其他的操作！

1.4.2. 為什么 Java 中只有值傳遞？

首先回顧一下在程序設計語言中有關將參數傳遞給方法（或函數）的一些專業術語。按值調用(call by value)表示方法接收的是調用者提供的值，而按引用調用（call by reference)表示方法接收的是調用者提供的變量地址。一個方法可以修改傳遞引用所對應的變量值，而不能修改傳遞值調用所對應的變量值。 它用來描述各種程序設計語言（不只是 Java)中方法參數傳遞方式。

Java 程序設計語言總是采用按值調用。也就是說，方法得到的是所有參數值的一個拷貝，也就是說，方法不能修改傳遞給它的任何參數變量的內容。

下面通過 3 個例子來給大家說明

example 1

public static void main(String[] args) {int num1 = 10;int num2 = 20;swap(num1, num2);System.out.println("num1 = " + num1);System.out.println("num2 = " + num2); }public static void swap(int a, int b) {int temp = a;a = b;b = temp;System.out.println("a = " + a);System.out.println("b = " + b); }

結果：

a = 20 b = 10 num1 = 10 num2 = 20

解析：

example 1

在 swap 方法中，a、b 的值進行交換，并不會影響到 num1、num2。因為，a、b 中的值，只是從 num1、num2 的復制過來的。也就是說，a、b 相當于 num1、num2 的副本，副本的內容無論怎么修改，都不會影響到原件本身。

通過上面例子，我們已經知道了一個方法不能修改一個基本數據類型的參數，而對象引用作為參數就不一樣，請看 example2.
example 2

public static void main(String[] args) {int[] arr = { 1, 2, 3, 4, 5 };System.out.println(arr[0]);change(arr);System.out.println(arr[0]);}public static void change(int[] array) {// 將數組的第一個元素變為0array[0] = 0;}

結果：

1 0

解析：

example 2

array 被初始化 arr 的拷貝也就是一個對象的引用，也就是說 array 和 arr 指向的是同一個數組對象。 因此，外部對引用對象的改變會反映到所對應的對象上。

通過 example2 我們已經看到，實現一個改變對象參數狀態的方法并不是一件難事。理由很簡單，方法得到的是對象引用的拷貝，對象引用及其他的拷貝同時引用同一個對象。

很多程序設計語言（特別是，C++和 Pascal)提供了兩種參數傳遞的方式：值調用和引用調用。有些程序員（甚至本書的作者）認為 Java 程序設計語言對對象采用的是引用調用，實際上，這種理解是不對的。由于這種誤解具有一定的普遍性，所以下面給出一個反例來詳細地闡述一下這個問題。

example 3

public class Test {public static void main(String[] args) {// TODO Auto-generated method stubStudent s1 = new Student("小張");Student s2 = new Student("小李");Test.swap(s1, s2);System.out.println("s1:" + s1.getName());System.out.println("s2:" + s2.getName());}public static void swap(Student x, Student y) {Student temp = x;x = y;y = temp;System.out.println("x:" + x.getName());System.out.println("y:" + y.getName());} }

結果：

x:小李
y:小張
s1:小張
s2:小李
解析：

交換之前：

交換之后：

通過上面兩張圖可以很清晰的看出： 方法并沒有改變存儲在變量 s1 和 s2 中的對象引用。swap 方法的參數 x 和 y 被初始化為兩個對象引用的拷貝，這個方法交換的是這兩個拷貝

總結

Java 程序設計語言對對象采用的不是引用調用，實際上，對象引用是按 值傳遞的。

下面再總結一下 Java 中方法參數的使用情況：

一個方法不能修改一個基本數據類型的參數（即數值型或布爾型）。
一個方法可以改變一個對象參數的狀態。
一個方法不能讓對象參數引用一個新的對象。
參考：

《Java 核心技術卷 Ⅰ》基礎知識第十版第四章 4.5 小節

1.4.3. 重載和重寫的區別

重載就是同樣的一個方法能夠根據輸入數據的不同，做出不同的處理

重寫就是當子類繼承自父類的相同方法，輸入數據一樣，但要做出有別于父類的響應時，你就要覆蓋父類方法

重載：

發生在同一個類中，方法名必須相同，參數類型不同、個數不同、順序不同，方法返回值和訪問修飾符可以不同。

下面是《Java 核心技術》對重載這個概念的介紹：

綜上：重載就是同一個類中多個同名方法根據不同的傳參來執行不同的邏輯處理。

重寫：

重寫發生在運行期，是子類對父類的允許訪問的方法的實現過程進行重新編寫。

返回值類型、方法名、參數列表必須相同，拋出的異常范圍小于等于父類，訪問修飾符范圍大于等于父類。
如果父類方法訪問修飾符為 private/final/static 則子類就不能重寫該方法，但是被 static 修飾的方法能夠被再次聲明。
構造方法無法被重寫
綜上：重寫就是子類對父類方法的重新改造，外部樣子不能改變，內部邏輯可以改變

暖心的 Guide 哥最后再來個圖表總結一下！

方法的重寫要遵循“兩同兩小一大”（以下內容摘錄自《瘋狂 Java 講義》）：

• “兩同”即方法名相同、形參列表相同；
• “兩小”指的是子類方法返回值類型應比父類方法返回值類型更小或相等，子類方法聲明拋出的異常類應比父類方法聲明拋出的異常類更小或相等；
• “一大”指的是子類方法的訪問權限應比父類方法的訪問權限更大或相等。

1.4.4. 深拷貝 vs 淺拷貝

• 淺拷貝：對基本數據類型進行值傳遞，對引用數據類型進行引用傳遞般的拷貝，此為淺拷貝。
• 深拷貝：對基本數據類型進行值傳遞，對引用數據類型，創建一個新的對象，并復制其內容，此為深拷貝。
  deep and shallow copy
  

1.4.5. 方法的四種類型

1、無參數無返回值的方法

// 無參數無返回值的方法(如果方法沒有返回值，不能不寫，必須寫void，表示沒有返回值) public void f1() {System.out.println("無參數無返回值的方法"); }

2、有參數無返回值的方法

/** * 有參數無返回值的方法 * 參數列表由零組到多組“參數類型+形參名”組合而成，多組參數之間以英文逗號（,）隔開，形參類型和形參名之間以英文空格隔開 */ public void f2(int a, String b, int c) {System.out.println(a + "-->" + b + "-->" + c); }

3、有返回值無參數的方法

// 有返回值無參數的方法（返回值可以是任意的類型,在函數里面必須有return關鍵字返回對應的類型） public int f3() {System.out.println("有返回值無參數的方法");return 2; }

4、有返回值有參數的方法

// 有返回值有參數的方法 public int f4(int a, int b) {return a * b; } 5、return 在無返回值方法的特殊使用// return在無返回值方法的特殊使用 public void f5(int a) {if (a > 10) {return;//表示結束所在方法 （f5方法）的執行,下方的輸出語句不會執行}System.out.println(a); }

總結

以上是生活随笔為你收集整理的Java 基本功之（一）入门知识点的全部內容，希望文章能夠幫你解決所遇到的問題。

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