Java基礎(chǔ)知識(shí)：面試官必問的問題
數(shù)據(jù)類型
基本類型
? byte/8
? char/16
? short/16
? int/32
? float/32
? long/64
? double/64
? boolean/~
boolean 只有兩個(gè)值：true、false，可以使用 1 bit 來(lái)存儲(chǔ)，但是具體大小沒有明確規(guī)定。JVM 會(huì)在編譯時(shí)期將 boolean 類型的數(shù)據(jù)轉(zhuǎn)換為 int，使用 1 來(lái)表示 true，0 表示 false。JVM 支持 boolean 數(shù)組，但是是通過(guò)讀寫 byte 數(shù)組來(lái)實(shí)現(xiàn)的。
包裝類型
基本類型都有對(duì)應(yīng)的包裝類型，基本類型與其對(duì)應(yīng)的包裝類型之間的賦值使用自動(dòng)裝箱與拆箱完成。
Integer x = 2;? ? ?// 裝箱 調(diào)用了 Integer.valueOf(2)
int y = x;? ? ? ? ?// 拆箱 調(diào)用了 X.intValue()
緩存池
new Integer(123) 與 Integer.valueOf(123) 的區(qū)別在于：
? new Integer(123) 每次都會(huì)新建一個(gè)對(duì)象；
? Integer.valueOf(123) 會(huì)使用緩存池中的對(duì)象，多次調(diào)用會(huì)取得同一個(gè)對(duì)象的引用。
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() 方法的實(shí)現(xiàn)比較簡(jiǎn)單，就是先判斷值是否在緩存池中，如果在的話就直接返回緩存池的內(nèi)容。
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 緩存池的大小默認(rèn)為 -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;
}
編譯器會(huì)在自動(dòng)裝箱過(guò)程調(diào)用 valueOf() 方法，因此多個(gè)值相同且值在緩存池范圍內(nèi)的 Integer 實(shí)例使用自動(dòng)裝箱來(lái)創(chuàng)建，那么就會(huì)引用相同的對(duì)象。
Integer m = 123;
Integer n = 123;
System.out.println(m == n); // true
基本類型對(duì)應(yīng)的緩沖池如下：
? 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
在使用這些基本類型對(duì)應(yīng)的包裝類型時(shí)，如果該數(shù)值范圍在緩沖池范圍內(nèi)，就可以直接使用緩沖池中的對(duì)象。
在 jdk 1.8 所有的數(shù)值類緩沖池中，Integer 的緩沖池 IntegerCache 很特殊，這個(gè)緩沖池的下界是 - 128，上界默認(rèn)是 127，但是這個(gè)上界是可調(diào)的，在啟動(dòng) jvm 的時(shí)候，通過(guò) -XX:AutoBoxCacheMax= 來(lái)指定這個(gè)緩沖池的大小，該選項(xiàng)在 JVM 初始化的時(shí)候會(huì)設(shè)定一個(gè)名為 java.lang.IntegerCache.high 系統(tǒng)屬性，然后 IntegerCache 初始化的時(shí)候就會(huì)讀取該系統(tǒng)屬性來(lái)決定上界。
String
概覽
String 被聲明為 final，因此它不可被繼承。(Integer 等包裝類也不能被繼承）
在 Java 8 中，String 內(nèi)部使用 char 數(shù)組存儲(chǔ)數(shù)據(jù)。
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 類的實(shí)現(xiàn)改用 byte 數(shù)組存儲(chǔ)字符串，同時(shí)使用 coder 來(lái)標(biāo)識(shí)使用了哪種編碼。
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 數(shù)組被聲明為 final，這意味著 value 數(shù)組初始化之后就不能再引用其它數(shù)組。并且 String 內(nèi)部沒有改變 value 數(shù)組的方法，因此可以保證 String 不可變。
不可變的好處
1. 可以緩存 hash 值
因?yàn)?String 的 hash 值經(jīng)常被使用，例如 String 用做 HashMap 的 key。不可變的特性可以使得 hash 值也不可變，因此只需要進(jìn)行一次計(jì)算。
1. String Pool 的需要
如果一個(gè) String 對(duì)象已經(jīng)被創(chuàng)建過(guò)了，那么就會(huì)從 String Pool 中取得引用。只有 String 是不可變的，才可能使用 String Pool。
1. 安全性
String 經(jīng)常作為參數(shù)，String 不可變性可以保證參數(shù)不可變。例如在作為網(wǎng)絡(luò)連接參數(shù)的情況下如果 String 是可變的，那么在網(wǎng)絡(luò)連接過(guò)程中，String 被改變，改變 String 的那一方以為現(xiàn)在連接的是其它主機(jī)，而實(shí)際情況卻不一定是。
1. 線程安全
String 不可變性天生具備線程安全，可以在多個(gè)線程中安全地使用。
String, StringBuffer and StringBuilder
1. 可變性
? String 不可變
? StringBuffer 和 StringBuilder 可變
1. 線程安全
? String 不可變，因此是線程安全的
? StringBuilder 不是線程安全的
? StringBuffer 是線程安全的，內(nèi)部使用 synchronized 進(jìn)行同步
String Pool
字符串常量池（String Pool）保存著所有字符串字面量（literal strings），這些字面量在編譯時(shí)期就確定。不僅如此，還可以使用 String 的 intern() 方法在運(yùn)行過(guò)程將字符串添加到 String Pool 中。
當(dāng)一個(gè)字符串調(diào)用 intern() 方法時(shí)，如果 String Pool 中已經(jīng)存在一個(gè)字符串和該字符串值相等（使用 equals() 方法進(jìn)行確定），那么就會(huì)返回 String Pool 中字符串的引用；否則，就會(huì)在 String Pool 中添加一個(gè)新的字符串，并返回這個(gè)新字符串的引用。
下面示例中，s1 和 s2 采用 new String() 的方式新建了兩個(gè)不同字符串，而 s3 和 s4 是通過(guò) s1.intern() 和 s2.intern() 方法取得同一個(gè)字符串引用。intern() 首先把 "aaa" 放到 String Pool 中，然后返回這個(gè)字符串引用，因此 s3 和 s4 引用的是同一個(gè)字符串。
String s1 = new String("aaa");
String s2 = new String("aaa");
System.out.println(s1 == s2);? ? ? ? ? ?// false
String s3 = s1.intern();
String s4 = s2.intern();
System.out.println(s3 == s4);? ? ? ? ? ?// true
如果是采用 "bbb" 這種字面量的形式創(chuàng)建字符串，會(huì)自動(dòng)地將字符串放入 String Pool 中。
String s5 = "bbb";
String s6 = "bbb";
System.out.println(s5 == s6);? // true
在 Java 7 之前，String Pool 被放在運(yùn)行時(shí)常量池中，它屬于永久代。而在 Java 7，String Pool 被移到堆中。這是因?yàn)橛谰么目臻g有限，在大量使用字符串的場(chǎng)景下會(huì)導(dǎo)致 OutOfMemoryError 錯(cuò)誤。
new String("abc")
使用這種方式一共會(huì)創(chuàng)建兩個(gè)字符串對(duì)象（前提是 String Pool 中還沒有 "abc" 字符串對(duì)象）。
? "abc" 屬于字符串字面量，因此編譯時(shí)期會(huì)在 String Pool 中創(chuàng)建一個(gè)字符串對(duì)象，指向這個(gè) "abc" 字符串字面量；
? 而使用 new 的方式會(huì)在堆中創(chuàng)建一個(gè)字符串對(duì)象。
創(chuàng)建一個(gè)測(cè)試類，其 main 方法中使用這種方式來(lái)創(chuàng)建字符串對(duì)象。
public class NewStringTest {
? ? public static void main(String[] args) {
? ? ? ? String s = new String("abc");
? ? }
}
使用 javap -verbose 進(jìn)行反編譯，得到以下內(nèi)容：
// ...
Constant pool:
// ...
? ?#2 = Class? ? ? ? ? ? ? #18? ? ? ? ? ? // java/lang/String
? ?#3 = String? ? ? ? ? ? ?#19? ? ? ? ? ? // abc
// ...
? #18 = Utf8? ? ? ? ? ? ? ?java/lang/String
? #19 = Utf8? ? ? ? ? ? ? ?abc
// ...
? public static void main(java.lang.String[]);
? ? descriptor: ([Ljava/lang/String;)V
? ? flags: ACC_PUBLIC, ACC_STATIC
? ? Code:
? ? ? stack=3, locals=2, args_size=1
? ? ? ? ?0: new? ? ? ? ? ?#2? ? ? ? ? ? ? ? ? // class java/lang/String
? ? ? ? ?3: dup
? ? ? ? ?4: ldc? ? ? ? ? ?#3? ? ? ? ? ? ? ? ? // String abc
? ? ? ? ?6: invokespecial #4? ? ? ? ? ? ? ? ? // Method java/lang/String."<init>":(Ljava/lang/String;)V
? ? ? ? ?9: astore_1
// ...
在 Constant Pool 中，#19 存儲(chǔ)這字符串字面量 "abc"，#3 是 String Pool 的字符串對(duì)象，它指向 #19 這個(gè)字符串字面量。在 main 方法中，0: 行使用 new #2 在堆中創(chuàng)建一個(gè)字符串對(duì)象，并且使用 ldc #3 將 String Pool 中的字符串對(duì)象作為 String 構(gòu)造函數(shù)的參數(shù)。
以下是 String 構(gòu)造函數(shù)的源碼，可以看到，在將一個(gè)字符串對(duì)象作為另一個(gè)字符串對(duì)象的構(gòu)造函數(shù)參數(shù)時(shí)，并不會(huì)完全復(fù)制 value 數(shù)組內(nèi)容，而是都會(huì)指向同一個(gè) value 數(shù)組。
public String(String original) {
? ? this.value = original.value;
? ? this.hash = original.hash;
}
運(yùn)算
參數(shù)傳遞
Java 的參數(shù)是以值傳遞的形式傳入方法中，而不是引用傳遞。
以下代碼中 Dog dog 的 dog 是一個(gè)指針，存儲(chǔ)的是對(duì)象的地址。在將一個(gè)參數(shù)傳入一個(gè)方法時(shí)，本質(zhì)上是將對(duì)象的地址以值的方式傳遞到形參中。
public class Dog {
? ? String name;
? ? Dog(String name) {
? ? ? ? this.name = name;
? ? }
? ? String getName() {
? ? ? ? return this.name;
? ? }
? ? void setName(String name) {
? ? ? ? this.name = name;
? ? }
? ? String getObjectAddress() {
? ? ? ? return super.toString();
? ? }
}
在方法中改變對(duì)象的字段值會(huì)改變?cè)瓕?duì)象該字段值，因?yàn)橐玫氖峭粋€(gè)對(duì)象。
class PassByValueExample {
? ? public static void main(String[] args) {
? ? ? ? Dog dog = new Dog("A");
? ? ? ? func(dog);
? ? ? ? System.out.println(dog.getName());? ? ? ? ? // B
? ? }
? ? private static void func(Dog dog) {
? ? ? ? dog.setName("B");
? ? }
}
但是在方法中將指針引用了其它對(duì)象，那么此時(shí)方法里和方法外的兩個(gè)指針指向了不同的對(duì)象，在一個(gè)指針改變其所指向?qū)ο蟮膬?nèi)容對(duì)另一個(gè)指針?biāo)赶虻膶?duì)象沒有影響。
public class PassByValueExample {
? ? public static void main(String[] args) {
? ? ? ? Dog dog = new Dog("A");
? ? ? ? System.out.println(dog.getObjectAddress()); // Dog@4554617c
? ? ? ? func(dog);
? ? ? ? System.out.println(dog.getObjectAddress()); // Dog@4554617c
? ? ? ? System.out.println(dog.getName());? ? ? ? ? // A
? ? }
? ? private static void func(Dog dog) {
? ? ? ? System.out.println(dog.getObjectAddress()); // Dog@4554617c
? ? ? ? dog = new Dog("B");
? ? ? ? System.out.println(dog.getObjectAddress()); // Dog@74a14482
? ? ? ? System.out.println(dog.getName());? ? ? ? ? // B
? ? }
}
float 與 double
Java 不能隱式執(zhí)行向下轉(zhuǎn)型，因?yàn)檫@會(huì)使得精度降低。
1.1 字面量屬于 double 類型，不能直接將 1.1 直接賦值給 float 變量，因?yàn)檫@是向下轉(zhuǎn)型。
// float f = 1.1;
1.1f 字面量才是 float 類型。
float f = 1.1f;
隱式類型轉(zhuǎn)換
因?yàn)樽置媪?1 是 int 類型，它比 short 類型精度要高，因此不能隱式地將 int 類型向下轉(zhuǎn)型為 short 類型。
short s1 = 1;
// s1 = s1 + 1;
但是使用 += 或者 ++ 運(yùn)算符會(huì)執(zhí)行隱式類型轉(zhuǎn)換。
s1 += 1;
s1++;
上面的語(yǔ)句相當(dāng)于將 s1 + 1 的計(jì)算結(jié)果進(jìn)行了向下轉(zhuǎn)型：
s1 = (short) (s1 + 1);
switch
從 Java 7 開始，可以在 switch 條件判斷語(yǔ)句中使用 String 對(duì)象。
String s = "a";
switch (s) {
? ? case "a":
? ? ? ? System.out.println("aaa");
? ? ? ? break;
? ? case "b":
? ? ? ? System.out.println("bbb");
? ? ? ? break;
}
switch 不支持 long、float、double，是因?yàn)?switch 的設(shè)計(jì)初衷是對(duì)那些只有少數(shù)幾個(gè)值的類型進(jìn)行等值判斷，如果值過(guò)于復(fù)雜，那么還是用 if 比較合適。
// long x = 111;
// switch (x) { // Incompatible types. Found: 'long', required: 'char, byte, short, int, Character, Byte, Short, Integer, String, or an enum'
//? ? ?case 111:
//? ? ? ? ?System.out.println(111);
//? ? ? ? ?break;
//? ? ?case 222:
//? ? ? ? ?System.out.println(222);
//? ? ? ? ?break;
// }
關(guān)鍵字
final
1. 數(shù)據(jù)
聲明數(shù)據(jù)為常量，可以是編譯時(shí)常量，也可以是在運(yùn)行時(shí)被初始化后不能被改變的常量。
? 對(duì)于基本類型，final 使數(shù)值不變；
? 對(duì)于引用類型，final 使引用不變，也就不能引用其它對(duì)象，但是被引用的對(duì)象本身是可以修改的。
final int x = 1;
// x = 2;? // cannot assign value to final variable 'x'
final A y = new A();
y.a = 1;
1. 方法
聲明方法不能被子類重寫。
private 方法隱式地被指定為 final，如果在子類中定義的方法和基類中的一個(gè) private 方法簽名相同，此時(shí)子類的方法不是重寫基類方法，而是在子類中定義了一個(gè)新的方法。
1. 類
聲明類不允許被繼承。
static
1. 靜態(tài)變量
? 靜態(tài)變量：又稱為類變量，也就是說(shuō)這個(gè)變量屬于類的，類所有的實(shí)例都共享靜態(tài)變量，可以直接通過(guò)類名來(lái)訪問它。靜態(tài)變量在內(nèi)存中只存在一份。
? 實(shí)例變量：每創(chuàng)建一個(gè)實(shí)例就會(huì)產(chǎn)生一個(gè)實(shí)例變量，它與該實(shí)例同生共死。
public class A {
? ? private int x;? ? ? ? ?// 實(shí)例變量
? ? private static int y;? // 靜態(tài)變量
? ? public static void main(String[] args) {
? ? ? ? // int x = A.x;? // Non-static field 'x' cannot be referenced from a static context
? ? ? ? A a = new A();
? ? ? ? int x = a.x;
? ? ? ? int y = A.y;
? ? }
}
1. 靜態(tài)方法
靜態(tài)方法在類加載的時(shí)候就存在了，它不依賴于任何實(shí)例。所以靜態(tài)方法必須有實(shí)現(xiàn)，也就是說(shuō)它不能是抽象方法。
public abstract class A {
? ? public static void func1(){
? ? }
? ? // public abstract static void func2();? // Illegal combination of modifiers: 'abstract' and 'static'
}
只能訪問所屬類的靜態(tài)字段和靜態(tài)方法，方法中不能有 this 和 super 關(guān)鍵字，因?yàn)檫@兩個(gè)關(guān)鍵字與具體對(duì)象關(guān)聯(lián)。
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
? ? }
}
1. 靜態(tài)語(yǔ)句塊
靜態(tài)語(yǔ)句塊在類初始化時(shí)運(yùn)行一次。
public class A {
? ? static {
? ? ? ? System.out.println("123");
? ? }
? ? public static void main(String[] args) {
? ? ? ? A a1 = new A();
? ? ? ? A a2 = new A();
? ? }
}
1. 靜態(tài)內(nèi)部類
非靜態(tài)內(nèi)部類依賴于外部類的實(shí)例，也就是說(shuō)需要先創(chuàng)建外部類實(shí)例，才能用這個(gè)實(shí)例去創(chuàng)建非靜態(tài)內(nèi)部類。而靜態(tài)內(nèi)部類不需要。
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();
? ? }
}
靜態(tài)內(nèi)部類不能訪問外部類的非靜態(tài)的變量和方法。
1. 靜態(tài)導(dǎo)包
在使用靜態(tài)變量和方法時(shí)不用再指明 ClassName，從而簡(jiǎn)化代碼，但可讀性大大降低。
import static com.xxx.ClassName.*
1. 初始化順序
靜態(tài)變量和靜態(tài)語(yǔ)句塊優(yōu)先于實(shí)例變量和普通語(yǔ)句塊，靜態(tài)變量和靜態(tài)語(yǔ)句塊的初始化順序取決于它們?cè)诖a中的順序。
public static String staticField = "靜態(tài)變量";
static {
? ? System.out.println("靜態(tài)語(yǔ)句塊");
}
public String field = "實(shí)例變量";
{
? ? System.out.println("普通語(yǔ)句塊");
}
最后才是構(gòu)造函數(shù)的初始化。
public InitialOrderTest() {
? ? System.out.println("構(gòu)造函數(shù)");
}
存在繼承的情況下，初始化順序?yàn)椋?/p>
? 父類（靜態(tài)變量、靜態(tài)語(yǔ)句塊）
? 子類（靜態(tài)變量、靜態(tài)語(yǔ)句塊）
? 父類（實(shí)例變量、普通語(yǔ)句塊）
? 父類（構(gòu)造函數(shù)）
? 子類（實(shí)例變量、普通語(yǔ)句塊）
? 子類（構(gòu)造函數(shù)）
Object 通用方法
概覽
public native int hashCode()
public boolean equals(Object obj)
protected native Object clone() throws CloneNotSupportedException
public String toString()
public final native Class<?> getClass()
protected void finalize() throws Throwable {}
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
equals()
等價(jià)關(guān)系，兩個(gè)對(duì)象具有等價(jià)關(guān)系，需要滿足以下五個(gè)條件：
1. 自反性
x.equals(x); // true
1. 對(duì)稱性
x.equals(y) == y.equals(x); // true
1. 傳遞性
if (x.equals(y) && y.equals(z))
? ? x.equals(z); // true;
1. 一致性
多次調(diào)用 equals() 方法結(jié)果不變
x.equals(y) == x.equals(y); // true
1. 與 null 的比較
對(duì)任何不是 null 的對(duì)象 x 調(diào)用 x.equals(null) 結(jié)果都為 false
x.equals(null); // false;
等價(jià)與相等
? 對(duì)于基本類型，== 判斷兩個(gè)值是否相等，基本類型沒有 equals() 方法。
? 對(duì)于引用類型，== 判斷兩個(gè)變量是否引用同一個(gè)對(duì)象，而 equals() 判斷引用的對(duì)象是否等價(jià)。
Integer x = new Integer(1);
Integer y = new Integer(1);
System.out.println(x.equals(y)); // true
System.out.println(x == y);? ? ? // false
實(shí)現(xiàn)
? 檢查是否為同一個(gè)對(duì)象的引用，如果是直接返回 true；
? 檢查是否是同一個(gè)類型，如果不是，直接返回 false；
? 將 Object 對(duì)象進(jìn)行轉(zhuǎn)型；
? 判斷每個(gè)關(guān)鍵域是否相等。
public class EqualExample {
? ? private int x;
? ? private int y;
? ? private int z;
? ? public EqualExample(int x, int y, int z) {
? ? ? ? this.x = x;
? ? ? ? this.y = y;
? ? ? ? this.z = z;
? ? }
? ? @Override
? ? public boolean equals(Object o) {
? ? ? ? if (this == o) return true;
? ? ? ? if (o == null || getClass() != o.getClass()) return false;
? ? ? ? EqualExample that = (EqualExample) o;
? ? ? ? if (x != that.x) return false;
? ? ? ? if (y != that.y) return false;
? ? ? ? return z == that.z;
? ? }
}
hashCode()
hashCode() 返回哈希值，而 equals() 是用來(lái)判斷兩個(gè)對(duì)象是否等價(jià)。等價(jià)的兩個(gè)對(duì)象散列值一定相同，但是散列值相同的兩個(gè)對(duì)象不一定等價(jià)，這是因?yàn)橛?jì)算哈希值具有隨機(jī)性，兩個(gè)值不同的對(duì)象可能計(jì)算出相同的哈希值。
在覆蓋 equals() 方法時(shí)應(yīng)當(dāng)總是覆蓋 hashCode() 方法，保證等價(jià)的兩個(gè)對(duì)象哈希值也相等。
HashSet 和 HashMap 等集合類使用了 hashCode() 方法來(lái)計(jì)算對(duì)象應(yīng)該存儲(chǔ)的位置，因此要將對(duì)象添加到這些集合類中，需要讓對(duì)應(yīng)的類實(shí)現(xiàn) hashCode() 方法。
下面的代碼中，新建了兩個(gè)等價(jià)的對(duì)象，并將它們添加到 HashSet 中。我們希望將這兩個(gè)對(duì)象當(dāng)成一樣的，只在集合中添加一個(gè)對(duì)象。但是 EqualExample 沒有實(shí)現(xiàn) hashCode() 方法，因此這兩個(gè)對(duì)象的哈希值是不同的，最終導(dǎo)致集合添加了兩個(gè)等價(jià)的對(duì)象。
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
理想的哈希函數(shù)應(yīng)當(dāng)具有均勻性，即不相等的對(duì)象應(yīng)當(dāng)均勻分布到所有可能的哈希值上。這就要求了哈希函數(shù)要把所有域的值都考慮進(jìn)來(lái)。可以將每個(gè)域都當(dāng)成 R 進(jìn)制的某一位，然后組成一個(gè) R 進(jìn)制的整數(shù)。
R 一般取 31，因?yàn)樗且粋€(gè)奇素?cái)?shù)，如果是偶數(shù)的話，當(dāng)出現(xiàn)乘法溢出，信息就會(huì)丟失，因?yàn)榕c 2 相乘相當(dāng)于向左移一位，最左邊的位丟失。并且一個(gè)數(shù)與 31 相乘可以轉(zhuǎn)換成移位和減法：31*x == (x<<5)-x，編譯器會(huì)自動(dòng)進(jìn)行這個(gè)優(yōu)化。
@Override
public int hashCode() {
? ? int result = 17;
? ? result = 31 * result + x;
? ? result = 31 * result + y;
? ? result = 31 * result + z;
? ? return result;
}
toString()
默認(rèn)返回 ToStringExample@4554617c 這種形式，其中 @ 后面的數(shù)值為散列碼的無(wú)符號(hào)十六進(jìn)制表示。
public class ToStringExample {
? ? private int number;
? ? public ToStringExample(int number) {
? ? ? ? this.number = number;
? ? }
}
ToStringExample example = new ToStringExample(123);
System.out.println(example.toString());
ToStringExample@4554617c
clone()
1. cloneable
clone() 是 Object 的 protected 方法，它不是 public，一個(gè)類不顯式去重寫 clone()，其它類就不能直接去調(diào)用該類實(shí)例的 clone() 方法。
public class CloneExample {
? ? private int a;
? ? private int b;
}
CloneExample e1 = new CloneExample();
// CloneExample e2 = e1.clone(); // 'clone()' has protected access in 'java.lang.Object'
重寫 clone() 得到以下實(shí)現(xiàn)：
public class CloneExample {
? ? private int a;
? ? private int b;
? ? @Override
? ? public CloneExample clone() throws CloneNotSupportedException {
? ? ? ? return (CloneExample)super.clone();
? ? }
}
CloneExample e1 = new CloneExample();
try {
? ? CloneExample e2 = e1.clone();
} catch (CloneNotSupportedException e) {
? ? e.printStackTrace();
}
java.lang.CloneNotSupportedException: CloneExample
以上拋出了 CloneNotSupportedException，這是因?yàn)?CloneExample 沒有實(shí)現(xiàn) Cloneable 接口。
應(yīng)該注意的是，clone() 方法并不是 Cloneable 接口的方法，而是 Object 的一個(gè) protected 方法。Cloneable 接口只是規(guī)定，如果一個(gè)類沒有實(shí)現(xiàn) Cloneable 接口又調(diào)用了 clone() 方法，就會(huì)拋出 CloneNotSupportedException。
public class CloneExample implements Cloneable {
? ? private int a;
? ? private int b;
? ? @Override
? ? public Object clone() throws CloneNotSupportedException {
? ? ? ? return super.clone();
? ? }
}
1. 淺拷貝
拷貝對(duì)象和原始對(duì)象的引用類型引用同一個(gè)對(duì)象。
public class ShallowCloneExample implements Cloneable {
? ? private int[] arr;
? ? public ShallowCloneExample() {
? ? ? ? arr = new int[10];
? ? ? ? for (int i = 0; i < arr.length; i++) {
? ? ? ? ? ? arr[i] = i;
? ? ? ? }
? ? }
? ? public void set(int index, int value) {
? ? ? ? arr[index] = value;
? ? }
? ? public int get(int index) {
? ? ? ? return arr[index];
? ? }
? ? @Override
? ? protected ShallowCloneExample clone() throws CloneNotSupportedException {
? ? ? ? return (ShallowCloneExample) super.clone();
? ? }
}
ShallowCloneExample e1 = new ShallowCloneExample();
ShallowCloneExample e2 = null;
try {
? ? e2 = e1.clone();
} catch (CloneNotSupportedException e) {
? ? e.printStackTrace();
}
e1.set(2, 222);
System.out.println(e2.get(2)); // 222
1. 深拷貝
拷貝對(duì)象和原始對(duì)象的引用類型引用不同對(duì)象。
public class DeepCloneExample implements Cloneable {
? ? private int[] arr;
? ? public DeepCloneExample() {
? ? ? ? arr = new int[10];
? ? ? ? for (int i = 0; i < arr.length; i++) {
? ? ? ? ? ? arr[i] = i;
? ? ? ? }
? ? }
? ? public void set(int index, int value) {
? ? ? ? arr[index] = value;
? ? }
? ? public int get(int index) {
? ? ? ? return arr[index];
? ? }
? ? @Override
? ? protected DeepCloneExample clone() throws CloneNotSupportedException {
? ? ? ? DeepCloneExample result = (DeepCloneExample) super.clone();
? ? ? ? result.arr = new int[arr.length];
? ? ? ? for (int i = 0; i < arr.length; i++) {
? ? ? ? ? ? result.arr[i] = arr[i];
? ? ? ? }
? ? ? ? return result;
? ? }
}
DeepCloneExample e1 = new DeepCloneExample();
DeepCloneExample e2 = null;
try {
? ? e2 = e1.clone();
} catch (CloneNotSupportedException e) {
? ? e.printStackTrace();
}
e1.set(2, 222);
System.out.println(e2.get(2)); // 2
1. clone() 的替代方案
使用 clone() 方法來(lái)拷貝一個(gè)對(duì)象即復(fù)雜又有風(fēng)險(xiǎn)，它會(huì)拋出異常，并且還需要類型轉(zhuǎn)換。Effective Java 書上講到，最好不要去使用 clone()，可以使用拷貝構(gòu)造函數(shù)或者拷貝工廠來(lái)拷貝一個(gè)對(duì)象。
public class CloneConstructorExample {
? ? private int[] arr;
? ? public CloneConstructorExample() {
? ? ? ? arr = new int[10];
? ? ? ? for (int i = 0; i < arr.length; i++) {
? ? ? ? ? ? arr[i] = i;
? ? ? ? }
? ? }
? ? public CloneConstructorExample(CloneConstructorExample original) {
? ? ? ? arr = new int[original.arr.length];
? ? ? ? for (int i = 0; i < original.arr.length; i++) {
? ? ? ? ? ? arr[i] = original.arr[i];
? ? ? ? }
? ? }
? ? public void set(int index, int value) {
? ? ? ? arr[index] = value;
? ? }
? ? public int get(int index) {
? ? ? ? return arr[index];
? ? }
}
CloneConstructorExample e1 = new CloneConstructorExample();
CloneConstructorExample e2 = new CloneConstructorExample(e1);
e1.set(2, 222);
System.out.println(e2.get(2)); // 2
繼承
訪問權(quán)限
Java 中有三個(gè)訪問權(quán)限修飾符：private、protected 以及 public，如果不加訪問修飾符，表示包級(jí)可見。
可以對(duì)類或類中的成員（字段和方法）加上訪問修飾符。
? 類可見表示其它類可以用這個(gè)類創(chuàng)建實(shí)例對(duì)象。
? 成員可見表示其它類可以用這個(gè)類的實(shí)例對(duì)象訪問到該成員；
protected 用于修飾成員，表示在繼承體系中成員對(duì)于子類可見，但是這個(gè)訪問修飾符對(duì)于類沒有意義。
設(shè)計(jì)良好的模塊會(huì)隱藏所有的實(shí)現(xiàn)細(xì)節(jié)，把它的 API 與它的實(shí)現(xiàn)清晰地隔離開來(lái)。模塊之間只通過(guò)它們的 API 進(jìn)行通信，一個(gè)模塊不需要知道其他模塊的內(nèi)部工作情況，這個(gè)概念被稱為信息隱藏或封裝。因此訪問權(quán)限應(yīng)當(dāng)盡可能地使每個(gè)類或者成員不被外界訪問。
如果子類的方法重寫了父類的方法，那么子類中該方法的訪問級(jí)別不允許低于父類的訪問級(jí)別。這是為了確?？梢允褂酶割悓?shí)例的地方都可以使用子類實(shí)例去代替，也就是確保滿足里氏替換原則。
字段決不能是公有的，因?yàn)檫@么做的話就失去了對(duì)這個(gè)字段修改行為的控制，客戶端可以對(duì)其隨意修改。例如下面的例子中，AccessExample 擁有 id 公有字段，如果在某個(gè)時(shí)刻，我們想要使用 int 存儲(chǔ) id 字段，那么就需要修改所有的客戶端代碼。
public class AccessExample {
? ? public String id;
}
可以使用公有的 getter 和 setter 方法來(lái)替換公有字段，這樣的話就可以控制對(duì)字段的修改行為。
public class AccessExample {
? ? private int id;
? ? public String getId() {
? ? ? ? return id + "";
? ? }
? ? public void setId(String id) {
? ? ? ? this.id = Integer.valueOf(id);
? ? }
}
但是也有例外，如果是包級(jí)私有的類或者私有的嵌套類，那么直接暴露成員不會(huì)有特別大的影響。
public class AccessWithInnerClassExample {
? ? private class InnerClass {
? ? ? ? int x;
? ? }
? ? private InnerClass innerClass;
? ? public AccessWithInnerClassExample() {
? ? ? ? innerClass = new InnerClass();
? ? }
? ? public int getValue() {
? ? ? ? return innerClass.x;? // 直接訪問
? ? }
}
抽象類與接口
1. 抽象類
抽象類和抽象方法都使用 abstract 關(guān)鍵字進(jìn)行聲明。如果一個(gè)類中包含抽象方法，那么這個(gè)類必須聲明為抽象類。
抽象類和普通類最大的區(qū)別是，抽象類不能被實(shí)例化，只能被繼承。
public abstract class AbstractClassExample {
? ? protected int x;
? ? private int y;
? ? public abstract void func1();
? ? public void func2() {
? ? ? ? System.out.println("func2");
? ? }
}
public class AbstractExtendClassExample extends AbstractClassExample {
? ? @Override
? ? public void func1() {
? ? ? ? System.out.println("func1");
? ? }
}
// AbstractClassExample ac1 = new AbstractClassExample(); // 'AbstractClassExample' is abstract; cannot be instantiated
AbstractClassExample ac2 = new AbstractExtendClassExample();
ac2.func1();
1. 接口
接口是抽象類的延伸，在 Java 8 之前，它可以看成是一個(gè)完全抽象的類，也就是說(shuō)它不能有任何的方法實(shí)現(xiàn)。
從 Java 8 開始，接口也可以擁有默認(rèn)的方法實(shí)現(xiàn)，這是因?yàn)椴恢С帜J(rèn)方法的接口的維護(hù)成本太高了。在 Java 8 之前，如果一個(gè)接口想要添加新的方法，那么要修改所有實(shí)現(xiàn)了該接口的類，讓它們都實(shí)現(xiàn)新增的方法。
接口的成員（字段 + 方法）默認(rèn)都是 public 的，并且不允許定義為 private 或者 protected。從 Java 9 開始，允許將方法定義為 private，這樣就能定義某些復(fù)用的代碼又不會(huì)把方法暴露出去。
接口的字段默認(rèn)都是 static 和 final 的。
public interface InterfaceExample {
? ? void func1();
? ? default void func2(){
? ? ? ? System.out.println("func2");
? ? }
? ? int x = 123;
? ? // int y;? ? ? ? ? ? ? ?// Variable 'y' might not have been initialized
? ? public int z = 0;? ? ? ?// Modifier 'public' is redundant for interface fields
? ? // private int k = 0;? ?// Modifier 'private' not allowed here
? ? // protected int l = 0; // Modifier 'protected' not allowed here
? ? // private void fun3(); // Modifier 'private' not allowed here
}
public class InterfaceImplementExample implements InterfaceExample {
? ? @Override
? ? public void func1() {
? ? ? ? System.out.println("func1");
? ? }
}
// InterfaceExample ie1 = new InterfaceExample(); // 'InterfaceExample' is abstract; cannot be instantiated
InterfaceExample ie2 = new InterfaceImplementExample();
ie2.func1();
System.out.println(InterfaceExample.x);
1. 比較
? 從設(shè)計(jì)層面上看，抽象類提供了一種 IS-A 關(guān)系，需要滿足里式替換原則，即子類對(duì)象必須能夠替換掉所有父類對(duì)象。而接口更像是一種 LIKE-A 關(guān)系，它只是提供一種方法實(shí)現(xiàn)契約，并不要求接口和實(shí)現(xiàn)接口的類具有 IS-A 關(guān)系。
? 從使用上來(lái)看，一個(gè)類可以實(shí)現(xiàn)多個(gè)接口，但是不能繼承多個(gè)抽象類。
? 接口的字段只能是 static 和 final 類型的，而抽象類的字段沒有這種限制。
? 接口的成員只能是 public 的，而抽象類的成員可以有多種訪問權(quán)限。
1. 使用選擇
使用接口：
? 需要讓不相關(guān)的類都實(shí)現(xiàn)一個(gè)方法，例如不相關(guān)的類都可以實(shí)現(xiàn) Comparable 接口中的 compareTo() 方法；
? 需要使用多重繼承。
使用抽象類：
? 需要在幾個(gè)相關(guān)的類中共享代碼。
? 需要能控制繼承來(lái)的成員的訪問權(quán)限，而不是都為 public。
? 需要繼承非靜態(tài)和非常量字段。
在很多情況下，接口優(yōu)先于抽象類。因?yàn)榻涌跊]有抽象類嚴(yán)格的類層次結(jié)構(gòu)要求，可以靈活地為一個(gè)類添加行為。并且從 Java 8 開始，接口也可以有默認(rèn)的方法實(shí)現(xiàn)，使得修改接口的成本也變的很低。
super
? 訪問父類的構(gòu)造函數(shù)：可以使用 super() 函數(shù)訪問父類的構(gòu)造函數(shù)，從而委托父類完成一些初始化的工作。應(yīng)該注意到，子類一定會(huì)調(diào)用父類的構(gòu)造函數(shù)來(lái)完成初始化工作，一般是調(diào)用父類的默認(rèn)構(gòu)造函數(shù)，如果子類需要調(diào)用父類其它構(gòu)造函數(shù)，那么就可以使用 super() 函數(shù)。
? 訪問父類的成員：如果子類重寫了父類的某個(gè)方法，可以通過(guò)使用 super 關(guān)鍵字來(lái)引用父類的方法實(shí)現(xiàn)。
public class SuperExample {
? ? protected int x;
? ? protected int y;
? ? public SuperExample(int x, int y) {
? ? ? ? this.x = x;
? ? ? ? this.y = y;
? ? }
? ? public void func() {
? ? ? ? System.out.println("SuperExample.func()");
? ? }
}
public class SuperExtendExample extends SuperExample {
? ? private int z;
? ? public SuperExtendExample(int x, int y, int z) {
? ? ? ? super(x, y);
? ? ? ? this.z = z;
? ? }
? ? @Override
? ? public void func() {
? ? ? ? super.func();
? ? ? ? System.out.println("SuperExtendExample.func()");
? ? }
}
SuperExample e = new SuperExtendExample(1, 2, 3);
e.func();
SuperExample.func()
SuperExtendExample.func()
重寫與重載
1. 重寫（Override）
存在于繼承體系中，指子類實(shí)現(xiàn)了一個(gè)與父類在方法聲明上完全相同的一個(gè)方法。
為了滿足里式替換原則，重寫有以下三個(gè)限制：
? 子類方法的訪問權(quán)限必須大于等于父類方法；
? 子類方法的返回類型必須是父類方法返回類型或?yàn)槠渥宇愋汀?/p>
? 子類方法拋出的異常類型必須是父類拋出異常類型或?yàn)槠渥宇愋汀?/p>
使用 @Override 注解，可以讓編譯器幫忙檢查是否滿足上面的三個(gè)限制條件。
下面的示例中，SubClass 為 SuperClass 的子類，SubClass 重寫了 SuperClass 的 func() 方法。其中：
? 子類方法訪問權(quán)限為 public，大于父類的 protected。
? 子類的返回類型為 ArrayList，是父類返回類型 List 的子類。
? 子類拋出的異常類型為 Exception，是父類拋出異常 Throwable 的子類。
? 子類重寫方法使用 @Override 注解，從而讓編譯器自動(dòng)檢查是否滿足限制條件。
class SuperClass {
? ? protected List<Integer> func() throws Throwable {
? ? ? ? return new ArrayList<>();
? ? }
}
class SubClass extends SuperClass {
? ? @Override
? ? public ArrayList<Integer> func() throws Exception {
? ? ? ? return new ArrayList<>();
? ? }
}
在調(diào)用一個(gè)方法時(shí)，先從本類中查找看是否有對(duì)應(yīng)的方法，如果沒有再到父類中查看，看是否從父類繼承來(lái)。否則就要對(duì)參數(shù)進(jìn)行轉(zhuǎn)型，轉(zhuǎn)成父類之后看是否有對(duì)應(yīng)的方法?？偟膩?lái)說(shuō)，方法調(diào)用的優(yōu)先級(jí)為：
? this.func(this)
? super.func(this)
? this.func(super)
? super.func(super)
class A {
? ? public void show(A obj) {
? ? ? ? System.out.println("A.show(A)");
? ? }
? ? public void show(C obj) {
? ? ? ? System.out.println("A.show(C)");
? ? }
}
class B extends A {
? ? @Override
? ? public void show(A obj) {
? ? ? ? System.out.println("B.show(A)");
? ? }
}
class C extends B {
}
class D extends C {
}
public static void main(String[] args) {
? ? A a = new A();
? ? B b = new B();
? ? C c = new C();
? ? D d = new D();
? ? // 在 A 中存在 show(A obj)，直接調(diào)用
? ? a.show(a); // A.show(A)
? ? // 在 A 中不存在 show(B obj)，將 B 轉(zhuǎn)型成其父類 A
? ? a.show(b); // A.show(A)
? ? // 在 B 中存在從 A 繼承來(lái)的 show(C obj)，直接調(diào)用
? ? b.show(c); // A.show(C)
? ? // 在 B 中不存在 show(D obj)，但是存在從 A 繼承來(lái)的 show(C obj)，將 D 轉(zhuǎn)型成其父類 C
? ? b.show(d); // A.show(C)
? ? // 引用的還是 B 對(duì)象，所以 ba 和 b 的調(diào)用結(jié)果一樣
? ? A ba = new B();
? ? ba.show(c); // A.show(C)
? ? ba.show(d); // A.show(C)
}
1. 重載（Overload）
存在于同一個(gè)類中，指一個(gè)方法與已經(jīng)存在的方法名稱上相同，但是參數(shù)類型、個(gè)數(shù)、順序至少有一個(gè)不同。
應(yīng)該注意的是，返回值不同，其它都相同不算是重載。
class OverloadingExample {
? ? public void show(int x) {
? ? ? ? System.out.println(x);
? ? }
? ? public void show(int x, String y) {
? ? ? ? System.out.println(x + " " + y);
? ? }
}
public static void main(String[] args) {
? ? OverloadingExample example = new OverloadingExample();
? ? example.show(1);
? ? example.show(1, "2");
}
反射
每個(gè)類都有一個(gè) Class 對(duì)象，包含了與類有關(guān)的信息。當(dāng)編譯一個(gè)新類時(shí)，會(huì)產(chǎn)生一個(gè)同名的 .class 文件，該文件內(nèi)容保存著 Class 對(duì)象。
類加載相當(dāng)于 Class 對(duì)象的加載，類在第一次使用時(shí)才動(dòng)態(tài)加載到 JVM 中。也可以使用 Class.forName("com.mysql.jdbc.Driver") 這種方式來(lái)控制類的加載，該方法會(huì)返回一個(gè) Class 對(duì)象。
反射可以提供運(yùn)行時(shí)的類信息，并且這個(gè)類可以在運(yùn)行時(shí)才加載進(jìn)來(lái)，甚至在編譯時(shí)期該類的 .class 不存在也可以加載進(jìn)來(lái)。
Class 和 java.lang.reflect 一起對(duì)反射提供了支持，java.lang.reflect 類庫(kù)主要包含了以下三個(gè)類：
? Field ：可以使用 get() 和 set() 方法讀取和修改 Field 對(duì)象關(guān)聯(lián)的字段；
? Method ：可以使用 invoke() 方法調(diào)用與 Method 對(duì)象關(guān)聯(lián)的方法；
? Constructor ：可以用 Constructor 的 newInstance() 創(chuàng)建新的對(duì)象。
反射的優(yōu)點(diǎn)：
? 可擴(kuò)展性 ：應(yīng)用程序可以利用全限定名創(chuàng)建可擴(kuò)展對(duì)象的實(shí)例，來(lái)使用來(lái)自外部的用戶自定義類。
? 類瀏覽器和可視化開發(fā)環(huán)境 ：一個(gè)類瀏覽器需要可以枚舉類的成員?？梢暬_發(fā)環(huán)境（如 IDE）可以從利用反射中可用的類型信息中受益，以幫助程序員編寫正確的代碼。
? 調(diào)試器和測(cè)試工具 ： 調(diào)試器需要能夠檢查一個(gè)類里的私有成員。測(cè)試工具可以利用反射來(lái)自動(dòng)地調(diào)用類里定義的可被發(fā)現(xiàn)的 API 定義，以確保一組測(cè)試中有較高的代碼覆蓋率。
反射的缺點(diǎn)：
盡管反射非常強(qiáng)大，但也不能濫用。如果一個(gè)功能可以不用反射完成，那么最好就不用。在我們使用反射技術(shù)時(shí)，下面幾條內(nèi)容應(yīng)該牢記于心。
? 性能開銷 ：反射涉及了動(dòng)態(tài)類型的解析，所以 JVM 無(wú)法對(duì)這些代碼進(jìn)行優(yōu)化。因此，反射操作的效率要比那些非反射操作低得多。我們應(yīng)該避免在經(jīng)常被執(zhí)行的代碼或?qū)π阅芤蠛芨叩某绦蛑惺褂梅瓷洹?/p>
? 安全限制 ：使用反射技術(shù)要求程序必須在一個(gè)沒有安全限制的環(huán)境中運(yùn)行。如果一個(gè)程序必須在有安全限制的環(huán)境中運(yùn)行，如 Applet，那么這就是個(gè)問題了。
? 內(nèi)部暴露 ：由于反射允許代碼執(zhí)行一些在正常情況下不被允許的操作（比如訪問私有的屬性和方法），所以使用反射可能會(huì)導(dǎo)致意料之外的副作用，這可能導(dǎo)致代碼功能失調(diào)并破壞可移植性。反射代碼破壞了抽象性，因此當(dāng)平臺(tái)發(fā)生改變的時(shí)候，代碼的行為就有可能也隨著變化。
異常
Throwable 可以用來(lái)表示任何可以作為異常拋出的類，分為兩種： Error 和 Exception。其中 Error 用來(lái)表示 JVM 無(wú)法處理的錯(cuò)誤，Exception 分為兩種：
? 受檢異常 ：需要用 try...catch... 語(yǔ)句捕獲并進(jìn)行處理，并且可以從異常中恢復(fù)；
? 非受檢異常 ：是程序運(yùn)行時(shí)錯(cuò)誤，例如除 0 會(huì)引發(fā) Arithmetic Exception，此時(shí)程序崩潰并且無(wú)法恢復(fù)。
泛型
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 注解是附加在代碼中的一些元信息，用于一些工具在編譯、運(yùn)行時(shí)進(jìn)行解析和使用，起到說(shuō)明、配置的功能。注解不會(huì)也不能影響代碼的實(shí)際邏輯，僅僅起到輔助性的作用。
特性
Java 各版本的新特性
Java SE 8 的新功能
1. Lambda 表達(dá)式
2. 管道和流
3. 日期和時(shí)間 API
4. 默認(rèn)方法
5. 類型注解
6. Nashorn JavaScript 引擎
7. 并發(fā)累加器
8. 并行操作
Java SE 7 的新功能
1. Switch 語(yǔ)句中的字符串
2. 泛型實(shí)例創(chuàng)建時(shí)的類型推斷
3. 多異常處理
4. 對(duì)動(dòng)態(tài)語(yǔ)言的支持
5. 資源的 try-with 語(yǔ)句
6. Java nio 包
7. 二進(jìn)制字面量、字面量中的下劃線
8. 菱形語(yǔ)法
Java 與 C++ 的區(qū)別
? Java 是純粹的面向?qū)ο笳Z(yǔ)言，所有的對(duì)象都繼承自 java.lang.Object，C++ 為了兼容 C 即支持面向?qū)ο笠仓С置嫦蜻^(guò)程。
? Java 通過(guò)虛擬機(jī)從而實(shí)現(xiàn)跨平臺(tái)特性，但是 C++ 依賴于特定的平臺(tái)。
? Java 沒有指針，它的引用可以理解為安全指針，而 C++ 具有和 C 一樣的指針。
? Java 支持自動(dòng)垃圾回收，而 C++ 需要手動(dòng)回收。
? Java 不支持多重繼承，只能通過(guò)實(shí)現(xiàn)多個(gè)接口來(lái)達(dá)到相同目的，而 C++ 支持多重繼承。
? Java 不支持操作符重載，雖然可以對(duì)兩個(gè) String 對(duì)象執(zhí)行加法運(yùn)算，但是這是語(yǔ)言內(nèi)置支持的操作，不屬于操作符重載，而 C++ 可以。
? Java 的 goto 是保留字，但是不可用，C++ 可以使用 goto。
JRE or JDK
? JRE：Java Runtime Environment，Java 運(yùn)行環(huán)境的簡(jiǎn)稱，為 Java 的運(yùn)行提供了所需的環(huán)境。它是一個(gè) JVM 程序，主要包括了 JVM 的標(biāo)準(zhǔn)實(shí)現(xiàn)和一些 Java 基本類庫(kù)。
? JDK：Java Development Kit，Java 開發(fā)工具包，提供了 Java 的開發(fā)及運(yùn)行環(huán)境。JDK 是 Java 開發(fā)的核心，集成了 JRE 以及一些其它的工具，比如編譯 Java 源碼的編譯器 javac 等。
