变量
正如你在上一课中所了解到的,对象将其状态存储在字段中。
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,具体取决于数据类型,然而,依赖于这样的默认值通常被认为是糟糕的编程风格。
下表总结了上述数据类型的默认值。
数据类型
默认值(对于字段)
byte
0
short
0
int
0
long
0L
float
0.0f
double
0.0d
char
'\u0000'
String(或任何对象)
null
boolean
false
局部变量略有不同;编译器永远不会为未初始化的局部变量分配默认值,如果无法初始化声明它的局部变量,请确保在尝试使用它之前为其赋值,访问未初始化的局部变量将导致编译时错误。
字面值
你可能已经注意到在初始化基本类型的变量时不使用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),或"S\u00ED Se\u00F1or"(SíSeñor,西班牙语)。始终对char字面值使用“单引号”,对字符串字面值使用“双引号”,Unicode转义序列可以在程序的其他地方使用(例如在字段名中),而不仅仅是在char或String字面值中。
Java编程语言还支持char和String字面值的一些特殊转义序列:\b(退格)、\t(制表符)、\n(换行)、\f(换页)、\r(回车)、 \"(双引号)、\'(单引号)和\\(反斜杠)。
还有一个特殊的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类表示字符串。编译器将为上述类型的字段分配合理的默认值,对于局部变量,永远不会分配默认值。字面值是固定值的源代码表示,数组是一个容器对象,它包含固定数量的单个类型的值,创建数组时,将建立数组的长度,创建后,其长度是固定的。