Java的基本使用

1、如何運行一個Java源碼

打開文本編輯器，輸入以下代碼：

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

class用來定義一個類，public表示這個類是公開的，public、class都是Java的關(guān)鍵字，必須小寫，Hello是類的名字，按照習慣，首字母 H 要大寫。

這里有一個 main 方法，該方法有一個參數(shù)，參數(shù)類型是String[]，參數(shù)名是args。public、static用來修飾方法，這里表示它是一個公開的靜態(tài)方法，void是方法的返回類型。

Java規(guī)定，某個類定義的public static void main(String[] args)是Java程序的固定入口方法，因此，Java程序總是從main方法開始執(zhí)行。

最后，當我們把代碼保存為文件時，文件名必須是Hello.java，而且文件名也要注意大小寫。注意，文件名跟類名必須完全一致。

如何運行一個Java程序：

Java源碼本質(zhì)上是一個文本文件，我們需要先用javac把Hello.java編譯成字節(jié)碼文件Hello.class，然后，用java命令執(zhí)行這個字節(jié)碼文件即可得到輸出。可執(zhí)行文件javac是編譯器，而可執(zhí)行文件java就是虛擬機。

$ javac Hello.java

$ java Hello
Hello, world!

1.1、java SE代碼如何打包成jar包

在項目的根目錄下，如在 src 目錄下執(zhí)行以下命令：

jar cfe app.jar cn.itcast.jvm.demo.Test01 cn/itcast/jvm/demo/Test01.class

其中，cn.itcast.jvm.demo.Test01是主方法 main 的類的全名，cn/itcast/jvm/demo/Test01.class 是該類編譯生成的 class 文件相對于當前執(zhí)行命令的路徑。

1.2、java帶jvm參數(shù)運行jar包

java [options] -jar jar-file-name [args …]   # args：傳入main()的參數(shù)

示例：

java -Xms512m -Xmx1024m -XX:+UseG1GC -jar your-application.jar

java -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/usr/myfolder/MY_JVM_ANALYZE/HEAP_DUMP/heapdump0626.hprof  -jar springbootTest01.jar

有些人把 jvm 參數(shù)放在命令最后面雖然不會報錯，但 jvm 參數(shù)不會起作用

2、Java的基本知識

Java是面向?qū)ο蟮恼Z言，它的一個程序的基本單位就是class。

Java入口程序規(guī)定的方法必須是靜態(tài)方法，方法名必須為main，括號內(nèi)的參數(shù)必須是String數(shù)組。Java的每一行語句必須以分號結(jié)束。

一個 .java 文件只能包含一個 public 類，但可以包含多個非 public 類，除了一個 public 類，其它類都只能用 default 修飾。如果有 public類，public 類的類名必須與文件名相同。

2.1、一次編寫，到處執(zhí)行

Java介于編譯型語言和解釋型語言之間。編譯型語言如C、C++，代碼是直接編譯成機器碼執(zhí)行，但是不同的平臺（x86、ARM等）CPU的指令集不同，因此，需要編譯出每一種平臺的對應(yīng)機器碼。解釋型語言如Python、Ruby沒有這個問題，可以由解釋器直接加載源碼然后運行，代價是運行效率太低。而Java是將代碼編譯成一種“字節(jié)碼”，它類似于抽象的CPU指令，然后，針對不同平臺編寫虛擬機即JVM，不同平臺的虛擬機負責加載字節(jié)碼并執(zhí)行，這樣就實現(xiàn)了“一次編寫，到處運行”的效果。

當然，這是針對Java開發(fā)者而言。對于虛擬機，需要為每個平臺分別開發(fā)。為了保證不同平臺、不同公司開發(fā)的虛擬機都能正確執(zhí)行Java字節(jié)碼，SUN公司制定了一系列的Java虛擬機規(guī)范。從實踐的角度看，JVM的兼容性做得非常好，低版本的Java字節(jié)碼完全可以正常運行在高版本的JVM上。

2.2、Java的優(yōu)勢

從互聯(lián)網(wǎng)到企業(yè)平臺，Java是應(yīng)用最廣泛的編程語言，原因在于：

Java是基于JVM虛擬機的跨平臺語言，一次編寫，到處運行；
Java程序易于編寫，而且有內(nèi)置垃圾收集，不必考慮內(nèi)存管理；

2.3、Java的三個版本（Java SE、EE、ME）

隨著Java的發(fā)展，SUN給Java又分出了三個不同版本：

Java SE（J2SE）：Standard Edition（核心、基礎(chǔ)）
Java EE（J2EE）：Enterprise Edition（開發(fā)web應(yīng)用）
Java ME（J2ME）：Micro Edition（無特殊需求不建議學習）

簡單來說，Java SE就是標準版，包含標準的JVM和標準庫，而Java EE是企業(yè)版，它只是在Java SE的基礎(chǔ)上加上了大量的API和庫，以便方便開發(fā)Web應(yīng)用、數(shù)據(jù)庫、消息服務(wù)等，Java EE的應(yīng)用使用的虛擬機和Java SE完全相同。

Java ME就和Java SE不同，它是一個針對嵌入式設(shè)備的“瘦身版”，Java SE的標準庫無法在Java ME上使用，Java ME的虛擬機也是“瘦身版”。

毫無疑問，Java SE是整個Java平臺的核心，而Java EE是進一步學習Web應(yīng)用所必須的。我們熟悉的Spring等框架都是Java EE開源生態(tài)系統(tǒng)的一部分。不幸的是，Java ME從來沒有真正流行起來，反而是Android開發(fā)成為了移動平臺的標準之一，因此，沒有特殊需求，不建議學習Java ME。

2.4、JDK、JRE 和 JVM

JDK > JRE > JVM

JDK：Java Development Kit
JRE：Java Runtime Environment

簡單地說，JRE就是運行Java字節(jié)碼的虛擬機。但是，如果只有Java源碼，要編譯成Java字節(jié)碼，就需要JDK，因為JDK除了包含JRE，還提供了編譯器、調(diào)試器等開發(fā)工具。

二者關(guān)系如下：

而 JVM 又是什么呢？我們常說的虛擬機也可以指的是 JVM，在JDK下面的的 jre 目錄里面有兩個文件夾 bin 和 lib，在這里可以認為 bin 里的就是 jvm，lib 中則是 jvm 工作所需要的類庫，而 jvm 和 lib 加起來就稱為 jre，即 JVM+Lib =JRE。JVM不能單獨搞定class的執(zhí)行，解釋class的時候JVM需要調(diào)用解釋所需要的類庫lib。

JDK的安裝及配置可參考：http://www.rzrgm.cn/wenxuehai/p/9492355.html

3、數(shù)據(jù)類型

3.1、基本數(shù)據(jù)類型

基本數(shù)據(jù)類型是CPU可以直接進行運算的類型。Java定義了以下幾種基本數(shù)據(jù)類型：

1）整數(shù)類型：byte，short，int，long

2）浮點數(shù)類型：float，double

3）字符類型：char

4）布爾類型：boolean

在定義 long、float 類型的值時，需要在值加上 l、f 后綴。

3.2、基本數(shù)據(jù)類型占用的字節(jié)數(shù)和表示的范圍

3.2.1、整數(shù)類型

byte 占 1 個字節(jié)，能表示的范圍 -128 ~ 127 （-2^7 ~ 2^7-1）
short 占 2 個字節(jié)，能表示的范圍 -32768 ~ 32767 （-2^15 ~ 2^15-1）
int 占 4 個字節(jié)，能表示的范圍 -2147483648 ~ 2147483647 （-2^31 ~ 2^31-1）
long 占 8 個字節(jié)，能表示的范圍 -9223372036854774808 ~ 9223372036854774807 （-2^63 ~ 2^63-1）

3.2.2、浮點數(shù)類型

float 占 4 個字節(jié)，能表示的范圍 -2^128 ~ +2^127 （-3.40E+38 ~ +3.40E+38，E表示10的幾次方）
double 占 8 個字節(jié)，能表示的范圍 -2^1024 ~ +2^1023 （-1.79E+308 ~ +1.79E+308）

Java 有兩種浮點數(shù)據(jù)類型，第一種 float 對應(yīng)單精度浮點數(shù)，運行速度相比 double 更快，占內(nèi)存更小，但是當數(shù)值非常大或者非常小的時候會變得不精確，精度要求不高的時候可以使用float類型。double 為 64位表示，將浮點數(shù)賦給某個變量時，如果不字面值后面加 f 或者 F，則默認為 double 類型。

float 的精度為7~8位有效數(shù)字，double 的精度為16~17位有效數(shù)字。

3.2.3、布爾類型

Java 語言對布爾類型的存儲并沒有做規(guī)定，因為理論上存儲布爾類型只需要1 bit，但是通常 JVM 內(nèi)部會把 Boolean 表示為 4 字節(jié)整數(shù)。

3.3、基本運算和自動類型轉(zhuǎn)換、強制類型轉(zhuǎn)換

在Java中，位移運算屬于基本運算，符號是 << 和 >>，即向左位移和向右位移，在Java中只有整數(shù)才能位移。

在運算過程中，如果參與運算的兩個數(shù)類型不一致，那么計算結(jié)果為較大類型的整型，因為較小類型的值會被自動轉(zhuǎn)型為較大類型的值。

也可以對值進行強制轉(zhuǎn)型，即將大范圍的值轉(zhuǎn)型為小范圍的值，強制轉(zhuǎn)型使用： (類型)n。

int i = 10;
long l = i;   //自動類型轉(zhuǎn)換

long l =  200l;
int i = (int)l   //強制類型轉(zhuǎn)換

要注意，超出范圍的強制轉(zhuǎn)型會得到錯誤的結(jié)果，因為在轉(zhuǎn)型時只會保留較小類型值的字節(jié)數(shù)，即前面的那些多余的位數(shù)就會被扔掉。

4、Java命名規(guī)范

Java 中的命名規(guī)范：

項目名全部小寫（xxxyyy）
包名全部小寫（xxxyyy）
類名和接口名首字母大寫，如果由多個單詞組成，每個單詞的首字母都要大寫（XxxYyy）
變量名、方法名使用首字母小寫的駝峰命名法（xxxYyy）
常量名全部大寫，可用下劃線分隔開（XXX_YYY）

所有命名規(guī)則必須遵循以下規(guī)則：

1)、名稱只能由字母、數(shù)字、下劃線、$符號組成

2)、不能以數(shù)字開頭

3)、名稱不能直接使用JAVA中的關(guān)鍵字，但可以包含關(guān)鍵字。

4)、見名知意，堅決不允許出現(xiàn)中文及拼音命名。

5、Java中的方法參數(shù)

5.1、可變參數(shù)

可變參數(shù)用類型...定義，可變參數(shù)相當于數(shù)組類型：

class Group {
    private String[] names;

    public void setNames(String... namesArr) {
        this.names = namesArr; //這里的namesArr是一個數(shù)組來的 
    }
    public String[] getNames() {
        return names;
    }
}

public static void main(String[] args) {
    Group g = new Group();

    g.setNames("Xiao Ming"); 
    System.out.println(Arrays.toString(g.getNames()));  //[Xiao Ming]

    g.setNames();
    System.out.println(Arrays.toString(g.getNames()));  //[]
    
    g.setNames(new String[] {"aaa", "bbb"});  //也可以直接傳入一個數(shù)組
    System.out.println(Arrays.toString(g.getNames()));  //[aaa, bbb]
}

5.2、參數(shù)傳遞

在 Java 中，一般情況下，在數(shù)據(jù)做為參數(shù)傳遞的時候，基本數(shù)據(jù)類型是值傳遞，引用數(shù)據(jù)類型是引用傳遞（地址傳遞）。（也有一種說法是Java中的方法參數(shù)傳遞方式只有一種：值傳遞。其實也就是說引用傳遞時傳遞的是地址，也相當于是值傳遞）

基本類型參數(shù)的傳遞，是值的復(fù)制，相當于創(chuàng)建了一個值的副本，函數(shù)外和函數(shù)內(nèi)的值互不影響。

引用數(shù)據(jù)類型是引用傳遞，即傳遞了地址過去，相當于創(chuàng)建了一個地址的副本，在函數(shù)中如果修改了引用數(shù)據(jù)類型的值，則實際上修改的是該地址指向的值，所以函數(shù)外面的值也會改變，因為它們都是同一個地址。

但是 String 類型的值比較特殊，String 類型的值在創(chuàng)建之后不能被改變，所以如果在函數(shù)內(nèi)修改 string 類型的值，相當于重新創(chuàng)建一個對象，并且將傳遞過來的地址修改為指向新創(chuàng)建的 string 對象（實際上修改的是地址而不是字符串的值）。而傳遞過來的地址原本就是一個副本，所以函數(shù)外面的string類型的值不會發(fā)生改變。相對于其他引用類型來說，string類型是修改傳遞過來的地址，將地址參數(shù)改為指向其他地址，所以實際上修改的是地址。而其他引用類型的值是直接修改該地址中的引用類型的值，實際上是直接修改地址參數(shù)指向的值，所以函數(shù)外面的引用類型值也會隨之發(fā)生改變。

可以參考：http://www.rzrgm.cn/jiangxin007/p/9076696.html

6、聲明和初始化

在 Java 中，局部變量必須經(jīng)過顯式的賦值才能使用它，如果直接使用一個沒有被初始化的局部變量，編譯器會報錯。

但是，如果該變量是類中的成員變量的話，則虛擬機會默認給它一個初始值，無需顯式賦值即可引用。

7、Java中的修飾符

Java語言提供了很多修飾符，主要分為以下兩類：

訪問修飾符
非訪問修飾符

修飾符用來定義類、方法或者變量，通常放在語句的最前端。

7.1、訪問控制修飾符（public、protected、默認default、private）

Java 中可以使用訪問控制符來保護對類、變量、方法和構(gòu)造方法的訪問。

public : 對所有類可見。使用對象：類、接口、變量、方法
protected: 對同一包內(nèi)的類和所有子類可見。使用對象：變量、方法。 注意：不能修飾類（外部類）。
default (缺省即什么也不寫）: 在同一包內(nèi)可見，不使用任何修飾符。使用對象：類、接口、變量、方法。注意不是寫”default“關(guān)鍵字，而是什么都沒寫。
private : 在同一類內(nèi)可見。使用對象：變量、方法。注意：不能修飾類（外部類）

對于類的修飾符只可以用 public 和 default（缺省）。一個 Java 文件除了一個 public 類，其它的類只能缺省修飾。

請注意：下圖中的子類指的是不同包中的子類：

子類和父類在同一個包下，只要父類中的變量不是 private 修飾的都可以訪問。

子類和父類不在同一個包中，子類只能訪問父類中 public 和 protected 修飾的變量。

7.2、非訪問修飾符（static、final、abstract、synchronize和volatile）

為了實現(xiàn)一些其他的功能，Java 也提供了許多非訪問修飾符。

static 修飾符，用來修飾類方法和類變量。

final 修飾符，用來修飾類、方法和變量。final 修飾的類不能夠被繼承，修飾的方法不能被繼承類覆寫，修飾的變量為常量，一旦賦值后就不可修改。final修飾的變量可以在聲明時即賦值，也可以先聲明，后在構(gòu)造函數(shù)或者代碼塊中賦值。

abstract 修飾符，用來創(chuàng)建抽象類和抽象方法。

synchronized 和 volatile 修飾符，主要用于線程的編程。

7.2.1、static 修飾符

類中用 static 修飾的字段和方法被稱為靜態(tài)字段和靜態(tài)方法。

靜態(tài)字段和靜態(tài)方法并不屬于實例，而是類本身的字段或者方法。靜態(tài)字段和靜態(tài)方法對于所有的實例而言都是只有一個共享“空間”，所有實例都會共享該字段或者方法。

靜態(tài)字段（類變量）：static 關(guān)鍵字用來聲明獨立于實例對象的靜態(tài)變量，無論一個類實例化多少對象，它的靜態(tài)變量只有一份拷貝。對于靜態(tài)字段，無論修改哪個實例的靜態(tài)字段，所有實例的該字段都將會被修改了。注意：局部變量不能被聲明為 static 變量。

靜態(tài)方法（類方法）：static 關(guān)鍵字用來聲明獨立于實例對象的靜態(tài)方法。靜態(tài)方法內(nèi)部不能使用類的非靜態(tài)變量，因為靜態(tài)方法屬于class而不屬于實例，因此，靜態(tài)方法內(nèi)部，無法訪問 this 變量，也無法訪問實例字段和非靜態(tài)方法，它只能訪問靜態(tài)字段和靜態(tài)方法。

對類的靜態(tài)變量和方法的訪問 Java 中是推薦直接使用類名.變量名和類名.方法名（注意是直接寫類名而不是實例名）的方式訪問。雖然通過實例變量.靜態(tài)字段和實例變量.方法名也可以訪問到靜態(tài)變量，但這只是因為編譯器可以根據(jù)實例類型自動轉(zhuǎn)換為類名xxx來訪問靜態(tài)字段或者方法而已。

public static void main(String[] args) {
    System.out.println(Person.number);
}

class Person {
    public static int number;
}

在靜態(tài)方法中直接調(diào)用非靜態(tài)方法會報錯，只能直接調(diào)用靜態(tài)方法，但是可以通過實例化類對象來調(diào)用非靜態(tài)方法：

public class Hello {
    public static void main(String[] args) {
        show();
        show2();                //直接調(diào)用非靜態(tài)方法會編譯錯誤，Cannot make a static reference to the non-static method show2() from the type Hello
        Hello h = new Hello();  //可以通過實例化一個類對象來調(diào)用，此時不會報錯
        h.show2();
  
    }    
    private static void show() {
        System.out.println("hi");
    }    
    private void show2() {
        System.out.println("hi2");
    }
}

為什么 static 方法只能調(diào)用靜態(tài)方法，可以參考：https://blog.csdn.net/x6696/article/details/80798471

7.3、default 關(guān)鍵字

在 Java 中，default 關(guān)鍵字的用法不多，只有兩種情況會用到：

在switch語句的時候使用default
在定義接口的時候使用default來修飾具體的方法

請注意：default 關(guān)鍵字和不寫修飾符時的默認（default）是不同的概念。

7.4、Java 中方法（變量）修飾符的使用順序

訪問控制修飾符：public private protected (default)
static 靜態(tài)；abstract 抽象方法/類
final 常量。可選，不能和abstract共存
返回值類型
方法名 / 變量名

8、Java中關(guān)于 String 的操作

8.1、創(chuàng)建字符串

在Java中，String是一個引用類型，它本身也是一個class。但是，Java編譯器對String有特殊處理，即可以直接用 "xxx" 來表示一個字符串，實際上字符串在String內(nèi)部是通過一個char[]數(shù)組表示的。

String s1 = new String("hello");    //通過new關(guān)鍵字創(chuàng)建字符串
String s1 = "Hello!";               //字面量方式創(chuàng)建字符串，推薦使用

String s2 = new String(new char[] {'H', 'e', 'l', 'l', 'o', '!'});   //Java內(nèi)部實際上創(chuàng)建字符串

Java字符串的一個重要特點就是字符串不可變。這種不可變性是通過內(nèi)部的private final char[]字段，以及沒有任何修改char[]的方法實現(xiàn)的。

關(guān)于字符串的操作有很多方法，但所有關(guān)于字符串的修改都不會改變原字符串，而是返回新的字符串，原有的字符串不會發(fā)生改變。

public static void main(String[] args) {
    String s = "aA";
    String s2 = s.toLowerCase();
    System.out.println(s);   //aA
    System.out.println(s2);  //aa
}

8.2、字符串的equals()方法

當我們想要比較兩個字符串是否相同時，要特別注意，我們實際上是想比較字符串的內(nèi)容是否相同。必須使用equals()方法而不能用 == ，==判斷的是字符串之間的引用即地址是否相同而不是字符串內(nèi)容。

equals 方法實際上是 Object 類的方法，默認的 equals 方法比較的是兩個對象引用是否一樣，作用與 == 相同，但 String 類（還有比如File、Date）覆寫了該方法，覆寫后比較的是內(nèi)容而不是引用。

public static void main(String[] args) {
    String s1 = "hello";
    String s2 = "hello";
    System.out.println(s1 == s2);       //true 這里為true實際上只是因為Java編譯器在編譯期，會自動把所有相同的字符串當作一個對象放入常量池，所以s1和s2的引用是相同的。
    System.out.println(s1.equals(s2));  //true 字符串的內(nèi)容比較一定要使用equals方法
     
    String s3 = "HELLO".toLowerCase();
    System.out.println(s1 == s3);       //false  使用 == 進行比較會得到錯誤的結(jié)果
    System.out.println(s1.equals(s3));  //true
}

上面代碼中，s1 == s2 為 true 是因為在使用字面量方式創(chuàng)建字符串時，如果新創(chuàng)建一個相同內(nèi)容的字符串對象，Java會將該新建的對象引向常量池中已存在相同內(nèi)容的對象地址，所以才為 true。當使用new關(guān)鍵字創(chuàng)建時，此時 Java 會重新在堆中創(chuàng)建一個新對象，所以此時用等號比較會是 false。

所以，使用字面量創(chuàng)建字符串更省內(nèi)存，所以我們推薦使用字面量方式創(chuàng)建字符串。

9、Java中關(guān)于數(shù)組的操作

9.1、定義一個數(shù)組

在 Java 中，使用 ‘類型[] = new 類型[]’ 的形式來定義一個數(shù)組。在 Java 中，定義一個數(shù)組的同時，必須指定該數(shù)組可容納的元素數(shù)量，否則的話編譯不會通過。

//定義一個整型數(shù)組
int[] ns = new int[5];
//定義一個字符串數(shù)組
String[] arr = new String[3];

String[] arr = new String[];  //報錯

或者可以在定義數(shù)組時直接指定數(shù)組的初始元素，這樣就不必寫出數(shù)組大小，編譯器會自動推算出數(shù)組的大小。

//直接給數(shù)組賦值
int[] ns = new int[] { 68, 79, 91, 85, 62 };

//簡寫（推薦使用）
int[] ns = { 68, 79, 91, 85, 62 };

9.2、Java中數(shù)組的特點

Java的數(shù)組有幾個特點：

數(shù)組所有元素初始化為默認值，整型都是0，浮點型是0.0，布爾型是false；
數(shù)組一旦創(chuàng)建后，大小就不可改變。

數(shù)組是引用類型，并且數(shù)組大小不可變。如下：

int[] ns;
ns = new int[] { 68, 79, 91, 85, 62 };
System.out.println(ns.length); // 5
ns = new int[] { 1, 2, 3 };
System.out.println(ns.length); // 3

上面的代碼看上去數(shù)組好像是變了，但其實根本沒變。只不過一開始時 ns 指向一個5個元素的數(shù)組，后面又指向一個3個元素的數(shù)組而已，原有的數(shù)組并沒有發(fā)生改變，只是 ns 的指向發(fā)生了改變而已。

9.3、遍歷數(shù)組

9.3.1、for 循環(huán)遍歷數(shù)組

因為數(shù)組的每個元素都可以通過索引來訪問，所以我們可以通過for循環(huán)就可以遍歷數(shù)組

int[] ns = { 1, 4, 9, 16, 25 };
for (int i=0; i<ns.length; i++) {
         int n = ns[i];
         System.out.println(n);
}

9.3.2、for each循環(huán)遍歷數(shù)組

在for(int n : ns)循環(huán)中，直接拿到的是數(shù)組的元素，而不是索引。

int[] ns = { 1, 4, 9, 16, 25 };
for (int n : ns) {
      System.out.println(n);  //1  4  9 16 25
}

10、Java中的包裝類

為了能將基本類型視為對象進行處理，并能連接相關(guān)的方法，java為每個基本類型都提供了包裝類，在Java 中提供了 8 種基本數(shù)據(jù)類型及對應(yīng)的 8 種包裝數(shù)據(jù)類型

包裝類使得一個基本類型的數(shù)據(jù)變成了類，有了類的特點，可以調(diào)用類的方法

10.1、包裝類的構(gòu)造方法

包裝類可以將與之對應(yīng)的基本數(shù)據(jù)類型作為參數(shù)來構(gòu)造實例，也可以將一個字符串作為參數(shù)構(gòu)造它們的實例

Integer i=new Integer(1);
Integer i=new Integer("123");

Boolean b=new Boolean(true);
Boolean b=new Boolean(“ok");

注意事項：

1）Boolean類構(gòu)造方法參數(shù)為String類型時，若該字符串內(nèi)容為 true(不考慮大小寫)時，則該 Boolean 對象表示true，否則表示 false。

2）當構(gòu)造方法參數(shù)為 String 類型時，字符串不能為 null，并且該字符串必須可轉(zhuǎn)換為相應(yīng)的基本數(shù)據(jù)類型的數(shù)據(jù)，否則就算編譯通過，運行時也會報 NumberFormatException 異常。

10.2、裝箱和拆箱

自動裝箱即自動將基本數(shù)據(jù)類型轉(zhuǎn)換成包裝類型。

在 Java 5 之前，要將基本數(shù)據(jù)類型轉(zhuǎn)換成包裝類型只能這樣做，看下面的代碼。

Integer i1 = new Integer(8);
Integer i1 = new Integer("8");

Java5 之后即支持自動裝箱，如下代碼：

Integer i3 = 8;    //自動裝箱
Integer i2 = Integer.valueOf(8);    //原理就是調(diào)用包裝類的 valueOf 方法

自動拆箱即自動將包裝類型轉(zhuǎn)換成基本數(shù)據(jù)類型，與自動裝箱相反。

int i4 = i3;   //自動拆箱
int i5 = i3.intValue();

上面就是自動拆箱，自動拆箱的原理就是調(diào)用包裝類的 xxxValue （xxx表示的是基本數(shù)據(jù)類型的寫法）方法

10.3、包裝類的應(yīng)用場景

1）集合類泛型只能是包裝類

// 編譯報錯
List<int> list1 = new ArrayList<>();

// 正常
List<Integer> list2 = new ArrayList<>();

2）成員變量不想有默認值時可以使用包裝類

基本數(shù)據(jù)類型的成員變量都有默認值，如下面代碼 status 默認值為 0，如果定義中 0 代表失敗，那樣就會有問題，這樣只能使用包裝類 Integer，它的默認值為 null,所以就不會有默認值影響。

private int status;

3) 方法參數(shù)允許定義空值

下面的代碼，方法參數(shù)定義的是基本數(shù)據(jù)類型 int，所以必須得傳一個數(shù)字過來，不能傳 null，很多場合我們希望是能傳遞 null 的，所以這種場合用包裝類比較合適。

private static void test1(int status){
    System.out.println(status);
}

posted @ 2019-10-31 11:09 wenxuehai 閱讀(2936) 評論(0) 收藏舉報

刷新頁面返回頂部

提升自己，才有選擇的能力和勇氣