java基礎

一、基本類型

1.基本類型和包裝類型

2.基本介紹

java對於基本數據類型不是用new關鍵字創建，而是直接將變量存儲在堆棧中，更加高效。基本類型存儲空間大小與機器硬件架構無關，是java具有強可移植性的原因之一。下圖爲java內存空間示意圖：

爲什麼要有包裝數據類型？是因爲Java是一個面向對象的語言，它相當於把基本類型包裝起來，使它具有了對象的性質，並且爲其添加了屬性和方法。（在使用集合類型Collection時就必須使用包裝類型而非基本類型）

Character ch = new Character('x');
 char c = ch;//自動拆箱
 
 char c = 'c';
 Character ch = new Character(c);//自動裝箱

3.異同

(1).聲明方式不同，基本類型不適用new關鍵字，而包裝類型需要使用new關鍵字來在堆中分配存儲空間；
(2).存儲方式及位置不同，基本類型是直接將變量值存儲在堆棧中，而包裝類型是將對象放在堆中，然後通過引用來使用；
(3).初始值不同，基本類型的初始值如int爲0，boolean爲false，而包裝類型的初始值爲null

(4).使用方式不同，基本類型直接賦值直接使用就好，而包裝類型在集合如Collection、Map時會使用到

4.緩存池

new Integer(123) 每次都會新建一個對象，而 Integer.valueOf(123) 可能會使用緩存對象，因此多次使用 Integer.valueOf(123) 會取得同一個對象的引用。就好，而包裝類型在集合如Collection、Map時會使用到

Integer x = new Integer(123);
Integer y = new Integer(123);
System.out.println(x == y);    // false
Integer z = Integer.valueOf(123);
Integer k = Integer.valueOf(123);
System.out.println(z == k);   // true

編譯器會在自動裝箱過程調用 valueOf() 方法，因此多個 Integer 實例使用自動裝箱來創建並且值相同，那麼就會引用相同的對象。

Integer m = 123;
Integer n = 123;
System.out.println(m == n); // true

valueOf() 方法的實現比較簡單，就是先判斷值是否在緩存池中，如果在的話就直接使用緩存池的內容。

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

在 Java 8 中，Integer 緩存池的大小默認爲 -128~127。

static final int low = -128;
static final int high;
static final Integer cache[];

static {
    // high value may be configured by property
    int h = 127;
    String integerCacheHighPropValue =
        sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
    if (integerCacheHighPropValue != null) {
        try {
            int i = parseInt(integerCacheHighPropValue);
            i = Math.max(i, 127);
            // Maximum array size is Integer.MAX_VALUE
            h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
        } catch( NumberFormatException nfe) {
            // If the property cannot be parsed into an int, ignore it.
        }
    }
    high = h;

    cache = new Integer[(high - low) + 1];
    int j = low;
    for(int k = 0; k < cache.length; k++)
        cache[k] = new Integer(j++);

    // range [-128, 127] must be interned (JLS7 5.1.7)
    assert IntegerCache.high >= 127;
}

Java 還將一些其它基本類型的值放在緩衝池中，包含以下這些：

boolean values true and false
all byte values
short values between -128 and 127
int values between -128 and 127
char in the range \u0000 to \u007F

因此在使用這些基本類型對應的包裝類型時，就可以直接使用緩衝池中的對象。

二、String

String被聲明爲final，因此不可繼承。內部使用char數組存儲數據，該數組被聲明爲final，以爲着value數組初始化之後就不能再引用其他數組。並且String內部沒有改變value數組的方法，因此String不可變。

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

1.String不可變的好處

（1）可以緩存hash值

因爲 String 的 hash 值經常被使用，例如 String 用做 HashMap 的 key。不可變的特性可以使得 hash 值也不可變，因此只需要進行一次計算。

（2）String Pool 的需要

如果一個 String 對象已經被創建過了，那麼就會從 String Pool 中取得引用。只有 String 是不可變的，纔可能使用 String Pool。

（3）安全性

String經常作爲參數，String不可變性可以保證參數不可變。例如在作爲網絡連接參數的情況下如果 String 是可變的，那麼在網絡連接過程中，String 被改變，改變 String 對象的那一方以爲現在連接的是其它主機，而實際情況卻不一定是。

（4）線程安全

String 不可變性天生具備線程安全，可以在多個線程中安全地使用。

Program Creek : Why String is immutable in Java?

2.String,StringBuffer and StringBuilder

毫無疑問，這是個會在面試時經常出現的問題，一開始非常容易搞混。

（1）可變性

String不可變
StringBuffer和StringBuilder可變

（2）線程安全

String線程安全
StringBuilder非線程安全
StringBuffer線程安全,內部使用synchronized同步

 @Override
    public synchronized StringBuffer append(String str) {
        toStringCache = null;
        super.append(str);
        return this;
    }

StackOverflow : String, StringBuffer, and StringBuilder

3.String.intern()

使用 String.intern() 可以保證相同內容的字符串變量引用相同的內存對象。

下面示例中，s1 和 s2 採用 new String() 的方式新建了兩個不同對象，而 s3 是通過 s1.intern() 方法取得一個對象引用，這個方法首先把 s1 引用的對象放到 String Poll（字符串常量池）中，然後返回這個對象引用。因此 s3 和 s1 引用的是同一個字符串常量池的對象。

String s1 = new String("aaa");
String s2 = new String("aaa");
System.out.println(s1 == s2);           // false
String s3 = s1.intern();
System.out.println(s1.intern() == s3);  // true

如果是採用 "bbb" 這種使用雙引號的形式創建字符串實例，會自動地將新建的對象放入 String Poll 中。

String s4 = "bbb";
String s5 = "bbb";
System.out.println(s4 == s5);  // true

在 Java 7 之前，字符串常量池被放在運行時常量池中，它屬於永久代。而在 Java 7，字符串常量池被放在堆中。這是因爲永久代的空間有限，在大量使用字符串的場景下會導致 OutOfMemoryError 錯誤。

深入解析String#intern

三、運算

1.參數傳遞

Java 的參數是以值傳遞的形式傳入方法中，而不是引用傳遞。
Dog dog 的 dog 是一個指針，存儲的是對象的地址。在將一個參數傳入一個方法時，本質上是將對象的地址以值的方式傳遞到形參中。

StackOverflow: Is Java “pass-by-reference” or “pass-by-value”?

2.float與double

1.1字面量是double類型，不能直接將1.1直接賦值給float變量，因爲這是下轉型，會使得精度下降，因此Java不能隱式執行下轉型

float f=1.1

1.1f字面量纔是float類型

3.隱式類型轉換

因爲字面量 1 是 int 類型，它比 short 類型精度要高，因此不能隱式地將 int 類型下轉型爲 short 類型。

short s1 = 1;
// s1 = s1 + 1;

但是使用 += 運算符可以執行隱式類型轉換。

s1 += 1;

上面的語句相當於將 s1 + 1 的計算結果進行了向下轉型：

s1 = (short) (s1 + 1);

4.switch

從 Java 7 開始，可以在 switch 條件判斷語句中使用 String 對象。

String s = "a";
switch (s) {
    case "a":
        System.out.println("aaa");
        break;
    case "b":
        System.out.println("bbb");
        break;
}

switch 不支持 long，是因爲 switch 的設計初衷是爲那些只需要對少數的幾個值進行等值判斷，如果值過於複雜，那麼還是用 if 比較合適。

四、繼承

java中訪問權限修飾符：private、protected、public，如果不加訪問修飾符，表示包級可見。

protected 用於修飾成員，表示在繼承體系中成員對於子類可見，但是這個訪問修飾符對於類沒有意義。

設計良好的模塊會隱藏所有的實現細節，把它的 API 與它的實現清晰地隔離開來。模塊之間只通過它們的 API 進行通信，一個模塊不需要知道其他模塊的內部工作情況，這個概念被稱爲信息隱藏或封裝。因此訪問權限應當儘可能地使每個類或者成員不被外界訪問。
如果子類的方法覆蓋了父類的方法，那麼子類中該方法的訪問級別不允許低於父類的訪問級別。這是爲了確保可以使用父類實例的地方都可以使用子類實例，也就是確保滿足里氏替換原則。

字段決不能是公有的，因爲這麼做的話就失去了對這個字段修改行爲的控制，客戶端可以對其隨意修改。可以使用公有的 getter 和 setter 方法來替換公有字段。

public class AccessExample {
    public int x;
}

public class AccessExample {
    private int x;

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }
}

但是也有例外，如果是包級私有的類或者私有的嵌套類，那麼直接暴露成員不會有特別大的影響。

public class AccessWithInnerClassExample {
    private class InnerClass {
        int x;
    }

    private InnerClass innerClass;

    public AccessWithInnerClassExample() {
        innerClass = new InnerClass();
    }

    public int getValue() {
        return innerClass.x; // 直接訪問
    }
}

抽象類與接口

1.抽象類

抽象類和抽象方法都使用 abstract 進行聲明。抽象類一般會包含抽象方法，抽象方法一定位於抽象類中。
抽象類和普通類最大的區別是，抽象類不能被實例化，需要繼承抽象類才能實例化其子類。

2.接口

接口是抽象類的延伸，在 Java 8 之前，它可以看成是一個完全抽象的類，也就是說它不能有任何的方法實現。
從 Java 8 開始，接口也可以擁有默認的方法實現，這是因爲不支持默認方法的接口的維護成本太高了。在 Java 8 之前，如果一個接口想要添加新的方法，那麼要修改所有實現了該接口的類。
接口的成員（字段 + 方法）默認都是 public 的，並且不允許定義爲 private 或者 protected。
接口的字段默認都是 static 和 final 的。

3.比較

從設計層面上看，抽象類提供了一種 IS-A 關係，那麼就必須滿足裏式替換原則，即子類對象必須能夠替換掉所有父類對象。而接口更像是一種 LIKE-A 關係，它只是提供一種方法實現契約，並不要求接口和實現接口的類具有 IS-A 關係。
從使用上來看，一個類可以實現多個接口，但是不能繼承多個抽象類。
接口的字段只能是 static 和 final 類型的，而抽象類的字段沒有這種限制。

接口的方法只能是 public 的，而抽象類的方法可以有多種訪問權限。

4.使用選擇

使用抽象類：

需要在幾個相關的類中共享代碼。
需要能控制繼承來的方法和域的訪問權限，而不是都爲 public。
需要繼承非靜態（non-static）和非常量（non-final）字段。

使用接口：

需要讓不相關的類都實現一個方法，例如不相關的類都可以實現 Compareable 接口中的 compareTo() 方法；
需要使用多重繼承。

在很多情況下，接口優先於抽象類，因爲接口沒有抽象類嚴格的類層次結構要求，可以靈活地爲一個類添加行爲。並且從 Java 8 開始，接口也可以有默認的方法實現，使得修改接口的成本也變的很低。

深入理解 abstract class 和 interface

重寫與重載

重寫（Override）存在於繼承體系中，指子類實現了一個與父類在方法聲明上完全相同的一個方法；
重載（Overload）存在於同一個類中，指一個方法與已經存在的方法名稱上相同，但是參數類型、個數、順序至少有一個不同。應該注意的是，返回值不同，其它都相同不算是重載。

五、Object通用方法

概覽

public final native Class<?> getClass()

public native int hashCode()

public boolean equals(Object obj)

protected native Object clone() throws CloneNotSupportedException

public String toString()

public final native void notify()

public final native void notifyAll()

public final native void wait(long timeout) throws InterruptedException

public final void wait(long timeout, int nanos) throws InterruptedException

public final void wait() throws InterruptedException

protected void finalize() throws Throwable {}

1. equals() 與 == 的區別

對於基本類型，== 判斷兩個值是否相等，基本類型沒有 equals() 方法。
對於引用類型，== 判斷兩個實例是否引用同一個對象，而 equals() 判斷引用的對象是否等價。

2.hashCode()

hasCode() 返回散列值，而 equals() 是用來判斷兩個實例是否等價。等價的兩個實例散列值一定要相同，但是散列值相同的兩個實例不一定等價。

在覆蓋 equals() 方法時應當總是覆蓋 hashCode() 方法，保證等價的兩個實例散列值也相等。

下面的代碼中，新建了兩個等價的實例，並將它們添加到 HashSet 中。我們希望將這兩個實例當成一樣的，只在集合中添加一個實例，但是因爲 EqualExample 沒有實現 hasCode() 方法，因此這兩個實例的散列值是不同的，最終導致集合添加了兩個等價的實例。

EqualExample e1 = new EqualExample(1, 1, 1);
EqualExample e2 = new EqualExample(1, 1, 1);
System.out.println(e1.equals(e2)); // true
HashSet<EqualExample> set = new HashSet<>();
set.add(e1);
set.add(e2);
System.out.println(set.size());   // 2

理想的散列函數應當具有均勻性，即不相等的實例應當均勻分佈到所有可能的散列值上。這就要求了散列函數要把所有域的值都考慮進來，可以將每個域都當成 R 進制的某一位，然後組成一個 R 進制的整數。R 一般取 31，因爲它是一個奇素數，如果是偶數的話，當出現乘法溢出，信息就會丟失，因爲與 2 相乘相當於向左移一位。

一個數與 31 相乘可以轉換成移位和減法：31\*x == (x<<5)-x，編譯器會自動進行這個優化。

@Override
public int hashCode() {
    int result = 17;
    result = 31 * result + x;
    result = 31 * result + y;
    result = 31 * result + z;
    return result;
}

3.clone

clone() 方法並不是 Cloneable 接口的方法，而是 Object 的一個 protected 方法。Cloneable 接口只是規定，如果一個類沒有實現 Cloneable 接口又調用了 clone() 方法，就會拋出 CloneNotSupportedException。

淺拷貝：拷貝實例和原始實例的引用類型引用同一個對象；
深拷貝：拷貝實例和原始實例的引用類型引用不同對象。

六、關鍵字

final

1.數據

聲明數據爲常量，可以是編譯時常量，也可以是在運行時被初始化後不能被改變的常量。
對於基本類型，final 使數值不變；
對於引用類型，final 使引用不變，也就不能引用其它對象，但是被引用的對象本身是可以修改的。

2.方法

聲明方法不能被子類重寫。
private 方法隱式地被指定爲 final，如果在子類中定義的方法和基類中的一個 private 方法簽名相同，此時子類的方法不是重寫基類方法，而是在子類中定義了一個新的方法

3. 類

聲明類不允許被繼承。

static

1.靜態變量

靜態變量在內存中只存在一份，只在類初始化時賦值一次。

靜態變量：類所有的實例都共享靜態變量，可以直接通過類名來訪問它；

實例變量：每創建一個實例就會產生一個實例變量，它與該實例同生共死。

2.靜態方法

靜態方法在類加載的時候就存在了，它不依賴於任何實例，所以靜態方法必須有實現，也就是說它不能是抽象方法（abstract）。

public abstract class A {
    public static void func1(){
    }
    // public abstract static void func2();  // Illegal combination of modifiers: 'abstract' and 'static'
}

只能訪問所屬類的靜態字段和靜態方法，方法中不能有 this 和 super 關鍵字。

public class A {
    private static int x;
    private int y;

    public static void func1(){
        int a = x;
        // int b = y;  // Non-static field 'y' cannot be referenced from a static context
        // int b = this.y;     // 'A.this' cannot be referenced from a static context
    }
}

3.靜態語句塊

靜態語句塊在類初始化時運行一次。

public class A {
    static {
        System.out.println("123");
    }

    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new A();
    }
}

4. 靜態內部類

非靜態內部類依賴於需要外部類的實例，而靜態內部類不需要。

public class OuterClass {
    class InnerClass {
    }

    static class StaticInnerClass {
    }

    public static void main(String[] args) {
        // InnerClass innerClass = new InnerClass(); // 'OuterClass.this' cannot be referenced from a static context
        OuterClass outerClass = new OuterClass();
        InnerClass innerClass = outerClass.new InnerClass();
        StaticInnerClass staticInnerClass = new StaticInnerClass();
    }
}

靜態內部類不能訪問外部類的非靜態的變量和方法。

5.初始化順序

存在繼承的情況下，初始化順序爲：

父類（靜態變量、靜態語句塊）
子類（靜態變量、靜態語句塊）
父類（實例變量、普通語句塊）
父類（構造函數）
子類（實例變量、普通語句塊）
子類（構造函數）

七、反射

每個類都有一個 Class 對象，包含了與類有關的信息。當編譯一個新類時，會產生一個同名的 .class 文件，該文件內容保存着 Class 對象。

類加載相當於 Class 對象的加載。類在第一次使用時才動態加載到 JVM 中，可以使用 Class.forName("com.mysql.jdbc.Driver") 這種方式來控制類的加載，該方法會返回一個 Class 對象。

反射可以提供運行時的類信息，並且這個類可以在運行時才加載進來，甚至在編譯時期該類的 .class 不存在也可以加載進來。

Class 和 java.lang.reflect 一起對反射提供了支持，java.lang.reflect 類庫主要包含了以下三個類：

Field ：可以使用 get() 和 set() 方法讀取和修改 Field 對象關聯的字段；
Method ：可以使用 invoke() 方法調用與 Method 對象關聯的方法；
Constructor ：可以用 Constructor 創建新的對象。

Advantages of Using Reflection:

Extensibility Features : An application may make use of external, user-defined classes by creating instances of extensibility objects using their fully-qualified names.
Class Browsers and Visual Development Environments : A class browser needs to be able to enumerate the members of classes. Visual development environments can benefit from making use of type information available in reflection to aid the developer in writing correct code.
Debuggers and Test Tools : Debuggers need to be able to examine private members on classes. Test harnesses can make use of reflection to systematically call a discoverable set APIs defined on a class, to insure a high level of code coverage in a test suite.

Drawbacks of Reflection:

Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection.

Performance Overhead : Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in sections of code which are called frequently in performance-sensitive applications.
Security Restrictions : Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet.
Exposure of Internals :Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

深入解析 Java 反射（1）- 基礎

八、異常

Throwable 可以用來表示任何可以作爲異常拋出的類，分爲兩種： Error 和 Exception。其中 Error 用來表示 JVM 無法處理的錯誤，Exception 分爲兩種：

受檢異常：需要用 try...catch... 語句捕獲並進行處理，並且可以從異常中恢復；
非受檢異常：是程序運行時錯誤，例如除 0 會引發 Arithmetic Exception，此時程序奔潰並且無法恢復。

Java 異常的面試問題及答案 -Part 1

九、泛型

public class Box<T> {
    // T stands for "Type"
    private T t;
    public void set(T t) { this.t = t; }
    public T get() { return t; }
}

Java 泛型詳解

10 道 Java 泛型面試題

十、註解

Java 註解是附加在代碼中的一些元信息，用於一些工具在編譯、運行時進行解析和使用，起到說明、配置的功能。註解不會也不能影響代碼的實際邏輯，僅僅起到輔助性的作用。

註解 Annotation 實現原理與自定義註解例子

十一、特性

New highlights in Java SE 8

Lambda Expressions
Pipelines and Streams
Date and Time API
Default Methods
Type Annotations
Nashhorn JavaScript Engine
Concurrent Accumulators
Parallel operations
PermGen Error Removed

New highlights in Java SE 7

Strings in Switch Statement
Type Inference for Generic Instance Creation
Multiple Exception Handling
Support for Dynamic Languages
Try with Resources
Java nio Package
Binary Literals, Underscore in literals
Diamond Syntax

Java VS C++

Java 是純粹的面嚮對象語言，所有的對象都繼承自 java.lang.Object，C++ 爲了兼容 C 即支持面向對象也支持面向過程。
Java 通過虛擬機從而實現跨平臺特性，但是 C++ 依賴於特定的平臺。
Java 沒有指針，它的引用可以理解爲安全指針，而 C++ 具有和 C 一樣的指針。
Java 支持自動垃圾回收，而 C++ 需要手動回收。
Java 不支持多重繼承，只能通過實現多個接口來達到相同目的，而 C++ 支持多重繼承。
Java 不支持操作符重載，雖然可以對兩個 String 對象支持加法運算，但是這是語言內置支持的操作，不屬於操作符重載，而 C++ 可以。
Java 內置了線程的支持，而 C++ 需要依靠第三方庫。
Java 的 goto 是保留字，但是不可用，C++ 可以使用 goto。
Java 不支持條件編譯，C++ 通過 #ifdef #ifndef 等預處理命令從而實現條件編譯。

What are the main differences between Java and C++?

JRE or JDK

JRE is the JVM program, Java application need to run on JRE.
JDK is a superset of JRE, JRE + tools for developing java programs. e.g, it provides the compiler "javac"

參考資料

Eckel B. Java 編程思想[M]. 機械工業出版社, 2002.
Bloch J. Effective java[M]. Addison-Wesley Professional, 2017.