Java 语言基础
本项目主要介绍 Java 的基础语法知识，包括 Java 的关键字常量、变量、简单数据类型、 运算符、表达式等，同时也简要地介绍了 Java 与 C、C++等其他编程语言之间的差异。通过本 项目的学习，要求读者掌握几种主要的 Java 语句结构（分支、循环），学会基本的程序设计方 法，能独立设计和阅读简单的 Java 程序。这些内容是任何一门程序设计语言都必须包含的部 分，也是编程的基础。 掌握变量的概念，会使用常用数据类型、赋值运算符和算术运算符，会进行数据类型 转换，掌握键盘输入 学习程序设计的三大结构：顺序结构、条件选择结构、循环结构任务 1 学习 Java 基本数据类型
2.1.1 标识符和关键字 1．标识符 用来标识类名、变量名、方法名、类型名、数组名、文件名的有效序列称为标识符。简2
2 项目 单地说，标识符就是一个名字，它需要遵守标识符命名规范。 规范如下： （1）只能以字母、下划线（_）或美元符（$）开头，数字不能作为开头。 （2）不能包含美元符（$）以外的特殊符号。 （3）不能包含空格。 （4）可以是中文字符或日文字符。 （5）标识符中的字母是区分大小写的，Boy 和 boy 是不同的标识符。 下列标识符都是合法的标识符：Boy_$、www_56$、$89bird。
Java 语言使用 Unicode 标准字符集，最多可以识别 65535 个字符，Unicode 字符表的前 128 个字符刚好对应 ASCII 表。每个国家的“字母表”的字母都是 Unicode 表中的一个字符，比如 汉字中的“你”字就是 Unicode 表中的第 20320 字符。 Java 中的字母包括了世界上任何语言中的“字母表”，因此，Java 所使用的字母不仅包括 通常的拉丁字母，a、b、c 等，也包括汉语中的汉字，日文里的片假名、平假名，朝鲜文以及 其他许多语言中的文字。 2．关键字 Java 中赋予一种特定的含义、用作专门用途的字符串称作关键字（Keyword）。不可以把 这类词作为名字来用。Java 的关键字有： 数据类型相关的关键字：boolean、int、long、short、byte、float、double、char、class 和 interface。 流程控制相关的关键字：if、else、do、while、for、switch、case、default、break、continue、 return、try、catch 和 finally。 修饰符相关的关键字：public、protected、private、final、void、static、strictfp、abstract、 transient、synchronized、volatile 和 native。 动作相关的关键字：package、import、throw、throws、extends、implements、this、super、 instanceof 和 new。 其他关键字：true、false、null、goto 和 const。 需注意，关键字一律用小写字母表示。 2.1.2 基本数据类型 基本数据类型是指 Java 固有的数据类型，是编译器本身能理解的。 在 Java 中，每个存放数据的变量都是有类型的，如： char ch; float x; int a,b,c; ch 是字符型的，会分配到两个字节内存。不同类型的变量在内存中分配的字节数不同，
2 项目 同时存储方式也是不同的。所以给变量赋值前需要先确定变量的类型，确定了变量的类型，即 确定了数据需分配内存空间的大小和数据在内存的存储方式。 1．布尔型——boolean 布尔型又名逻辑型，它是最简单的数据类型，在流程控制时常会用到。有 C++编程经验 的学习者，要特别看清，Java 中的布尔型数据不对应任何整数值。 布尔型常量：true 和 false。需要注意的是，布尔常量的组成字母一律都是小写的。 布尔型变量：以 boolean 定义的变量，如：
boolean b = true; //定义变量 b 是 boolean，且值为 true
2．字符类型——char （1）字符常量 字符常量指用单引号括起来的单个字符，如'a'，'A'。 请特别注意，字符的定界符是单引号，而非双引号。除了以上所述形式的字符常量值之 外，Java 还允许使用一种特殊形式的字符常量值，通常用于表示难以用一般字符来表示的字 符，这种特殊形式的字符是以一个“\”开头的字符序列，称为转义字符。Java 中的常用转义 字符如表 2-1 所示。 表 2-1 常用转义字符 转义字符 描述 \ddd 1～3 位八进制数所表示的字符（ddd） \uxxxx 1～4 位十六进制数所表示的字符（xxxx），如“\u0061”表示“a” \' \' 单引号字符和双引号字符 \\ 反斜杠 \r 回车 \n 换行 \t 横向跳格 \f 走纸换页 \b 退格 （2）字符变量
以 char 定义的变量，如 char c='a';。
要特别加以说明的是，Java 的文本编码采用 Unicode 空符集，而 Java 字符是 16 位无符号 型数据，所以一个字符变量在内存中占两个字节。
例 2.1 编程测试十六进制数 41、51 对应的字符，并相隔一个 tab 位输出。
分析：已知十六进制数，求字符。根据表 2-1，可用“\uxxxx”的转义字符形式来表示所 求字符，然后直接输出即可。
2
项目
class HDTest{
public static void main(String[] args){ char a='\u0041'; char b='\u0051'; System.out.println(a+\t+b); //字符之间以若干空格相间 } } 程序运行结果：A Q 3．定点类型（整型） 定点类型包括字节型、整型、短整型和长整型，它们在内存中虽然占据的字节数不相同， 但它们的存储方式是同样的，所以把这些类型归并在一起讨论。 “定点”的意思是把小数点定在末尾，小数点后没有数字的数据，Java 中通常把它们称 为整数。 （1）定点常量 定点常量即整型常数，它可用十进制、八进制、十六进制三种方式来表示。 十进制定点常量：如 123、-456、0。 八进制定点常量：以 0 前导，形式为 0dd...d。如 0123 表示十进制数 83，-011 表示十进制 数-9。 十六进制定点常量：以 0x 或 0X 开头，如 0x123 表示十进制数 291，-0X12 表示十进制 数-18。 （2）定点变量 定点变量即整型变量，可细分成字节型变量、整型变量、短整型变量和长整型变量四种。 表 2-2 对各种定点变量所占内存字节数和数值范围作了简要说明。 表 2-2 关于整型变量的说明 定点变量 占字节数 范围 字节型 byte 1 [-128~127] 短整型 short 2 [-32 768~32 767] 整型 int 4 [-2 147 483 648~2 147 483 647] 长整型 long 8 [-263～263-1] 需要注意的是，如果要将一个定点常量赋值给一个定点变量，需要查验常量是否在该变 量的表达范围内，如超出范围程序会编译出错。 如： byte b = 200; //JCreator 编译时错误信息是“可能损失精度” 例 2.2 阅读程序，分析其运行结果。 class OHTest{
2 项目 int x = 010; System.out.println("x = "+ x); int y = 0x10; System.out.println("y = " + y); } } 程序运行结果略，请思考并调试验证。 4．浮点型（实型） （1）浮点常量 即带小数点的实型数值，可以由直接带小数点的数值和科学计数法两种形式来表示： 带小数点的数值形式：由数字和小数点组成，如 0.123、.123、123.、123.0。 科学计数法表示形式：由一般实数和 e±n（E±n）组成，如 12.3e3、5E-3，它们分别表示 12.3×103和 5×10-3 。需要注意的是，e 或 E 之前必须有数字，且 e 或 E 后面的指数必须为整数。 （2）浮点变量 浮点变量有单精度变量和双精度变量之分，不同的精度开销的内存字节数和表达的数值 范围均有区别。两种浮点变量占内存字节数和数值范围见表 2-3。 表 2-3 单精度变量和双精度变量简要说明 浮点变量 占字节数 范围 单精度（float） 4 3.4e-038～3.4e+038，-3.4e+038～-3.4e-038 双精度（double） 8 1.7e-308～1.7e+308，-1.74e+038～-3.4e-038 浮点常量也有单精度和双精度之分，前面列出的常量均是双精度常量，如果要特别说明 为单精度常量，可以在数据末尾加上 f 或 F 作为后缀，如 12.34f。如果要特别指明一个浮点 常量是双精度常量，数据末尾不需要添加后缀，或者在数据末尾加上 d 或 D 作为后缀，如 12.34d。 2.1.3 常量和变量 1．常量 常量是不能被程序修改的固定值，在程序运行之前，其值已经确定了。常量一般是字符 串和字符常量，且可以是不同的数据类型。如：字符常量，字符串常量，整型常量，实型常量， 逻辑常量，字符串常量。 2．变量 变量是 Java 程序中的基本存储单元，它具有名称、类型、值和作用域等特性。Java 程序 通过变量来操纵内存中的数据，在使用任何变量之前必须先定义。 说明： （1）Java 在使用一个变量之前要对变量的类型加以声明。
2 项目 （2）Java 中一个变量的声明就是一条完整的 Java 语句，所以应该在结尾使用分号。 （3）变量的命名规则如下： 变量必须以一个字母开头。 变量名是一系列字母或数字的任意组合。 在 Java 中字母表示 Unicode 中相当于一个字母的任何字符。 数字也包含 0～9 以外的其他地位与一个数字相当的任何 Unicode 字符。 版权信息符号©和空格不能在变量名中使用。 变量名区分大小写。 变量名的长度基本上没有限制。如想知道 Java 到目前为止哪些 Unicode 字符是字母
的话，可以使用 Character 类中的 isJavaIdentifierStart 以及 isJavaIdentifierPart 方法进 行检查。 变量名中不能使用 Java 的保留字。 （4）可在一条语句中进行多个变量的声明，不同变量之间用逗号分隔。 3．变量的赋值和初始化 变量的值可以通过两种方法获得，一种是赋值，给一个变量赋值需要使用赋值语句。另 外一种就是初始化，说是初始化，其实还是一个赋值语句。例如： int a =10; //这就是一个变量初始化的过程 下面两条语句的功能和上面一条的功能相同，只是将变量的声明和赋值分开来进行的。 int a; a =10; //在赋值语句的结尾应该是用分号来结束。 说明： （1）在 Java 中绝对不能出现未初始化的变量，在使用一个变量前必须给变量赋值。 （2）声明可以在代码内的任何一个位置出现，但在方法的任何代码块内只可对一个变量 声明一次。
任务 2 使用运算符和表达式
运算符指明对操作数所进行的运算。按操作数的数目来分，可以有一元运算符（如++、--）， 二元运算符（如+、>）和三元运算符（如?:），它们分别对应于一个、两个和三个操作数。对 于一元运算符来说，可以有前缀表达式（如++i）和后缀表达式（如 i++），对于二元运算符来 说，则采用中缀表达式（如 a+b）。按照运算符功能来分，基本的运算符有下面几类： （1）算术运算符（+、-、*、/、%）。 （2）自加和自减运算符（++、--）。 （3）关系运算符（>、<、>=、<=、==、!=）。 （4）逻辑运算符（!、&&、||）。 （5）赋值运算符（=及扩展赋值运算符如+=）。2 项目 （6）位运算符（>>、<<、>>>、&、|、^、～）。 （7）条件运算符（?:）。 （8）其他（包括分量运算符“.”、类型转换运算符(类型)、方法调用运算符()等）。 本节中我们主要讲述前 5 类运算符，其他的会在以后涉及到。 2.2.1 算术运算符和表达式 （1）加减运算符+、-。例如 2+39、908.98-23 等。加减运算符是双目运算符，即连接两 个操作数的运算符。加减运算符的结合方向是从左到右。例如：2+3-8，先计算 2+3，然后再 将得到的结果减 8。加减运算符的操作数是整型或浮点型数据。 （2）乘、除和求余运算符*、/、%。例如 2*39、908.98/23 等。 *、/、%运算符是双目运算符，即连接两个操作数的运算符。*、/、%运算符的结合方向 也是从左到右，例如 2*3/8，先计算 2*3，然后再将得到的结果除以 8。乘除运算符的操作数 是整型或浮点型数据。 用算术符号和括号连接起来的符合 Java 语法规则的表达式，如 x+2*y-30+3*(y+5)，像这 样的式子我们称为算术表达式。 2.2.2 自加和自减运算符 自加、自减运算符是单目运算符，可以放在操作数之前，也可以放在操作数之后。操作数 必须是一个整型或浮点型变量。作用是使变量的值增 1 或减 1，如： ++x、--x 表示在使用 x 之前，先使 x 的值加 1 减 1。 x++、x--表示在使用 x 之后，使 x 的值加 1 减 1。 粗略的看，++x 和 x++的作用相当于 x=x+1。但++x 和 x++的不同之处在于，++x 是先执 行 x=x+1 再使用 x 的值，而 x++是先使用 x 的值再执行 x=x+1。如果 x 的原值是 5，则 对于 y=++x；先将 x 的值变为 6，然后赋给 y，y 的值为 6。 对于 y=x++；先将 x 的值赋给 y，y 得到的值为 5，然后 x 的值变为 6。 2.2.3 关系运算符和表达式 关系运算符用来比较两个值的关系。关系运算符的运算结果是 boolean 型，当运算符对应 的关系成立时，运算结果是 true，否则是 false。
例如，10<9 的结果是 false，5>1 的结果是 true，3!=5 的结果是 true，10>20-17 的结果为 true。因为算术运算符的级别高于关系运算符，10>20-17 相当于 10>(20-17)，结果当然是 true。
结果为数值型的变量或表达式可以通过关系运算符形成关系表达式。如：4>8、(x+y)>80。 Java 语言提供的关系运算符如表 2-4 所示。
2 项目 表 2-4 关系运算符 运算符 名称 用途举例 < 小于 a<b，3<4 <= 小于等于 a<=b，x<=8 > 大于 a>b，9>5 >= 大于等于 a>=b，y>=x == 等于 a==b，x==3*4 != 不等于 a!=b，x!=7 2.2.4 逻辑运算符和表达式 逻辑运算符包括&&、||、!。其中&&、||为二目运算符，实现逻辑与逻辑或。！为单目运 算符，实现逻辑非。逻辑运算符的操作数必须是 boolean 型数据，逻辑运算符可以用来连接 关系表达式。 表 2-5 给出了逻辑运算符的用法和含义。 表 2-5 逻辑运算符 运算符 名称 用途举例 ! 逻辑非 !b && 逻辑与 (a>b)&&(c<d) || 逻辑或 (a>b)||(c<d) 结果为 boolean 型的变量或表达式可以通过逻辑运算符合成为逻辑表达式。 用逻辑运算符进行逻辑运算，其运算结果为逻辑类型：true 或 false。
例如，2>8&&9>2 的结果为 false，2>8||9>2 的结果为 true。由于关系运算符的级别高于&&、 ||的级别，2>8&&9>2 相当于(2>8)&&(9>2)。 逻辑运算符“&&”和“||”也称做短路逻辑运算符，这是因为当条件 1 的值是 false 时， “&&”运算符在运算时不再去计算条件 2 的值，直接就得出“条件 1&&条件 2”的结果是 false。当条件 1 的值是 true 时，“||”运算符号在运算时也不再去计算条件 2 的值，直接就得出 “条件 1||条件 2”的结果是 true。 2.2.5 赋值运算符和表达式 赋值运算符是双目运算符，左面的操作数必须是变量，不能是常量或表达式，见表 2-6。 设 x 是一个整型变量，y 是一个 boolean 型变量，x=20 和 y = true 都是正确的赋值表达式，赋
2 项目 值运算符的优先级较低，结合方向从右到左。赋值表达式的值“=”左面变量的值。注意不要 将赋值运算符“=”与等号运算符“==”混淆。 表 2-6 赋值运算符 运算符 说明 等效表达式 = a=a +=\-=\*=\/=\%= a+=a a=a+b，a=a-b
&=\|=\^= a&=a a=a&b，a=a|b，a=a^b
>>=\<<=\>>>= a>>=b，a<<=b，a>>>=b a=a>>b，a=a<<b，a=a>>>b 2.2.6 运算符的优先级 Java 语言中运算符的优先级如表 2-7 所示。 表 2-7 运算符优先级表 优先级 描述 运算符 结合性 1 分隔符 () [] ,; 从左到右 2 自增自减运算\逻辑非 ! +（正）-（负） ~ ++ -- 从右向左 3 算术乘除运算 * / % 从左向右 4 算术加减运算 +（加）-（减） 从左向右 5 移位运算 << >> >>> 从左向右 6 大小关系运算 < <= > >= 从左向右 7 相等关系运算 == != 从左向右 8 按位与运算 & 从左向右 9 按位异或运算 ^ 从左向右 10 按位或运算 | 从左向右 11 逻辑与运算 && 从左向右 12 逻辑或运算 || 从左向右 13 三目条件运算 ?: 从右向左 14 赋值运算 = 从右向左 说明： （1）该表中优先级按照从高到低的顺序书写，也就是优先级为 1 的优先级最高，优先级 为 14 的优先级最低。 （2）结合性是指运算符结合的顺序，通常都是从左到右。从右到左的运算符最典型的就
2 项目 是负号，例如 3+-4，则意义为 3 加-4，负号首先和运算符右侧的内容结合。 （3）注意区分正负号和加减号，以及按位与和逻辑与的区别。 其实在实际的开发中，不需要去记忆运算符的优先级别，也不需要刻意地使用运算符的 优先级别，对于不清楚优先级的地方使用小括号去进行替代，示例代码： int m = 12; int n = m << 1 + 2; int n = m << (1 + 2); //这样更直观
习 题
1．举例说明在什么情况下会发生自动类型转换。 2．为抵抗洪水，解放军战士连续作战 89 小时，编程计算共多少天零多少小时。 3．自定义一个整数，输出该数分别与 1 到 10 相乘的结果。 4．小明要到美国旅游，可是那里的温度是以华氏度为单位记录的。他需要一个程序将华 氏温度（80 度）转换为摄氏度，并以华氏度和摄氏度为单位分别显示该温度。编写程序达成 小明的要求。提示：摄氏度与华氏度的转换公式为：摄氏度=5/9.0*（华氏度-32）。任务 3 初识 Java 语句
2.3.1 Java 语句概述 Java 里的语句可分为以下 5 类： 1．方法调用语句 System.out.println("Hello World!"); 2．表达式语句 由一个表达式构成一个语句，最典型的是赋值语句，如：x=69;。在一个表达式的最后加 上一个分号就构成了一个语句，分号是语句不可缺少的部分。 3．复合语句 可以用{}把一些语句括起来构成复合语句，如： { y=43+x; System.out.println("Hello World!"); } 4．控制语句 包括选择语句和 switch 开关语句。2
项目
5．package 和 import 语句 （1）package 语句
通过关键字 package 声明包语句。Package 语句作为 Java 源文件的第一条语句，指明该源 文件定义的类所在的包。Package 语句的一般格式为： Package 包名; 如果源文件中省略了 package 语句，那么源文件中定义的类被默认为是无名包的一部分， 即源文件中定义的类在同一个包中，但该包没有名字。 包名可以是一个合法的标识符，也可以是若干个标识符加“.”分隔而成，例如： package sun; package sun.moon; 程序如果使用了包语句，那么要先将源文件保存到包所在的目录中，再编译源文件。 （2）import 语句 使用 import 语句可以引入包中的类。在编写源文件时，除了自己编写类外，经常需要用 到 Java 提供的许多类，这些类可能在不同的包中。在学习 Java 时，可以使用已经存在的类。 尽量避免一切从头做起。
为了能使用 Java 提供的类，可以使用 import 语句来引入包中类。在一个 Java 源文件中， 可以有多个 import 语句，它们必须写在 package 语句和源文件中类的定义之前，Java 提供了 130 多个包。 2.3.2 选择语句 所谓选择语句就是对语句中不同条件的值进行判断，进而根据不同的条件执行不同的语 句。在分支语句中主要有两个语句：if 条件语句和 switch 多分支语句。下面对这两个语句进行 详细的介绍。 简单的 if 条件语句是条件语句的一种形式，它针对某种条件做出相应的处理。通常表现 为“如果满足某种条件，就进行某种处理”。例如，聪聪的妈妈对聪聪说“如果你这次考试得 100 分，星期天就带你去公园玩”。这句话通过伪代码描述成算法如下： if(聪聪考试得 100 分){ 星期天带聪聪去公园玩 } 实际上，上面的代码就是简单的 if 条件语句，其语法格式如下： if(条件表达式){ 语句序列 } 条件表达式：必要参数。其值可以由多个表达式组成，但最后结果一定是 boolean 类型， 也就是结果只能是 true 或 false。 语句序列：可选参数。一条或多条语句，当表达式的值为 true 时执行这些语句。当语句 序列省略时，要么保存其外面的大括号，要么去掉大括号，然后在 if 语句的末尾添加分号“;”。 例如，下面的两行代码都是正确的。
2 项目 if(聪聪考试得 100 分); if(聪聪考试得 100 分){} 在简单的 if 条件语句中，if 是 Java 中的关键字，当系统执行到 if 关键字时，就会去判断 它后面的小括号中的条件表达式是否为 true，如果为 true，就执行其后面大括号中的语句序列， 否则将忽略大括号中的程序代码，继续向下执行。 1．if...else 条件语句 if...else 条件语句是最常用的一种形式，它针对某种条件有选择地做出处理。通常表现为 “如果满足某种条件，就进行某种处理，否则就进行另一种处理”。例如，要判断指定年的 2 月份的天数，通过伪代码描述的算法如下： if(指定年为闰年){ 2 月份为 29 天 }else{ 2 月份为 28 天 } 实际上，上面代码就是 if...else 条件语句，其语法格式如下： if(条件表达式){ 语句序列 1 }else{ 语句序列 2 } 条件表达式：必要参数。其值可以由多个表达式组成，但是最后结果一定是 boolean 类型， 也就是其结果只能是 true 或 false。 语句序列 1：可选参数。一条或多条语句，当表达式的值为 true 时执行这些语句。当该语 句序列省略时，要么保留其外面的大括号，要么去掉大括号，然后在 if 关键字后面添加分号 “;”。例如，下面的两段代码都是正确的。 //代码段 1 if(指定年为闰年); else{ 2 月份为 28 天 } //代码段 2 if(指定年为闰年){} else{ 2 月份为 28 天 } 语句序列 2：可选参数。一条或多条语句，当表达式的值为 false 时执行这些语句。当该 语句序列省略时，要么保留其外面的大括号，要么去掉大括号，然后在 else 关键字后面添加 分号“;”。例如，下面的两段代码都是正确的。 //代码段 1 if(指定年为闰年){ 2 月份为 29 天 }else;
2 项目 //代码段 2 if(指定年为闰年){ 2 月份为 29 天 }else{}
在 if...else 条件语句中，if 和 else 是 Java 中的关键字，当系统执行到 if 关键字时，就会去 判断它后面的小括号中的条件表达式是否为 true，如果为 true，就执行其后面大括号中的语句 序列 1，否则将执行 else 后面的大括号中的语句序列 2。 2．if...else if 多分支语句 if...else if 多分支语句用于针对某一事件的多种情况进行处理。通常表现为“如果满足某 种条件，就进行某种处理，否则如果满足另一种条件才执行另一种处理”。例如，聪聪和妈妈 要从公园回家，如果步行，需要 30 分钟；如果乘公交车，则需要 10 分钟；如果乘计程车，只 需要 5 分钟。针对该事件通过伪代码描述的算法如下： if(步行){ 需要 30 分钟 }else if(乘公交车){ 需要 10 分钟 }else{ 乘计程车则只需要 5 分钟 } 实际上，上面的代码就是 if...else if 多分支语句，其语法格式如下： if(条件表达式 1){ 语句序列 1 }else if(条件表达式 2){ 语句序列 2 }else{ 语句序列 3 } 条件表达式 1 和条件表达式 2：必要参数。其值可以由多个表达式组成，但是最后结果一 定是 boolean 类型，也就是其结果只能是 true 或 false。
语句序列 1：可选参数。一条或多条语句，当条件表达式 1 的值为 true 时执行这些语句。 当该语句序列省略时，要么保留其外面的大括号，要么将大括号替换为分号“;”。例如，下面 的两段代码都是正确的。 //代码段 1 if(步行){ }else if(乘公交车){ 需要 10 分钟 }else{ 乘计程车则只需要 5 分钟 } //代码段 2 if(步行); else if(乘公交车){
2 项目 需要 10 分钟 }else{ 乘计程车则只需要 5 分钟 } 语句序列 2：可选参数。一条或多条语句，当条件表达式 1 的值为 false，条件表达式 2 的值为 true 时执行这些语句。同语句序列 1 相同，该语句序列也可以省略，省略原则同语句 序列 1 相同，这里不作介绍。 语句序列 3：可选参数。一条或多条语句，当条件表达式 1 的值为 false，条件表达式 2 的值也为 false 时，执行这些语句。同语句序列 1 相同，该语句序列也可以省略，省略原则同 语句序列 1 相同。 3．switch 语句 Java 程序设计语言中还有另一种选择结构，即 switch 选择结构，它常常用于等值判断的 状况。例如：韩嫣参加计算机编程大赛： 如果获得第一名，将参加麻省理工大学组织的 1 个月夏令营。 如果获得第二名，将奖励惠普笔记本电脑一部。 如果获得第三名，将奖励移动硬盘一个。 否则，不给任何奖励。 这个问题属于等值判断的情况，既可以使用多重 if 选择结构实现，也可以使用 switch 选 择结构解决。使用多重 if 选择结构实现留给读者思考。对该事件使用 switch 语句通过伪代码 描述的算法如下： int mingCi = 1; switch (mingCi) { case 1: 参加麻省理工大学组织的 1 个月夏令营; break; case 2: 奖励惠普笔记本电脑一部; break; case 3: 奖励移动硬盘一个; break; default: 没有任何奖励; } 具体编码如下： int mingCi = 1; switch (mingCi) { case 1: System.out.println("参加麻省理工大学组织的 1 个月夏令营"); break; case 2:
2 项目 System.out.println("奖励惠普笔记本电脑一部"); break; case 3: System.out.println("奖励移动硬盘一个"); break; default: System.out.println("没有任何奖励 "); } Switch 选择结构的语法为： switch (表达式) { case 常量 1: 语句; break; case 常量 2: 语句; break; …… default: 语句; } 比较 switch 和多重 if 选择结构，其异同点如下： 相同点：都是用来处理多分支条件的结构。 不同点：switch 选择结构只能处理等值条件判断的情况，而且条件必须是整型变量或字符 型变量；多重 if 选择结构，没有 switch 选择结构的限制，特别适合某个变量处于某个连续区 间时的情况使用。 2.3.3 循环语句 所谓循环语句就是在满足条件的情况下反复执行同一个操作。在 Java 中，提供了 3 种常 用的循环语句，分别是：for 循环语句、while 循环语句和 do...while 循环语句。下面分别对这 3 种循环语句进行介绍。 1．for 语句 for 循环在第一次执行之前要进行初始化，随后会进行条件测试。 例如，要计算 1～100 之间所有整数的和，就可以使用 for 循环语句。具体代码如下： int sum=0; for(int i=1;i<=100;i++){ sum+=i; } System.out.println("1 到 100 之间所有整数的和是："+sum); 在对 for 循环语句有一个初步的认识后，下面给出 for 循环语句的语法格式： for(初始化语句;循环条件;迭代语句){ 语句序列 }
2 项目 初始化语句：为循环变量赋初始值的语句，该语句在整个循环语句中只执行一次。 循环条件：决定是否进行循环的表达式，其结果为 boolean 类型，也就是其结果只能是 true 或 false。 迭代语句：用于改变循环变量的值的语句。 语句序列：也就是循环体，在循环条件的结果为 true 时，重复执行。 for 循环语句执行的过程是：先执行为循环变量赋初始值的语句，然后判断循环条件，如 果循环条件的结果为 true，则执行一次循环体，否则直接退出循环，最后执行迭代语句，改变 循环变量的值，至此完成一次循环；接下来将进行下一次循环，直到循环条件的结果为 false， 才结束循环。 在使用 for 语句时，一定要保证循环可以正常结束，也就是必须保证循环条件的结果存在 为 false 的情况，否则循环体将无休止的执行下去，从而形成死循环。例如，下面的循环语句 就会造成死循环，原因是 i 永远大于等于 1。 for(int i=1;i>=1;i++){ System.out.println(i); } 2．while 语句 while 循环语句也称为前测试循环语句，它的循环重复执行方式，是利用一个条件来控制 是否要继续重复执行这个语句。while 循环语句与 for 循环语句相比，无论是语法还是执行的 流程，都较为简明易懂。例如，前面实现的计算 1～100 之间所有整数的和，也可以使用 while 循环语句实现。具体代码如下： int sum=0; int i=1; while (i<=100){ sum+=i; i++; } System.out.println("1 到 100 之间所有整数的和是："+sum); //输出计算结果 在对 while 循环语句有一个初步的认识后，下面给出 while 循环语句的语法格式： while(条件表达式){ 语句序列 } 条件表达式：决定是否进行循环的表达式，其结果为 boolean 类型，也就是其结果只能是 true 或 false。 语句序列：也就是循环体，在条件表达式的结果为 true 时，重复执行。 while 循环语句之所以命名为前测试循环，是因为它要先判断此循环的条件是否成立，然 后才完成重复执行的操作。也就是说，while 循环语句执行的过程是：先判断条件表达式，如 果条件表达式的值为 true，则执行循环体，并且在循环体执行完毕后，进入下一次循环，否则 退出循环。
2 项目 在使用 while 语句时，同样要保证循环可以正常结束，也就是必须保证条件表达式的值存 在为 false 的情况，否则将形成死循环。例如，下面的循环语句就会造成死循环，原因是 i 永 远都小于 100。 int i=1; while(i<=100){ System.out.println(i); //输出 i 的值 } 3．do…while 语句 do...while 循环语句也称为后测试循环语句，它的循环重复执行方式，也是利用一个条件 来控制是否要继续重复执行这个语句。与 while 循环不同的是，它先执行一次循环语句，然后 再去判断是否继续执行。例如，前面实现的计算 1～100 之间所有整数的和，也可以使用 do...while 循环语句实现。具体代码如下： int sum=0; int i=1; do{ sum+=i; i++; } while (i<=100); System.out.println("1 到 100 之间所有整数的和是："+sum); 在对 do…while 循环语句有一个初步的认识后，下面给出 do…while 循环语句的语法格式： do{ 语句序列 } while(条件表达式); //注意：语句结尾处的分号“;”一定不能少 语句序列：也就是循环体，循环开始时首先被执行一次，然后在条件表达式的结果为 true 时，重复执行。 条件表达式：决定是否进行循环的表达式，其结果为 boolean 类型，也就是其结果只能是 true 或 false。 do...while 循环语句执行的过程是：先执行一次循环体，然后再判断条件表达式，如果条 件表达式的值为 true，则继续执行，否则跳出循环。也就是说，do...while 循环语句中的循环 体至少被执行一次。 在使用 do...while 语句时，也一定要保证循环可以正常结束，也即条件表达式的值存在为 false 的情况，否则将形成死循环。例如，下面的循环语句就会造成死循环，原因是 i 永远都小 于 100。 int i=1; do{ System.out.println(i); } while(i<=100);
while 和 do…while 唯一的区别就是 do…while 至少会执行一次。而在 while 循环结构中， 若条件第一次就为 false，那么其中的语句根本不会被执行。在实际应用中，while 比 do…while 更常用一些。
2
项目
2.3.4 break 和 continue 语句
break 和 continue 语句是和循环语句紧密相关的两种语句。 1．break 语句
break 语句在前面的 switch 语句中已经出现过，功能是中断 switch 语句的执行。在循环语 句中，break 语句的作用也是中断循环语句，即结束循环语句的执行。 break 语句可以用在 3 种循环语句的内部，功能完全相同。下面以 while 语句为例来说明 break 语句的基本使用及其功能。 示例代码： int i = 0; while(i < 10){ i++; if(i == 5){ break; }} 则该循环在变量 i 的值等于 5 时，满足条件，然后执行 break 语句，结束整个循环，接着 执行循环后续的代码。 在循环语句中，可以使用 break 语句中断正在执行的循环。 在实际的代码中，结构往往会因为逻辑比较复杂，而存在循环语句的嵌套，如果 break 语 句出现在循环嵌套的内部时，则只结束 break 语句所在的循环，对于其他的循环没有影响，示 例代码如下： for(int i = 0; i < 10; i++){ for(int j = 0; j < 5; j++){ System.out.println(j); if(j == 3){ break; } } } 上例中 break 语句因为出现在循环变量为 j 的循环内部，则执行到 break 语句时，只中断 循环变量为 j 的循环，而对循环变量为 i 的循环没有影响。 在上面的示例代码中，如果需要中断外部的循环，则可以使用语法提供的标签语句来标 识循环的位置，然后跳出标签对应的循环。示例代码如下： lable1: for(int i = 0; i < 10; i++){ for(int j = 0; j < 5; j++){ System.out.println(j); if(j == 3){ break label1; } } }
2 项目 说明：这里的 label1 是标签的名称，可以为 Java 语言中任意合法的标识符，标签语句必 须和循环匹配使用，使用时书写在对应的循环语句的上面，标签语句以冒号结束。如果需要中 断标签语句对应的循环时，采用 break 后跟标签名的方式中断对应的循环。在该示例代码中 break 语句中断的是循环变量为 i 的循环。 同样的功能也可以使用如下的逻辑实现： boolean b = false; for(int i = 0; i < 10; i++){ for(int j = 0; j < 5; j++){ System.out.println(j); if(j == 3){ b = true; break; } } if(b){ break; } } 该示例代码中，通过组合使用两个 break 以及一个标识变量，实现跳出外部的循环结构。 2．continue 语句 continue 语句只能使用在循环语句内部，功能是跳过该次循环，继续执行下一次循环结构. 在 while 和 do…while 语句中 continue 语句跳转到循环条件处开始继续执行，而在 for 语句中 continue 语句跳转到迭代语句处开始继续执行。 下面以 while 语句为例，来说明 continue 语句的功能，示例代码如下： int i = 0; while(i < 4){ i++; if(i == 2){ continue; } System.out.println(i); } 则该代码的执行结果是： 1 3 4 在变量 i 的值等于 2 时，执行 continue 语句，则后续未执行完成的循环体将被跳过，而直 接进入下一次循环。在实际的代码中，可以使用 continue 语句跳过循环中的某些内容。 和前面介绍的 break 语句类似，continue 语句使用在循环嵌套的内部时，也只是跳过所在 循环的结构，如果需要跳过外部的循环，则需要使用标签语句标识对应的循环结构。示例代码 如下：
2 项目 lable1: for(int i = 0; i < 10; i++){ for(int j = 0; j < 5; j++){ System.out.println(j); if(j == 3){ continue label1; } } } 这样在执行 continue 语句时，就不再是跳转到 j++语句，而是直接跳转到 i++语句。 在实际的代码中，可以根据需要使用 break 和 continue 语句调整循环语句的执行，break 语句的功能是结束所在的循环，而 continue 语句的功能是跳过当次循环未执行的代码，直接执 行下一次循环。
习 题
1．画出流程图并使用 if 条件结构实现：岳灵珊同学参加了 Java 课程的学习，他父亲岳不 群和母亲宁中则承诺： 如果岳灵珊的考试成绩==100 分，父亲给她买辆车； 如果岳灵珊的考试成绩>=90 分，母亲给她买台笔记本电脑； 如果岳灵珊的考试成绩>=60 分，母亲给她买部手机； 如果岳灵珊的考试成绩<60 分，没有礼物。 2．什么情况下可以使用 switch 结构代替多重 if 条件结构。习题 1 可以用 switch 结构实现 吗？如果可以，用 switch 结构实现，如果不可以，说明原因。 3．使用循环输出：100，95，90，85，...5。先画出流程图，再编程实现。 4．说明在循环中使用 break 和 continue 结束和终止循环的区别。 5．简述 while、do…while、for 循环之间的异同。 6．开发一个标题为“FlipFlop”的游戏应用程序。它从 1 计数到 100，遇到 3 的倍数就替 换为单词“Flip”，5 的倍数就替换为单词“Flop”，既为 3 的倍数又为 5 的倍数则替换为单词 “FlipFlop”。 提示：使用%运算符取得数字的余数。循环从循环变量 i 为 1 开始，循环次数是 100 次， 在循环的过程中，需要完成的任务是，检测是 3 的倍数，输出“Flip”，检测是 5 的倍数，输 出“Flop”，检测既是 3 的倍数又是 5 的倍数，输出“FlipFlop”，其余情况下输出当前数字。任务 4 学习数组
数组是有序数据的集合，数组中的每个元素用相同的数组名和下标来唯一地确定。2 项目 2.4.1 数组声明 数组的声明包括数组的名字、数组包含元素的数据类型。 type arrayName[]; 其中：类型（type）可以为 Java 中任意的数据类型，包括简单类型和组合类型，数组名 arrayName 为一个合法的标识符，[]指明该变量是一个数组类型变量。例如： int intArray[]; 声明了一个整型数组，数组中的每个元素为整型数据。与 C、C++不同，Java 在定义数组 时并不为数组元素分配内存，因此[]中不用指出数组中元素个数，即数组长度，而且对于如上 定义的一个数组是不能访问它的任何元素的。我们必须为它分配内存空间，这时要用到运算符 new，其格式如下： arrayName=new type[arraySize]; 其中，arraySize 指明数组的长度。如： intArray=new int[3]; 为一个整型数组分配 3 个 int 型整数所占据的内存空间。 通常，这两部分可以合在一起，格式如下：
type arrayName=new type[arraySize];
例如：
int intArray=new int[3];
2.4.2 数组的创建
声明数组仅仅是给出了数组名字和元素的数据类型，要想真正地使用数组还必须为它分 配内存空间，即创建数组。当定义了一个数组，并用运算符 new 为它分配了内存空间后，就 可以引用数组中的每一个元素了。数组元素的引用方式为：
arrayName[index]
其中：index 为数组下标，它可以为整型常数或表达式。如 a[3]、b[i]（i 为整型）、c[6*I] 等。下标从 0 开始，一直到数组的长度减 1。对于上面例子中的 intArray 数组来说，它有 3 个 元素，分别为：intArray[0]、intArray[1]、intArray[2]。
注意：没有 intArray[3]。
另外，与 C、C++中不同，Java 对数组元素要进行越界检查以保证安全性。同时，对于每 个数组都有一个属性 length 指明它的长度，例如：intArray.length 指明数组 intArray 的长度。
public class ArrayTest{
public static void main(String args[]){ int i;
int a[]=new int[5]; for(i=0;i＜5;i++) a[i]=i;
2 项目 System.out.println("a["+i+"]="+a[i]); } } 运行结果如下： a[4]=4 a[3]=3 a[2]=2 a[1]=1 a[0]=0 该程序对数组中的每个元素赋值，然后按逆序输出。 对数组元素可以按照上述的例子进行赋值，也可以在定义数组的同时进行初始化。例如： int a[]={1,2,3,4,5}; 用逗号（,）分隔数组的各个元素，系统自动为数组分配一定空间。 2.4.3 数组的使用 我们将用 Fibonacci 数列的例子来具体说明一维数组的用法。Fibonacci 数列的定义为： F[1]=F[2]=1，F[n]=F[n-1]+F[n-2]（n>=3）。 例 2.3 Fibonacci 数列。
public class Fibonacci{
public static void main(String args[]){ int i;
int f[]=new int[10]; f[0]=f[1]=1; for(i=2;i＜10;i++) f[i]=f[i-1]+f[i-2]; for(i=1;i＜=10;i++) System.out.println("F["+i+"]="+f[i-1]); } } 运行结果为： F[1]=1 F[2]=1 F[3]=2 F[4]=3 F[5]=5 F[6]=8 F[7]=13 F[8]=21 F[9]=34 F[10]=55
2 项目 2.4.4 二维数组 与 C、C++一样，Java 中多维数组也被看作数组的数组。例如二维数组为一个特殊的一维 数组，其每个元素又是一个一维数组。下面我们主要以二维数组为例来进行说明，高维的情况 是类似的。 1．二维数组的声明 二维数组的声明方式为： type arrayName[][]; 例如： int intArray[][]; 与一维数组一样，这时对数组元素也没有分配内存空间，使用运算符 new 来分配内存， 然后才可以访问每个元素。 对二维数组来说，分配内存空间有下面几种方法：
（1）直接为每一维分配空间，如： int a[][]=new int[2][3];。 （2）从最高维开始，分别为每一维分配空间，如：
int a[][]=new int[2][]; a[0]=new int[3]; a[1]=new int[3]; （1）与（2）具有完全相同的功能。这一点与 C、C++是不同的，在 C、C++中必须一次 指明每一维的长度。 2．二维数组的创建 对二维数组中的每个元素，引用方式为：arrayName[index1][index2]，其中：index1、index2 为下标，为整型常数或表达式，如 a[2][3]等，同样，每一维的下标都从 0 开始。 有两种方式对二维数组进行初始化： （1）直接对每个元素进行赋值。 （2）在定义数组的同时进行初始化。 如：int a[][]={{2,3},{1,5},{3,4}};。 定义了一个 3×2 的数组，并对每个元素赋值。 3．二维数组的使用
例 2.4 两个矩阵 A（m×n）、B（n×l）相乘得到 C（m×l），每个元素 cij=aik*bkj（i=1..m,n=1..n）。
public class MatrixMultiply{
public static void main(String args[]){ int i,j,k;
int a[][]=new int[2][3];
int b[][]={{1,5,2,8},{5,9,10,-3},{2,7,-5,-18}}; int c[][]=new int[2][4];
2 项目 for(j=0;j＜3;j++) a[i][j]=(i+1)*(j+2); for(i=0;i＜2;i++){ for(j=0;j＜4;j++){ c[i][j]=0; for(k=0;k＜3;k++) c[i][j]+=a[i][k]*b[k][j]; } } System.out.println("\n***MatrixA***"); for(i=0;i＜2;i++){ for(j=0;j＜3;j++) System.out.print(a[i][j]+""); System.out.println(); } System.out.println("\n***MatrixB***"); for(i=0;i＜3;i++){ for(j=0;j＜4;j++) System.out.print(b[i][j]+""); System.out.println(); } System.out.println("\n***MatrixC***"); for(i=0;i＜2;i++){ for(j=0;j＜4;j++) System.out.print(c[i][j]+""); System.out.println(); } } } 其结果为： ***MatrixA*** 2 3 4 4 6 8 ***MatrixB*** 1 5 2 8 5 9 10 -3 2 7 -5 -18 ***MatrixC*** 25 65 14 -65 50 130 28 -130
2 项目
