Java基礎知識回顧(一)

阿新 • • 發佈：2022-04-01

1. 面向物件和麵向過程的區別

面向過程 ：面向過程效能比面向物件高。 因為類呼叫時需要例項化，開銷比較大，比較消耗資源，所以當效能是最重要的考量因素的時候，比如微控制器、嵌入式開發、Linux/Unix等一般採用面向過程開發。但是，面向過程沒有面向物件易維護、易複用、易擴充套件。
面向物件 ：面向物件易維護、易複用、易擴充套件。 因為面向物件有封裝、繼承、多型性的特性，所以可以設計出低耦合的系統，使系統更加靈活、更加易於維護。但是，面向物件效能比面向過程低。

2. Java 語言有哪些特點?

簡單易學；
面向物件（封裝，繼承，多型）；
平臺無關性（ Java 虛擬機器實現平臺無關性）；

可靠性；
安全性；
支援多執行緒（ C++ 語言沒有內建的多執行緒機制，因此必須呼叫作業系統的多執行緒功能來進行多執行緒程式設計，而 Java 語言卻提供了多執行緒支援）；
支援網路程式設計並且很方便（ Java 語言誕生本身就是為簡化網路程式設計設計的，因此 Java 語言不僅支援網路程式設計而且很方便）；
編譯與解釋並存；

3. 關於 JVM JDK 和 JRE 最詳細通俗的解答

JVM

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

什麼是位元組碼?採用位元組碼的好處是什麼?

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

Java 程式從原始碼到執行一般有下面3步：

我們需要格外注意的是 .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 語言“一次編譯，隨處可以執行”的關鍵所在。

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。

4. 字元型常量和字串常量的區別?

形式上: 字元常量是單引號引起的一個字元; 字串常量是雙引號引起的若干個字元
含義上: 字元常量相當於一個整型值( ASCII 值),可以參加表示式運算; 字串常量代表一個地址值(該字串在記憶體中存放位置)
佔記憶體大小字元常量只佔2個位元組; 字串常量佔若干個位元組(至少一個字元結束標誌) (注意： char在Java中佔兩個位元組)

java程式設計思想第四版：2.2.2節

5. 構造器 Constructor 是否可被 override?

在講繼承的時候我們就知道父類的私有屬性和構造方法並不能被繼承，所以 Constructor 也就不能被 override（重寫）,但是可以 overload（過載）,所以你可以看到一個類中有多個建構函式的情況。

6. 過載和重寫的區別

過載： 發生在同一個類中，方法名必須相同，引數型別不同、個數不同、順序不同，方法返回值和訪問修飾符可以不同，發生在編譯時。　　
重寫： 發生在父子類中，方法名、引數列表必須相同，返回值範圍小於等於父類，丟擲的異常範圍小於等於父類，訪問修飾符範圍大於等於父類；如果父類方法訪問修飾符為 private 則子類就不能重寫該方法。

7. Java 面向物件程式設計三大特性: 封裝繼承多型

封裝

封裝把一個物件的屬性私有化，同時提供一些可以被外界訪問的屬性的方法，如果屬性不想被外界訪問，我們大可不必提供方法給外界訪問。但是如果一個類沒有提供給外界訪問的方法，那麼這個類也沒有什麼意義了。

繼承

繼承是使用已存在的類的定義作為基礎建立新類的技術，新類的定義可以增加新的資料或新的功能，也可以用父類的功能，但不能選擇性地繼承父類。通過使用繼承我們能夠非常方便地複用以前的程式碼。

關於繼承如下 3 點請記住：

子類擁有父類物件所有的屬性和方法（包括私有屬性和私有方法），但是父類中的私有屬性和方法子類是無法訪問，只是擁有。
子類可以擁有自己屬性和方法，即子類可以對父類進行擴充套件。
子類可以用自己的方式實現父類的方法。（以後介紹）。

多型

所謂多型就是指程式中定義的引用變數所指向的具體型別和通過該引用變數發出的方法呼叫在程式設計時並不確定，而是在程式執行期間才確定，即一個引用變數到底會指向哪個類的例項物件，該引用變數發出的方法呼叫到底是哪個類中實現的方法，必須在由程式執行期間才能決定。

在Java中有兩種形式可以實現多型：繼承（多個子類對同一方法的重寫）和介面（實現介面並覆蓋介面中同一方法）。

8. String StringBuffer 和 StringBuilder 的區別是什麼? String 為什麼是不可變的?

可變性

簡單的來說：String 類中使用 final 關鍵字修飾字符陣列來儲存字串，private　final　char　value[]，所以 String 物件是不可變的。而StringBuilder 與 StringBuffer 都繼承自 AbstractStringBuilder 類，在 AbstractStringBuilder 中也是使用字元陣列儲存字串char[]value 但是沒有用 final 關鍵字修飾，所以這兩種物件都是可變的。

StringBuilder 與 StringBuffer 的構造方法都是呼叫父類構造方法也就是 AbstractStringBuilder 實現的，大家可以自行查閱原始碼。

AbstractStringBuilder.java

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    char[] value;
    int count;
    AbstractStringBuilder() {
    }
    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }

執行緒安全性

String 中的物件是不可變的，也就可以理解為常量，執行緒安全。AbstractStringBuilder 是 StringBuilder 與 StringBuffer 的公共父類，定義了一些字串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法。StringBuffer 對方法加了同步鎖或者對呼叫的方法加了同步鎖，所以是執行緒安全的。StringBuilder 並沒有對方法進行加同步鎖，所以是非執行緒安全的。　

效能

每次對 String 型別進行改變的時候，都會生成一個新的 String 物件，然後將指標指向新的 String 物件。StringBuffer 每次都會對 StringBuffer 物件本身進行操作，而不是生成新的物件並改變物件引用。相同情況下使用 StringBuilder 相比使用 StringBuffer 僅能獲得 10%~15% 左右的效能提升，但卻要冒多執行緒不安全的風險。

對於三者使用的總結：

操作少量的資料: 適用String
單執行緒操作字串緩衝區下操作大量資料: 適用StringBuilder
多執行緒操作字串緩衝區下操作大量資料: 適用StringBuffer

9. 自動裝箱與拆箱

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

10. 在一個靜態方法內呼叫一個非靜態成員為什麼是非法的?

由於靜態方法可以不通過物件進行呼叫，因此在靜態方法裡，不能呼叫其他非靜態變數，也不可以訪問非靜態變數成員。

11. 在 Java 中定義一個不做事且沒有引數的構造方法的作用

Java 程式在執行子類的構造方法之前，如果沒有用 super()來呼叫父類特定的構造方法，則會呼叫父類中“沒有引數的構造方法”。因此，如果父類中只定義了有引數的構造方法，而在子類的構造方法中又沒有用 super()來呼叫父類中特定的構造方法，則編譯時將發生錯誤，因為 Java 程式在父類中找不到沒有引數的構造方法可供執行。解決辦法是在父類里加上一個不做事且沒有引數的構造方法。　

12. 介面和抽象類的區別是什麼？

介面的方法預設是 public，所有方法在介面中不能有實現(Java 8 開始介面方法可以有預設實現），而抽象類可以有非抽象的方法。
介面中除了static、final變數，不能有其他變數，而抽象類中則不一定。
一個類可以實現多個介面，但只能實現一個抽象類。介面自己本身可以通過extends關鍵字擴充套件多個介面。
介面方法預設修飾符是public，抽象方法可以有public、protected和default這些修飾符（抽象方法就是為了被重寫所以不能使用private關鍵字修飾！）。
從設計層面來說，抽象是對類的抽象，是一種模板設計，而介面是對行為的抽象，是一種行為的規範。

備註：在JDK8中，介面也可以定義靜態方法，可以直接用介面名呼叫。實現類和實現是不可以呼叫的。如果同時實現兩個介面，介面中定義了一樣的預設方法，則必須重寫，不然會報錯。(詳見issue:https://github.com/Snailclimb/JavaGuide/issues/146)

13. == 與 equals(重要))

== : 它的作用是判斷兩個物件的地址是不是相等。即，判斷兩個物件是不是同一個物件(基本資料型別比較的是值，引用資料型別比較的是記憶體地址)。

equals() : 它的作用也是判斷兩個物件是否相等。但它一般有兩種使用情況：

情況1：類沒有覆蓋 equals() 方法。則通過 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) // true
            System.out.println("aa==bb");
        if (a == b) // false，非同一物件
            System.out.println("a==b");
        if (a.equals(b)) // true
            System.out.println("aEQb");
        if (42 == 42.0) { // true
            System.out.println("true");
        }
    }
}

說明：

String 中的 equals 方法是被重寫過的，因為 object 的 equals 方法是比較的物件的記憶體地址，而 String 的 equals 方法比較的是物件的值。
當建立 String 型別的物件時，虛擬機器會在常量池中查詢有沒有已經存在的值和要建立的值相同的物件，如果有就把它賦給當前引用。如果沒有就在常量池中重新建立一個 String 物件。

14. hashCode 與 equals (重要)

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

hashCode（）介紹

hashCode() 的作用是獲取雜湊碼，也稱為雜湊碼；它實際上是返回一個int整數。這個雜湊碼的作用是確定該物件在雜湊表中的索引位置。hashCode() 定義在JDK的Object.java中，這就意味著Java中的任何類都包含有hashCode() 函式。

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

為什麼要有 hashCode

我們先以“HashSet 如何檢查重複”為例子來說明為什麼要有 hashCode： 當你把物件加入 HashSet 時，HashSet 會先計算物件的 hashcode 值來判斷物件加入的位置，同時也會與其他已經加入的物件的 hashcode 值作比較，如果沒有相符的hashcode，HashSet會假設物件沒有重複出現。但是如果發現有相同 hashcode 值的物件，這時會呼叫 equals（）方法來檢查 hashcode 相等的物件是否真的相同。如果兩者相同，HashSet 就不會讓其加入操作成功。如果不同的話，就會重新雜湊到其他位置。（摘自我的Java啟蒙書《Head first java》第二版）。這樣我們就大大減少了 equals 的次數，相應就大大提高了執行速度。

通過我們可以看出：hashCode() 的作用就是獲取雜湊碼，也稱為雜湊碼；它實際上是返回一個int整數。這個雜湊碼的作用是確定該物件在雜湊表中的索引位置。hashCode()在散列表中才有用，在其它情況下沒用。在散列表中hashCode() 的作用是獲取物件的雜湊碼，進而確定該物件在散列表中的位置。

hashCode（）與equals（）的相關規定

如果兩個物件相等，則hashcode一定也是相同的
兩個物件相等,對兩個物件分別呼叫equals方法都返回true
兩個物件有相同的hashcode值，它們也不一定是相等的
因此，equals 方法被覆蓋過，則 hashCode 方法也必須被覆蓋
hashCode() 的預設行為是對堆上的物件產生獨特值。如果沒有重寫 hashCode()，則該 class 的兩個物件無論如何都不會相等（即使這兩個物件指向相同的資料）

推薦閱讀：Java hashCode() 和 equals()的若干問題解答

15. 為什麼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

解析：

在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) {
		// 將陣列的第一個元素變為0
		array[0] = 0;
	}

結果：

1
0

解析：

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

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

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

example 3

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student 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中方法引數的使用情況：

一個方法不能修改一個基本資料型別的引數（即數值型或布林型）。
一個方法可以改變一個物件引數的狀態。
一個方法不能讓物件引數引用一個新的物件。

參考：https://github.com/niaobulashi/JavaGuide

Java基礎知識回顧(一)

1. 面向物件和麵向過程的區別

2. Java 語言有哪些特點?

3. 關於 JVM JDK 和 JRE 最詳細通俗的解答

JVM

JDK 和 JRE

4. 字元型常量和字串常量的區別?

5. 構造器 Constructor 是否可被 override?

6. 過載和重寫的區別

7. Java 面向物件程式設計三大特性: 封裝 繼承 多型

封裝

繼承

多型

8. String StringBuffer 和 StringBuilder 的區別是什麼? String 為什麼是不可變的?

9. 自動裝箱與拆箱

10. 在一個靜態方法內呼叫一個非靜態成員為什麼是非法的?

11. 在 Java 中定義一個不做事且沒有引數的構造方法的作用

12. 介面和抽象類的區別是什麼？

13. == 與 equals(重要))

14. hashCode 與 equals (重要)

hashCode（）介紹

為什麼要有 hashCode

hashCode（）與equals（）的相關規定

15. 為什麼Java中只有值傳遞？

example 1

example 2

example 3

總結

相關推薦

7. Java 面向物件程式設計三大特性: 封裝繼承多型