String,static,final_ZenDei技術網路在線

1. String 下麵代碼創建了幾個對象？ String s1 = new String("Hello"); String s2 = new String("Hello"); 要想答對這道題，需要考慮String的一個常量池的概念。在執行代碼的時候，首先會判斷字元串常量池中是否存在"Hello"， ...

1. String

下麵代碼創建了幾個對象？

String s1 = new String("Hello");
String s2 = new String("Hello");

要想答對這道題，需要考慮String的一個常量池的概念。在執行代碼的時候，首先會判斷字元串常量池中是否存在"Hello"，如果存在，直接返回該對象的引用，那對於本題就是創建2個對象。如果不存在，則現在常量池中創建，加起來就三個對象了（一個對象兩個引用）。

1. 什麼樣的字元串才會放在常量池中呢？
首先，只有字元串對象才會放在常量池中。（String a = "abc"，"abc"是字元串對象）
其次，只有在編譯期確定的字元串才會被放在常量池中。

2. 考慮一下，常量池實在堆區還是方法區？
jdk1.6以及之前，是在方法區的，1.7及以後，是在堆區的。

下麵代碼的結果呢?創建了幾個對象呢？

String s1 = "Java";
String s2 = "從0到1";
String s3 = s1 + s2;
String s4 = "Java從0到1";
System.out.println(s3 == s4);

不考慮常量池中存在字元串，首先一眼看出至少三個，"Java","從0到1"，"Java從0到1"。比較麻煩的就是String s3 = s1 + s2;我們知道的是"Java","從0到1"，"Java從0到1"是在編譯期確定，放在字元串常量池中的。s3的值在編譯期間確定不了，是放在堆中，最後的值是"Java從0到1",這是第四個了，那這個值是如何得到的呢？s1和s2相加得到，但是s1和s2是在常量池中的，s3是在常量池之外的堆中的，所以必須拷貝s1和s2到常量池外的堆中，這又是兩個，現在看來，一共是創建了6個對象。

那程式的結果就很明顯了，結果是false。

加深理解，可以運行下麵的代碼：

String s1 = new String("Hello");
String s2 = s1;
s2 = "Java";
System.out.println(s1);
System.out.println(s2);
System.out.println("==========================");
String s3 = "Java";
String s4 = new String("Java");
System.out.println(s2 == s3);
System.out.println(s3 == s4);
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
System.out.println(s3.hashCode());
System.out.println(s4.hashCode());
System.out.println("===========================");
System.out.println(System.identityHashCode(s1));
System.out.println(System.identityHashCode(s2));
System.out.println(System.identityHashCode(s3));
System.out.println(System.identityHashCode(s4));

要註意的是String s = "Hello" 和 String s = new String("Hello"); 的區別，在我看來，前一個s是個引用，放在常量池中(有點疑惑還得認真研究)，而s是存放在堆上非常量池中，"Hello"是放在常量池中。

2. String被設計為不可變的好處。

1. 被設計為不可變，字元串池才可以實現。
2. 字元串不可變，不會造成線程安全問題，同一個字元串實例可以被多個線程共用，不用考慮同步，因為String本來就是線程安全。
3. 字元串的不可變，保證了哈希碼的唯一性，在創建的時候hashcode就被緩存，不用重新計算。使得字元串很適合作為Map中的鍵，字元串的處理速度要快過其它的鍵對象。這就是HashMap中的鍵往往都使用字元串。

3. final修飾類

首先要明確，final修飾的類是不可被繼承的。比如說String類就是被final修飾符修飾，就不可被繼承。相當於上鎖，

什麼時候使用？當你確定某一個類是完美的，不需要進行任何的修改和擴展，這個時候可以講類聲明為final。

4. final修飾成員變數

final修飾的成員變數只可被初始化一次，不可更改。

5. final修飾方法

final修飾方法，該方法不可被子類重寫覆蓋，但可以在本類中進行重載，並且可以被正常調用。

6. final修飾成員變數和普通變數的區別

String a = "hello1";
final String b = "hello"; 
String c = "hello"; 
String d = b + 1;
String e = c + 1;

System.out.println(a == d);
System.out.println(a == e);

結果是什麼呢？true和false！！！為什麼呢？這個原因是因為final修飾變數在編譯期間可以被直接替換，也就意味著在d=b+1的時候，d="hello"+1，即為"hello1",編譯期確定的值在常量池中，d和a的引用是相同的，所以a==b是true,而e是在運行期確定的，在堆的非常量池中，引用不同，所以a==e是false。

7. final和static

首先註意：

static用來表示唯一，獨此一份，也即是靜態，但是是可變的。
final用來表示不可變。

理解：static表示無論創建多少個對象，每個對象中被static修飾的成員變數都是相同的值。但是fianl表示每個對象中被fianl修飾的成員變數是不可更改的，一旦確定就不可能再修改。

8. static方法

static方法叫做靜態方法，靜態方法屬於類，不屬於對象，也就是可以直接使用類名來調用。在靜態方法中不能調用非靜態方法和非靜態成員變數，但是非靜態方法可以訪問靜態方法和成員變數（這兩句話怎麼理解呢？可以從載入類的順序考慮，類的載入會先載入靜態的成員變數和方法，之後是構造方法，非靜態的成員變數和方法）。

還有一個問題，就是構造方法是靜態的嗎？經過嘗試，構造方法不能使用static修飾，但是在靜態代碼塊中可以直接調用，因此可以得出，構造方法不是靜態的，但他具有靜態方法的一些特性，比如說可以在靜態方法中被調用。

9. static成員變數

靜態變數被所有對象共用，即屬於類，也就是在初次載入的時候被初始化，之後每次創建對象都不會初始化。而非靜態變數是屬於對象的，在每次創建對象都會有不同的賦值。

10. static代碼塊

靜態代碼塊可以用來優化程式性能，對於某些變數，只需要初始化一次等，這個時候就可以放在靜態代碼塊，靜態代碼塊永遠只會執行一次。

11. static註意點

static是不允許用來修飾局部變數。
static變數和方法可以使用對象來調用(this等)。
java類關於靜態的載入時間，單個類的話，沒有創建對象，只會執行靜態成員變數和靜態代碼塊。創建對象會在前面的基礎上依次執行初始化成員變數，代碼塊，構造方法。也就是這樣：靜態成員變數 --> 靜態代碼塊 --> 成員變數 --> 代碼塊 --> 構造函數。如果存在子父類繼承呢？父類靜態成員變數 --> 父類靜態代碼塊 -->子類靜態成員變數 --> 子類靜態代碼塊 --> 父類成員變數 --> 父類代碼塊 --> 父類構造函數 --> 子類成員變數 --> 子類代碼塊 --> 子類構造函數

按照上面的順序看看下麵的代碼的執行結果：

public class Test {
   Person person = new Person("Test");
   static{
       System.out.println("test static");
   }
    
   public Test() {
       System.out.println("test constructor");
   }
    
   public static void main(String[] args) {
       new MyClass();
   }
}

class Person{
   static{
       System.out.println("person static");
   }
   public Person(String str) {
       System.out.println("person "+str);
   }
}


class MyClass extends Test {
   Person person = new Person("MyClass");
   static{
       System.out.println("myclass static");
   }
    
   public MyClass() {
       System.out.println("myclass constructor");
   }
}

// 結果為
test static
myclass static
person static
person Test
test constructor
person MyClass
myclass constructor