[[442552]]

問題一：包裝類的緩存還記得不?

我們來看一下包裝類相關的比較，看下下面的代碼，最終將打印什么呢?

public static void main(String[] args) { 
    Boolean bool1 = true, bool2 = true; 
    System.out.println("bool1==bool2 ? " + (bool1 == bool2) ); 
 
    Character c1 = 127, c2 = 127; 
    Character c3 = 128, c4 = 128; 
    System.out.println("c1==c2 ? " + (c1 == c2)); 
    System.out.println("c3==c4 ? " + (c3 == c4) ); 
 
    Integer i1 = 10, i2 = 10; 
    Integer i3 = 300, i4 = 300; 
    System.out.println("i1==i2 ? " + (i1 == i2)); 
    System.out.println("i3==i4 ? " + (i3 == i4) ); 
 
    Long long1 = 10L, long2 = 10L; 
    Long long3 = 300L, long4 = 300L; 
    System.out.println("long1==long2 ? " + (long1 == long2)); 
    System.out.println("long3==long4 ? " + (long3 == long4)); 
 
    Float float1 = 10f, float2 = 10f; 
    Float float3 = 300f, float4 = 300f; 
    System.out.println("float1==float2 ? " + (float1 == float2)); 
    System.out.println("float3==float4 ? " + (float3 == float4)); 
} 

代碼很簡單，就是對各個包裝類的幾個值進行比較，可以猜測下這段代碼的打印結果。這里我們直接將打印結果貼出來：

public static void main(String[] args) { 
    Boolean bool1 = true, bool2 = true; 
    System.out.println("bool1==bool2 ? " + (bool1 == bool2) ); 
 
    Character c1 = 127, c2 = 127; 
    Character c3 = 128, c4 = 128; 
    System.out.println("c1==c2 ? " + (c1 == c2)); 
    System.out.println("c3==c4 ? " + (c3 == c4) ); 
 
    Integer i1 = 10, i2 = 10; 
    Integer i3 = 300, i4 = 300; 
    System.out.println("i1==i2 ? " + (i1 == i2)); 
    System.out.println("i3==i4 ? " + (i3 == i4) ); 
 
    Long long1 = 10L, long2 = 10L; 
    Long long3 = 300L, long4 = 300L; 
    System.out.println("long1==long2 ? " + (long1 == long2)); 
    System.out.println("long3==long4 ? " + (long3 == long4)); 
 
    Float float1 = 10f, float2 = 10f; 
    Float float3 = 300f, float4 = 300f; 
    System.out.println("float1==float2 ? " + (float1 == float2)); 
    System.out.println("float3==float4 ? " + (float3 == float4)); 
} 

如果和你的預期結果是一致的，那么說明你這里掌握的很好，而如果和你的預期結果有稍稍不同的話，那么或許你可以再接著往下看。

解惑1：

首先，我們學習String的時候，都知道String類是不可變的，因此編譯階段會將String常量放入字符串常量池中，當下次使用時就可以直接從字符串常量池中提取。

而對于包裝類來說，其對象同樣也是不可變的。所以對于某些頻繁使用的值，系統也提供了包裝類的緩存，當需要時直接從緩存中取值，而不是再創建一個新的包裝類對象。

這些包裝類緩存的范圍如下：

• boolean的所有值(true和false);
• char值的0~127;
• byte，short，int，long的-128~127;

以Long為例，我們來簡單看一下源碼：

private static class LongCache { 
    private LongCache(){} 
 
    static final Long cache[] = new Long[-(-128) + 127 + 1]; 
 
    static { 
        for(int i = 0; i < cache.length; i++) 
            cache[i] = new Long(i - 128); 
    } 
} 

這個LongCache就是Long中緩存的實現，其他的也是類似，如IntegerCache，CharacterCache等，這里比較有意思的是：

static final Long cache[] = new Long[-(-128) + 127 + 1]; 

這里數組的容量，使用了-(-128) + 127 + 1，這個我覺得寫的挺有意思的，相當于是間接標識出了數組元素對應的范圍：

-(-128) 表示負數的元素是128個;127 則表示正數的元素是127個，1 則表示元素0的個數;

這里我們在寫代碼的時候可以參考下，而其他的Cache的實現則是類似的，大家有興趣的可以扒下代碼看看。

對于浮點類型Float和Double，包裝類沒有緩存。

問題二：main方法有什么特殊的呢

我們一開始學習Java程序的時候，最先跑的一段代碼肯定是main方法，main方法的格式如下：

public static void main(String[] args)  

那么main方法有什么特殊的地方呢?我們來簡單看一下。

解惑2：

首先針對main方法的格式定義：

• public：main方法是啟動的時候由JVM進行加載的，public的可訪問權限是最高的，所以需要聲明為public;
• static：方法的調用要么是通過對象，要么是通過類，而main方法的話因為是由虛擬機調用的，所以無需生成對象，那么聲明為static即可;
• main：至于為什么方法名稱叫main，我想應該是參考的是C語言的方法名吧;
• void：main方法退出時，并沒有需要有相關返回值需要返回，所以是void;
• String[]：此字符串數組用來運行時接受用戶輸入的參數;因為字符串在Java中是具有通用普遍性的，所以使用字符串是最優選擇;數組的話，因為我們的參數不止一個，所以數組肯定是合適的;

不過自動JDK1.5引入動態參數后，String[]數組也可以使用String... args來實現：

public static void main(String... args) 

除了上面JVM規定的這個main方法比較特殊外，其他的main方法與普通的靜態方法是沒有什么不同的。

1. main方法能重載么?

這個是可以的，比如說我們給它重載一個方法：

public class Main { 
    public static void main(String args) { 
        System.out.println("hello world:" + args); 
    } 
 
    public static void main(String[] args) { 
        main("test"); 
    } 
} 

編譯運行，很顯然沒啥問題，除了JVM規定的作為應用程序入口的main方法之外，其他的main方法都是比較普通的方法。

2. main方法能被其他方法調用么?

public class Main { 
    private static int times = 3; 
 
    public static void main2(String[] args) { 
        times--; 
        main(args); 
    } 
 
    public static void main(String[] args) { 
        System.out.println("main方法執行:" + times); 
        if (times <= 0) { 
            System.exit(0); 
        } 
        main2(args); 
    } 
} 

運行一下代碼，可以發現代碼能正常執行：

main方法執行:3 
main方法執行:2 
main方法執行:1 
main方法執行:0 

所以說即使是作為應用程序入口的main方法，也是可以被其他方法調用的，但要注意程序的關閉方式，別陷入死循環了。

3. main方法可以繼承么?

我們以前了解過，當類繼承時，子類可以繼承父類的方法和變量，那么當父類定義了main方法，而子類沒有main方法時，能繼承父類的main方法，從而正常的運行程序么?

public class Main { 
    public static void main(String[] args) { 
        System.out.println("hello world"); 
    } 
} 

定義子類：

public class Main2 extends Main { 
} 

這時候我們運行子類Main2，可以發現，同樣打印了hello world，這說明main方法也是可以繼承的。那么還有一種隱藏的情況也很顯然了，子類定義自己的main方法，隱藏掉父類中的實現，那么這也是可以的。

public class Main2 extends Main { 
    public static void main(String[] args) { 
        System.out.println("hello world Main2"); 
    } 
} 

這時候就會打印子類自己的內容了：hello world Main2。

這么來看，除了main方法作為應用程序的入口比較特殊外，其他情況下與正常的靜態方法是沒什么區別的。