正如你在上一課中所了解到的，對象將其狀態存儲在字段中。

int cadence = 0;
int speed = 0;
int gear = 1;

“什么是對象？”討論向你介紹了字段，但你可能還有一些問題，例如：命名字段的規則和約定是什么？除了int之外，還有哪些其他數據類型？在聲明字段時是否必須初始化字段？如果未明確初始化字段，是否為字段分配了默認值？我們將在本課中探討這些問題的答案，但在我們開始之前，你必須首先了解一些技術差異。在Java編程語言中，使用術語“字段”和“變量”，這是新開發人員之間混淆的常見原因，因為兩者往往都是指同一件事。

Java編程語言定義了以下幾種變量：

實例變量（非靜態字段）：從技術上講，對象將它們各自的狀態存儲在“非靜態字段”中，即，在沒有static關鍵字的情況下聲明的字段，非靜態字段也稱為實例變量，因為它們的值對于類的每個實例都是唯一的（換句話說，對于每個對象），一輛自行車的當前速度獨立于另一輛自行車的當前速度。

類變量（靜態字段）：類變量是使用static修飾符聲明的任何字段，這告訴編譯器這個變量只有一個副本存在，無論該類被實例化多少次，定義特定類型自行車檔位數的字段可以標記為靜態，因為從概念上講，相同數量的檔位將適用于所有實例，代碼static int numGears = 6會創建這樣一個靜態字段。此外，可以添加關鍵字final以指示檔位的數量永遠不會改變。

局部變量：與對象如何在字段中存儲其狀態類似，方法通常將其臨時狀態存儲在局部變量中，聲明局部變量的語法類似于聲明字段（例如，int count = 0;）。沒有特殊關鍵字將變量指定為本地變量，該決定完全來自聲明變量的位置 - 它位于方法的開括號和右括號之間。因此，局部變量僅對聲明它們的方法可見，他們無法從類的其他其他訪問。

參數：你已經在Bicycle類和“Hello World”應用程序的main方法中看到了參數示例，回想一下main方法的簽名是public static void main (String [] args)，這里，args變量是此方法的參數。要記住的重要一點是參數總是被歸類為“變量”而不是“字段”，這也適用于其他參數接受構造（例如構造函數和異常處理程序），你將在本教程后面學習。

每種編程語言都有自己的規則和約定，適用于你可以使用的各種名稱，Java編程語言也不例外，命名變量的規則和約定可歸納如下：

變量名稱區分大小寫，變量的名稱可以是任何合法標識符 - 一個無限長度的Unicode字母和數字序列，以字母開、美元符號“$”或下劃線字符“_”開頭，但是，慣例是始終用字母開始變量名，而不是“$”或“_”，此外，按照慣例，美元符號字符根本不會被使用。你可能會發現某些情況，其中自動生成的名稱將包含美元符號，但你的變量名稱應始終避免使用它，對于下劃線字符存在類似的約定；雖然用“_”開始變量的名稱在技術上是合法的，但不鼓勵這種做法，不允許有空格。

后續字符可以是字母，數字，美元符號或下劃線字符，約定（和通用場景）也適用于此規則，為變量選擇名稱時，請使用完整單詞而不是隱藏縮寫，這樣做可以使你的代碼更易于閱讀和理解。在許多情況下，它還會使你的代碼自我記錄，例如，名為cadence，speed和gear的字段比縮寫版本（如s，c和g）更直觀，另請注意，你選擇的名稱不得是關鍵字或保留字。

如果你選擇的名稱只包含一個單詞，則拼寫全部小寫字母，如果它由多個單詞組成，則將每個后續單詞的首字母大寫，名稱gearRatio和currentGear是此約定的主要示例，如果你的變量存儲一個常量值，例如static final int NUM_GEARS = 6;，約定略有變化，大寫每個字母并用后下劃線分隔后續單詞，按照慣例，下劃線字符從未在別處使用過。

Java編程語言是靜態類型的，這意味著必須首先聲明所有變量才能使用它們，這包括聲明變量的類型和名稱，如你所見：

int gear = 1;

這樣做會告訴程序一個名為“gear”的字段存在，保存數字數據，初始值為“1”，變量的數據類型確定它可能包含的值，以及可能對其執行的操作。除了int之外，Java編程語言還支持其他七種原始數據類型，基本類型由語言預定義，并由保留關鍵字命名，原始值不與其他原始值共享狀態，Java編程語言支持的八種原始數據類型是：

byte：字節數據類型是8位帶符號的二進制補碼整數，它的最小值為-128，最大值為127（含），字節數據類型可用于在大數組中保存內存，其中節省的內存實際上很重要。它們也可以用于代替int，其限制有助于澄清你的代碼，變量范圍有限的事實可以作為一種文檔形式。

short：short數據類型是16位帶符號的二進制補碼整數，它的最小值為-32,768，最大值為32,767（含）。與字節一樣，適用相同的準則：在內存節省實際上很重要的情況下，你可以使用short來節省大數組中的內存。

int：默認情況下，int數據類型是32位帶符號的二進制補碼整數，其最小值為-2^31，最大值為2^31-1，在Java SE 8及更高版本中，你可以使用int數據類型來表示無符號的32位整數，其最小值為0，最大值為2^32-1，使用Integer類將int數據類型用作無符號整數，有關詳細信息，請參閱“Number類”一節。已經將諸如compareUnsigned、divideUnsigned等靜態方法添加到Integer類中，以支持無符號整數的算術運算。

long：long數據類型是64位二進制補碼整數，帶符號的long的最小值為-2^63，最大值為2^63-1，在Java SE 8及更高版本中，你可以使用long數據類型來表示無符號的64位長，其最小值為0，最大值為2^64-1，當需要比int提供的值更寬的值時，請使用此數據類型，Long類還包含compareUnsigned、divideUnsigned等方法，以支持無符號long的算術運算。

float：浮點數據類型是單精度32位IEEE 754浮點，它的值范圍超出了本討論的范圍，但在Java語言規范的浮點類型、格式和值部分中指定。與byte和short的建議一樣，如果需要在大型浮點數數組中保存內存，請使用float（而不是double），絕不應將此數據類型用于精確值，例如貨幣，為此，你需要使用java.math.BigDecimal類，Numbers和Strings涵蓋了Java平臺提供的BigDecimal和其他有用的類。

double：double數據類型是雙精度64位IEEE 754浮點，它的值范圍超出了本討論的范圍，但在Java語言規范的浮點類型、格式和值部分中指定，對于十進制值，此數據類型通常是默認選擇，如上所述，此數據類型不應用于精確值，例如貨幣。

boolean：布爾數據類型只有兩個可能的值：true和false，將此數據類型用于跟蹤真/假條件的簡單標志，此數據類型表示一位信息，但其“大小”不是精確定義的內容。

char：char數據類型是單個16位Unicode字符，它的最小值為"u0000"（或0），最大值為"uffff"（或65,535（含））。

除了上面列出的八種原始數據類型之外，Java編程語言還通過java.lang.String類為字符串提供特殊支持，將字符串括在雙引號內將自動創建一個新的String對象，例如，String s =“this is a string”;。字符串對象是不可變的，這意味著一旦創建，它們的值就不能更改，String類在技術上不是原始數據類型，但考慮到語言給予它的特殊支持，你可能傾向于認為它是這樣的，你將在簡單的數據對象中了解有關String類的更多信息。

聲明字段時并不總是需要分配值，聲明但未初始化的字段將由編譯器設置為合理的默認值。一般來說，此默認值將為零或null，具體取決于數據類型，然而，依賴于這樣的默認值通常被認為是糟糕的編程風格。

下表總結了上述數據類型的默認值。

局部變量略有不同；編譯器永遠不會為未初始化的局部變量分配默認值，如果無法初始化聲明它的局部變量，請確保在嘗試使用它之前為其賦值，訪問未初始化的局部變量將導致編譯時錯誤。

你可能已經注意到在初始化基本類型的變量時不使用new關鍵字，原始類型是語言中內置的特殊數據類型，它們不是從類創建的對象。字面值是固定值的源代碼表示，字面值直接在代碼中表示，無需計算，如下所示，可以將字面值分配給基本類型的變量：

boolean result = true;
char capitalC = "C";
byte b = 100;
short s = 10000;
int i = 100000;

如果整數字面值以字母L或l結尾，則其長度為long，否則它是int類型，建議你使用大寫字母L，因為小寫字母l很難與數字1區分開來。

可以從int字面值創建整數類型byte、short、int和long的值，可以從long字面值創建超出int范圍的long類型的值，整數字面值可以用這些數字系統表示：

十進制：基數10，其數字由數字0到9組成，這是你每天使用的數字系統。

十六進制：基數16，其數字由數字0到9和字母A到F組成。

二進制：基數2，其數字由數字0和1組成（你可以在Java SE 7及更高版本中創建二進制字面值）。

對于通用編程，十進制系統可能是你將使用的唯一數字系統，但是，如果需要使用其他數字系統，以下示例將顯示正確的語法，前綴0x表示十六進制，0b表示二進制：

// The number 26, in decimal
int decVal = 26;
//  The number 26, in hexadecimal
int hexVal = 0x1a;
// The number 26, in binary
int binVal = 0b11010;

如果浮點字面值以字母F或f結尾，則浮點字面值為float類型，否則它的類型是double的，它可以選擇以字母D或d結尾。

浮點類型（float和double）也可以用E或e（科學計數法），F或f（32位浮點數）和D或d（64位雙精度數，這是默認值，按慣例省略）表示。

double d1 = 123.4;
// same value as d1, but in scientific notation
double d2 = 1.234e2;
float f1  = 123.4f;

類型char和String的字面值可以包含任何Unicode（UTF-16）字符，如果你的編輯器和文件系統允許，你可以直接在代碼中使用這些字符，如果沒有，你可以使用“Unicode轉義”，例如"u0108"（帶有circumflex的大寫字母C），或"Su00ED Seu00F1or"（SíSe?or，西班牙語）。始終對char字面值使用“單引號”，對字符串字面值使用“雙引號”，Unicode轉義序列可以在程序的其他地方使用（例如在字段名中），而不僅僅是在char或String字面值中。

Java編程語言還支持char和String字面值的一些特殊轉義序列：（退格）、 （制表符）、 （換行）、f（換頁）、 （回車）、 "（雙引號）、"（單引號）和（反斜杠）。

還有一個特殊的null字面值，可以用作任何引用類型的值，null可以分配給任何變量，但基本類型的變量除外。除了測試它的存在之外，你幾乎無法使用null值，因此，null通常在程序中用作標記，以指示某些對象不可用。

最后，還有一種特殊的字面值稱為類字面值，通過獲取類型名稱并附加“.class”形成，例如，String.class，這指的是表示類型本身的對象（類型為Class）。

在Java SE 7及更高版本中，任何數量的下劃線字符（_）都可以出現在數字字面值中的數字之間的任何位置，例如，此功能可以使你分隔數字字面值中的數字組，這可以提高代碼的可讀性。

例如，如果你的代碼包含具有多個數字的數字，則可以使用下劃線字符來分隔三個組中的數字，類似于使用逗號或空格等標點符號作為分隔符的方式。

以下示例顯示了在數字字面值中使用下劃線的其他方法：

long creditCardNumber = 1234_5678_9012_3456L;
long socialSecurityNumber = 999_99_9999L;
float pi =  3.14_15F;
long hexBytes = 0xFF_EC_DE_5E;
long hexWords = 0xCAFE_BABE;
long maxLong = 0x7fff_ffff_ffff_ffffL;
byte nybbles = 0b0010_0101;
long bytes = 0b11010010_01101001_10010100_10010010;

你只能在數字之間放置下劃線；你不能在以下地方放置下劃線：

在數字的開頭或結尾

與浮點字面值中的小數點相鄰

在F或L后綴之前

在預期有一串數字的位置

以下示例演示了數字字面值中有效和無效的下劃線放置：

// Invalid: cannot put underscores
// adjacent to a decimal point
float pi1 = 3_.1415F;
// Invalid: cannot put underscores 
// adjacent to a decimal point
float pi2 = 3._1415F;
// Invalid: cannot put underscores 
// prior to an L suffix
long socialSecurityNumber1 = 999_99_9999_L;

// OK (decimal literal)
int x1 = 5_2;
// Invalid: cannot put underscores
// At the end of a literal
int x2 = 52_;
// OK (decimal literal)
int x3 = 5_______2;

// Invalid: cannot put underscores
// in the 0x radix prefix
int x4 = 0_x52;
// Invalid: cannot put underscores
// at the beginning of a number
int x5 = 0x_52;
// OK (hexadecimal literal)
int x6 = 0x5_2; 
// Invalid: cannot put underscores
// at the end of a number
int x7 = 0x52_;

數組是一個容器對象，它包含固定數量的單個類型的值，創建數組時，將建立數組的長度，創建后，其長度是固定的。你已經在“Hello World!”應用程序的main方法中看到了一個數組示例，本節更詳細地討論了數組。

10個元素的數組。

數組中的每個項稱為元素，每個元素都由其數字索引訪問，如上圖所示，編號從0開始，例如，第9個元素將在索引8處訪問。

以下程序ArrayDemo創建一個整數數組，將一些值放入數組中，并將每個值打印到標準輸出。

class ArrayDemo {
    public static void main(String[] args) {
        // declares an array of integers
        int[] anArray;

        // allocates memory for 10 integers
        anArray = new int[10];
           
        // initialize first element
        anArray[0] = 100;
        // initialize second element
        anArray[1] = 200;
        // and so forth
        anArray[2] = 300;
        anArray[3] = 400;
        anArray[4] = 500;
        anArray[5] = 600;
        anArray[6] = 700;
        anArray[7] = 800;
        anArray[8] = 900;
        anArray[9] = 1000;

        System.out.println("Element at index 0: "
                           + anArray[0]);
        System.out.println("Element at index 1: "
                           + anArray[1]);
        System.out.println("Element at index 2: "
                           + anArray[2]);
        System.out.println("Element at index 3: "
                           + anArray[3]);
        System.out.println("Element at index 4: "
                           + anArray[4]);
        System.out.println("Element at index 5: "
                           + anArray[5]);
        System.out.println("Element at index 6: "
                           + anArray[6]);
        System.out.println("Element at index 7: "
                           + anArray[7]);
        System.out.println("Element at index 8: "
                           + anArray[8]);
        System.out.println("Element at index 9: "
                           + anArray[9]);
    }
}

該程序的輸出是：

Element at index 0: 100
Element at index 1: 200
Element at index 2: 300
Element at index 3: 400
Element at index 4: 500
Element at index 5: 600
Element at index 6: 700
Element at index 7: 800
Element at index 8: 900
Element at index 9: 1000

在實際編程情況下，你可能會使用其中一個受支持的循環結構來遍歷數組的每個元素，而不是像前面的示例中那樣多帶帶編寫每一行，但是，該示例清楚地說明了數組語法，你將在控制流部分中了解各種循環結構（for，while和do-while）。

前面的程序使用以下代碼行聲明一個數組（名為anArray）：

// declares an array of integers
int[] anArray;

與其他類型的變量的聲明一樣，數組聲明有兩個組件：數組的類型和數組的名稱。數組的類型寫為type[]，其中type是包含元素的數據類型，括號是特殊符號，表示此變量包含數組，數組的大小不是其類型的一部分（這就是括號為空的原因）。數組的名稱可以是你想要的任何名稱，前提是它遵循前面在命名部分中討論的規則和約定。與其他類型的變量一樣，聲明實際上并不創建數組，它只是告訴編譯器該變量將包含指定類型的數組。

同樣，你可以聲明其他類型的數組：

byte[] anArrayOfBytes;
short[] anArrayOfShorts;
long[] anArrayOfLongs;
float[] anArrayOfFloats;
double[] anArrayOfDoubles;
boolean[] anArrayOfBooleans;
char[] anArrayOfChars;
String[] anArrayOfStrings;

你還可以將括號放在數組名稱后面：

// this form is discouraged
float anArrayOfFloats[];

但是，公約不鼓勵這種形式；括號標識數組類型，并應顯示類型名稱。

創建數組的一種方法是使用new運算符，ArrayDemo程序中的下一個語句為10個整數元素分配一個具有足夠內存的數組，并將該數組賦值給anArray變量。

// create an array of integers
anArray = new int[10];

如果缺少此語句，則編譯器將輸出如下所示的錯誤，并且編譯失敗：

ArrayDemo.java:4: Variable anArray may not have been initialized.

接下來的幾行為數組的每個元素賦值：

anArray[0] = 100; // initialize first element
anArray[1] = 200; // initialize second element
anArray[2] = 300; // and so forth

每個數組元素都通過其數字索引訪問：

System.out.println("Element 1 at index 0: " + anArray[0]);
System.out.println("Element 2 at index 1: " + anArray[1]);
System.out.println("Element 3 at index 2: " + anArray[2]);

或者，你可以使用快捷語法來創建和初始化數組：

int[] anArray = { 
    100, 200, 300,
    400, 500, 600, 
    700, 800, 900, 1000
};

這里數組的長度由大括號之間提供的值的數量確定，并用逗號分隔。

你還可以使用兩組或更多組括號聲明一個數組數組（也稱為多維數組），例如String [][] names，因此，每個元素必須由相應數量的索引值訪問。

在Java編程語言中，多維數組是一個數組，其組件本身就是數組，這與C或Fortran中的數組不同，這樣做的結果是允許行的長度不同，如下面的MultiDimArrayDemo程序所示：

class MultiDimArrayDemo {
    public static void main(String[] args) {
        String[][] names = {
            {"Mr. ", "Mrs. ", "Ms. "},
            {"Smith", "Jones"}
        };
        // Mr. Smith
        System.out.println(names[0][0] + names[1][0]);
        // Ms. Jones
        System.out.println(names[0][10] + names[1][11]);
    }
}

該程序的輸出是：

Mr. Smith
Ms. Jones

最后，你可以使用內置的length屬性來確定任何數組的大小，以下代碼將數組的大小打印到標準輸出：

System.out.println(anArray.length);

System類有一個arraycopy方法，你可以使用它來有效地將數據從一個數組復制到另一個數組：

public static void arraycopy(Object src, int srcPos,
                             Object dest, int destPos, int length)

兩個Object參數指定要從中復制的數組和要復制到的數組，三個int參數指定源數組中的起始位置、目標數組中的起始位置以及要復制的數組元素的數量。

以下程序ArrayCopyDemo聲明了一個char元素數組，拼寫單詞“decaffeinated”，它使用System.arraycopy方法將數組組件的子序列復制到第二個數組中：

class ArrayCopyDemo {
    public static void main(String[] args) {
        char[] copyFrom = { "d", "e", "c", "a", "f", "f", "e",
                "i", "n", "a", "t", "e", "d" };
        char[] copyTo = new char[7];

        System.arraycopy(copyFrom, 2, copyTo, 0, 7);
        System.out.println(new String(copyTo));
    }
}

該程序的輸出是：

caffein

數組是編程中使用的強大而有用的概念，Java SE提供了執行與數組相關的一些最常見操作的方法，例如，ArrayCopyDemo示例使用System類的arraycopy方法，而不是手動迭代源數組的元素并將每個元素放入目標數組中。這是在幕后執行的，使開發人員只使用一行代碼來調用該方法。

為方便起見，Java SE提供了幾種在java.util.Arrays類中執行數組操作（常見任務，如復制、排序和搜索數組）的方法。例如，可以修改前面的示例以使用java.util.Arrays類的copyOfRange方法，如ArrayCopyOfDemo示例中所示：

class ArrayCopyOfDemo {
    public static void main(String[] args) {
        
        char[] copyFrom = {"d", "e", "c", "a", "f", "f", "e",
            "i", "n", "a", "t", "e", "d"};
            
        char[] copyTo = java.util.Arrays.copyOfRange(copyFrom, 2, 9);
        
        System.out.println(new String(copyTo));
    }
}

正如你所看到的，此程序的輸出是相同的（caffein），盡管它需要更少的代碼行，請注意，copyOfRange方法的第二個參數是要復制的范圍的初始索引，包括，而第三個參數是要復制的范圍的最終索引，在此示例中，要復制的范圍不包括索引9處的數組元素（其中包含字符a）。

java.util.Arrays類中的方法提供的一些其他有用的操作是：

在數組中搜索特定值以獲取其所在的索引（binarySearch方法）。

比較兩個數組以確定它們是否相等（equals方法）。

填充數組以在每個索引處放置特定值（fill方法）。

按升序對數組進行排序，這可以使用sort方法串行完成，也可以使用Java SE 8中引入的parallelSort方法并行完成，在多處理器系統上并行排序大型數組比串行數組排序更快。

Java編程語言使用“字段”和“變量”作為其術語的一部分，實例變量（非靜態字段）對于類的每個實例都是唯一的，類變量（靜態字段）是使用static修飾符聲明的字段，無論類被實例化多少次，都只有一個類變量的副本。局部變量在方法中存儲臨時狀態，參數是為方法提供額外信息的變量，局部變量和參數總是被歸類為“變量”（而不是“字段”），在命名字段或變量時，你應該（或必須）遵循規則和約定。

八種原始數據類型是：byte、short、int、long、float、double、boolean和char，java.lang.String類表示字符串。編譯器將為上述類型的字段分配合理的默認值，對于局部變量，永遠不會分配默認值。字面值是固定值的源代碼表示，數組是一個容器對象，它包含固定數量的單個類型的值，創建數組時，將建立數組的長度，創建后，其長度是固定的。