Primitive Data Types基本数据类型

The Java programming language is statically-typed, which means that all variables must first be declared before they can be used.Java编程语言是静态类型的，这意味着必须先声明所有变量，然后才能使用它们。This involves stating the variable's type and name, as you've already seen:这涉及到声明变量的类型和名称，正如您已经看到的：

int gear = 1;

Doing so tells your program that a field named "gear" exists, holds numerical data, and has an initial value of "1".这样做会告诉您的程序，一个名为“gear”的字段存在，它保存数值数据，初始值为“1”。A variable's data type determines the values it may contain, plus the operations that may be performed on it.变量的数据类型决定了它可能包含的值，以及可能对其执行的操作。In addition to int, the Java programming language supports seven other primitive data types.除了int之外，Java编程语言还支持其他七种基本数据类型。A primitive type is predefined by the language and is named by a reserved keyword.基元类型由语言预定义，并由保留关键字命名。Primitive values do not share state with other primitive values.基本值不与其他基本值共享状态。The eight primitive data types supported by the Java programming language are:Java编程语言支持的八种基本数据类型是：

• byte: The byte data type is an 8-bit signed two's complement integer.：byte数据类型是一个8位有符号2的补码整数。It has a minimum value of -128 and a maximum value of 127 (inclusive).它的最小值为-128，最大值为127（含）。The byte data type can be useful for saving memory in large arrays, where the memory savings actually matters.byte数据类型对于在大型数组中节省内存非常有用，而实际上节省内存很重要。They can also be used in place of int where their limits help to clarify your code; the fact that a variable's range is limited can serve as a form of documentation.它们也可以用来代替int，因为它们的限制有助于澄清代码；变量的范围是有限的这一事实可以作为文档的一种形式。

• short: The short data type is a 16-bit signed two's complement integer.：short数据类型是一个16位有符号2的补码整数。It has a minimum value of -32,768 and a maximum value of 32,767 (inclusive).它的最小值为-32768，最大值为32767（含）。As with byte, the same guidelines apply: you can use a short to save memory in large arrays, in situations where the memory savings actually matters.与byte一样，同样的准则也适用：在内存节省非常重要的情况下，可以使用short来在大型数组中节省内存。

• int: By default, the int data type is a 32-bit signed two's complement integer, which has a minimum value of -2³¹ and a maximum value of 2³¹-1.：默认情况下，int数据类型是32位带符号2的补码整数，最小值为-2³¹，最大值为2³¹-1。In Java SE 8 and later, you can use the int data type to represent an unsigned 32-bit integer, which has a minimum value of 0 and a maximum value of 2³²-1.在Java SE 8及更高版本中，可以使用int数据类型表示无符号32位整数，该整数的最小值为0，最大值为2³²-1。Use the Integer class to use int data type as an unsigned integer.使用Integer类将int数据类型用作无符号整数。See the section The Number Classes for more information.有关更多信息，请参阅数字类一节。Static methods like compareUnsigned, divideUnsigned etc have been added to the Integer class to support the arithmetic operations for unsigned integers.向Integer类添加了静态方法，如compareUnsigned、divideUnsigned等，以支持无符号整数的算术运算。

• long: The long data type is a 64-bit two's complement integer.：long数据类型是64位2的补码整数。The signed long has a minimum value of -2⁶³ and a maximum value of 2⁶³-1.有符号long的最小值为-2⁶³，最大值为2⁶³-1。In Java SE 8 and later, you can use the long data type to represent an unsigned 64-bit long, which has a minimum value of 0 and a maximum value of 2⁶⁴-1.在Java SE 8及更高版本中，可以使用long数据类型来表示无符号的64位long，其最小值为0，最大值为2⁶⁴-1。Use this data type when you need a range of values wider than those provided by int.当需要比int提供的值更宽的值范围时，请使用此数据类型。The Long class also contains methods like compareUnsigned, divideUnsigned etc to support arithmetic operations for unsigned long.Long类还包含compareUnsigned、divideUnsigned等方法，以支持无符号长整型的算术运算。

• float: The float data type is a single-precision 32-bit IEEE 754 floating point.：float数据类型是单精度32位IEEE 754浮点。Its range of values is beyond the scope of this discussion, but is specified in the Floating-Point Types, Formats, and Values section of the Java Language Specification.它的值范围超出了本文讨论的范围，但在Java语言规范的浮点类型、格式和值部分中有详细说明。As with the recommendations for byte and short, use a float (instead of double) if you need to save memory in large arrays of floating point numbers.与byte和short的建议一样，如果需要在大型浮点数数组中保存内存，请使用float（而不是double）。This data type should never be used for precise values, such as currency.此数据类型不应用于精确值，如货币。For that, you will need to use the java.math.BigDecimal class instead.为此，您将需要使用java.math.BigDecimal类。Numbers and Strings covers BigDecimal and other useful classes provided by the Java platform.数字和字符串讲解了BigDecimal和Java平台提供的其他有用类。

• double: The double data type is a double-precision 64-bit IEEE 754 floating point.：double数据类型是双精度64位IEEE 754浮点。Its range of values is beyond the scope of this discussion, but is specified in the Floating-Point Types, Formats, and Values section of the Java Language Specification.它的值范围超出了本文讨论的范围，但在Java语言规范的浮点类型、格式和值部分中有详细说明。For decimal values, this data type is generally the default choice.对于十进制值，此数据类型通常是默认选择。As mentioned above, this data type should never be used for precise values, such as currency.如上所述，此数据类型不应用于精确值，如货币。

• boolean: The boolean data type has only two possible values: true and false.：boolean数据类型只有两个可能的值：true和false。Use this data type for simple flags that track true/false conditions.将此数据类型用于跟踪真/假条件的简单标志。This data type represents one bit of information, but its "size" isn't something that's precisely defined.此数据类型表示一位信息，但其“大小”并不是精确定义的。

• char: The char data type is a single 16-bit Unicode character.：char数据类型是单个16位Unicode字符。It has a minimum value of '\u0000' (or 0) and a maximum value of '\uffff' (or 65,535 inclusive).它的最小值为'\u0000'（或0），最大值为'\uffff'（或65535）。

In addition to the eight primitive data types listed above, the Java programming language also provides special support for character strings via the java.lang.String class.除了上面列出的八种基本数据类型之外，Java编程语言还通过java.lang.String类提供对字符串的特殊支持。Enclosing your character string within double quotes will automatically create a new String object; for example, String s = "this is a string";.将字符串括在双引号内将自动创建一个新的String对象；例如，String s = "this is a string";。String objects are immutable, which means that once created, their values cannot be changed.String对象是不可变的，这意味着一旦创建，它们的值就不能更改。The String class is not technically a primitive data type, but considering the special support given to it by the language, you'll probably tend to think of it as such.String类在技术上不是一种原始数据类型，但是考虑到该语言对它的特殊支持，您可能会这样认为。You'll learn more about the String class in Simple Data Objects您将在简单数据对象中了解有关String类的更多信息

Default Values默认值

It's not always necessary to assign a value when a field is declared.声明字段时并不总是需要赋值。Fields that are declared but not initialized will be set to a reasonable default by the compiler.已声明但未初始化的字段将由编译器设置为合理的默认值。Generally speaking, this default will be zero or null, depending on the data type.一般来说，此默认值将为零或null，具体取决于数据类型。Relying on such default values, however, is generally considered bad programming style.然而，依赖这些默认值通常被认为是糟糕的编程风格。

The following chart summarizes the default values for the above data types.下图总结了上述数据类型的默认值。

Local variables are slightly different; the compiler never assigns a default value to an uninitialized local variable.局部变量略有不同；编译器从不为未初始化的局部变量指定默认值。If you cannot initialize your local variable where it is declared, make sure to assign it a value before you attempt to use it.如果无法在声明局部变量的位置初始化它，请确保在尝试使用它之前为其赋值。Accessing an uninitialized local variable will result in a compile-time error.访问未初始化的局部变量将导致编译时错误。

Literals直接常量

You may have noticed that the new keyword isn't used when initializing a variable of a primitive type.您可能已经注意到，初始化基元类型的变量时不使用new关键字。Primitive types are special data types built into the language; they are not objects created from a class.基元类型是语言中内置的特殊数据类型；它们不是从类创建的对象。A literal is the source code representation of a fixed value; literals are represented directly in your code without requiring computation.文字是固定值的源代码表示形式；文本直接在代码中表示，无需计算。As shown below, it's possible to assign a literal to a variable of a primitive type:如下图所示，可以将文本分配给基元类型的变量：

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

Integer Literals整数文字

An integer literal is of type long if it ends with the letter L or l; otherwise it is of type int.如果整型文字以字母L或l结尾，则其类型为long；否则它是int类型。It is recommended that you use the upper case letter L because the lower case letter l is hard to distinguish from the digit 1.建议您使用大写字母L，因为小写字母l很难与数字1区分。

Values of the integral types byte, short, int, and long can be created from int literals.整型byte、short、int和long的值可以从int文本创建。Values of type long that exceed the range of int can be created from long literals.超过int范围的long类型的值可以从long文本创建。Integer literals can be expressed by these number systems:整数文字可以用以下数字系统表示：

• Decimal: Base 10, whose digits consists of the numbers 0 through 9; this is the number system you use every day十进制：以10为基数，其数字由数字0到9组成；这是你每天使用的数字系统
• Hexadecimal: Base 16, whose digits consist of the numbers 0 through 9 and the letters A through F十六进制：以16为基数，其数字由数字0到9和字母A到F组成
• Binary: Base 2, whose digits consists of the numbers 0 and 1 (you can create binary literals in Java SE 7 and later)二进制：以2为基数，其数字由数字0和1组成（您可以在JavaSE7和更高版本中创建二进制文本）

For general-purpose programming, the decimal system is likely to be the only number system you'll ever use.对于通用编程来说，十进制可能是您唯一使用的数字系统。However, if you need to use another number system, the following example shows the correct syntax.但是，如果需要使用其他数字系统，下面的示例将显示正确的语法。The prefix 0x indicates hexadecimal and 0b indicates binary:前缀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;

Floating-Point Literals浮点文字

A floating-point literal is of type float if it ends with the letter F or f; otherwise its type is double and it can optionally end with the letter D or d.如果浮点文字以字母F或f结尾，则它的类型为float；否则它的类型是double，并且可以选择以字母D或d结尾。

The floating point types (float and double) can also be expressed using E or e (for scientific notation), F or f (32-bit float literal) and D or d (64-bit double literal; this is the default and by convention is omitted).浮点类型（float和double）也可以使用E或e（用于科学记数法）、F或f（32位浮点文字）和D或d（64位double文字；这是默认值，按照惯例省略）。

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

Character and String Literals字符和字符串文本

Literals of types char and String may contain any Unicode (UTF-16) characters.char和String类型的文本可以包含任何Unicode(UTF-16）字符。If your editor and file system allow it, you can use such characters directly in your code.如果编辑器和文件系统允许，可以直接在代码中使用这些字符。If not, you can use a "Unicode escape" such as '\u0108' (capital C with circumflex), or "S\u00ED Se\u00F1or" (Sí Señor in Spanish).如果不允许，您可以使用“Unicode转义”，例如'\u0108'（大写字母C加扬抑符）或"S\u00ED Se\u00F1or"（西班牙语中的Sí Señor）。Always use 'single quotes' for char literals and "double quotes" for String literals.始终对char文本使用“单引号”，对String文本使用“双引号”。Unicode escape sequences may be used elsewhere in a program (such as in field names, for example), not just in char or String literals.Unicode转义序列可以在程序的其他地方使用（例如在字段名中），而不仅仅是在char或String文本中。

The Java programming language also supports a few special escape sequences for char and String literals: \b (backspace), \t (tab), \n (line feed), \f (form feed), \r (carriage return), \" (double quote), \' (single quote), and \\ (backslash).Java编程语言还支持char和String文本的一些特殊转义序列：\b（退格），\t（制表符），\n（换行符），\f（换行符），\r（回车符），\"（双引号），\'（单引号）和\\（反斜杠）。

There's also a special null literal that can be used as a value for any reference type.还有一个特殊的null文本，可以用作任何引用类型的值。null may be assigned to any variable, except variables of primitive types.null可以分配给任何变量，但基元类型的变量除外。There's little you can do with a null value beyond testing for its presence.除了测试null值的存在性之外，您对null值几乎无能为力。Therefore, null is often used in programs as a marker to indicate that some object is unavailable.因此，null通常在程序中用作标记，表示某些对象不可用。

Finally, there's also a special kind of literal called a class literal, formed by taking a type name and appending ".class"; for example, String.class.最后，还有一种特殊的文本，称为类文本，它是由类型名和附加“.class”组成的；例如，String.class。This refers to the object (of type Class) that represents the type itself.这是指表示类型本身的对象（Class类型）。

Using Underscore Characters in Numeric Literals在数字文本中使用下划线字符

In Java SE 7 and later, any number of underscore characters (_) can appear anywhere between digits in a numerical literal.在JavaSE7及更高版本中，数字文字中数字之间的任意位置都可以出现任意数量的下划线字符（_）。This feature enables you, for example. to separate groups of digits in numeric literals, which can improve the readability of your code.例如，此功能使您能够，以数字文字分隔数字组，这可以提高代码的可读性。

For instance, if your code contains numbers with many digits, you can use an underscore character to separate digits in groups of three, similar to how you would use a punctuation mark like a comma, or a space, as a separator.例如，如果代码包含多个数字的数字，则可以使用下划线字符将数字分成三组，类似于使用逗号或空格等标点符号作为分隔符。

The following example shows other ways you can use the underscore in numeric literals:以下示例显示了在数字文本中使用下划线的其他方法：

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;

You can place underscores only between digits; you cannot place underscores in the following places:只能在数字之间加下划线；不能在以下位置放置下划线：

• At the beginning or end of a number在数字的开头或结尾
• Adjacent to a decimal point in a floating point literal与浮点文字中的小数点相邻
• Prior to an F or L suffix在F或L后缀之前
• In positions where a string of digits is expected在需要一串数字的位置

The following examples demonstrate valid and invalid underscore placements (which are highlighted) in numeric literals:以下示例演示了数字文字中有效和无效的下划线位置（突出显示）：

// 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_;