3) 在编写 Java 代码时, 为了便于阅读, 通常会使用一种良好的格式进行排版, 但这并不是必需的, 我们也可以在两个单词或符号之间插入空格 制表符 换行符等任意的空白字符, 例如下面这段代码的编排方式也是可以的 public class HelloWorld {public static vo

Transcription

1 第 2 章 Java 编程基础 学习目标 掌握 Java 的基本语法格式 掌握常量 变量的定义和使用 掌握运算符的使用 掌握流程控制语句的使用 学会方法的定义与使用 学会数组的定义与使用 学做任何事情, 都要打好基础 同样地, 要掌握并熟练使用 Java 语言, 必须充分了解 Java 语言的基础知识 本章将针对 Java 的基本语法 变量 运算符 方法 结构语句以及数组等进行详细地讲解 2.1 Java 的基本语法 每一种编程语言都有一套自己的语法规范,Java 语言也不例外, 同样需要遵从一定的语法规范, 如代 码的书写 标识符的定义 关键字的应用等 因此要学好 Java 语言, 首先需要熟悉它的基本语法 Java 代码的基本格式 Java 中的程序代码都必须放在一个类中, 初学者可以简单地把类理解为一个 Java 程序 类需要使用 class 关键字定义, 在 class 前面可以有一些修饰符, 格式如下 : 修饰符 class 类名 { 程序代码 } 在编写 Java 代码时, 需要特别注意几个关键点 : 1)Java 中的程序代码可分为结构定义语句和功能执行语句, 其中, 结构定义语句用于声明一个类或方法, 功能执行语句用于实现具体的功能 每条功能执行语句的最后都必须用分号 (;) 结束 如下面的语句 : System.out.println(" 这是第一个 Java 程序!"); 值得注意的是, 在程序中不要将英文的分号 (;) 误写成中文的分号 (;), 如果写成中文的分号, 编译器会报告 illegal character ( 非法字符 ) 这样的错误信息 2)Java 语言是严格区分大小写的 在定义类时, 不能将 class 写成 Class, 否则编译会报错 程序中定义一个 computer 的同时, 还可以定义一个 Computer,computer 和 Computer 是两个完全不同的符号, 在使用时务必注意 1

2 3) 在编写 Java 代码时, 为了便于阅读, 通常会使用一种良好的格式进行排版, 但这并不是必需的, 我们也可以在两个单词或符号之间插入空格 制表符 换行符等任意的空白字符, 例如下面这段代码的编排方式也是可以的 public class HelloWorld {public static void main(string [ ] args){system.out.println(" 这是第一个 Java 程序!");}} 虽然 Java 没有严格要求用什么样的格式来编排程序代码, 但是, 出于可读性的考虑, 应该让自己编写的程序代码整齐美观 层次清晰, 通常会使用下面这种形式 : public class HelloWorld { public static void main(string[] args) { System.out.println(" 这是第一个 Java 程序!"); } } 4)Java 程序中一句连续的字符串不能分开在两行中书写, 例如, 下面这条语句在编译时将会出错 : System.out.println(" 这是第一个 Java 程序!"); 如果为了便于阅读, 想将一个太长的字符串分在两行中书写, 可以先将这个字符串分成两个字符串, 然后用加号 (+) 将这两个字符串连起来, 在加号 (+) 处断行, 上面的语句可以修改成如下形式 : System.out.println(" 这是第一个 " + "Java 程序!"); Java 中的注释 在编写程序时, 为了使代码易于理解, 通常会在实现功能的同时为代码加一些注释 注释是对程序的某个功能或者某行代码的解释说明, 它只在 Java 源文件中有效, 在编译程序时编译器会忽略这些注释信息, 不会将其编译到 class 字节码文件中去 Java 中的注释有三种类型, 具体如下 1. 单行注释单行注释通常用于对程序中的某一行代码进行解释, 用符号 // 表示, // 后面为被注释的内容, 具体示例如下 : int c = 10; // 定义一个整型变量 2. 多行注释多行注释顾名思义就是注释的内容可以为多行, 它以符号 /* 开头, 以符号 */ 结尾, 多行注释具体示例如下 : /* int c = 10; int x = 5; */ 3. 文档注释文档注释是以 /** 开头, 并在注释内容末尾以 */ 结束 文档注释是对一段代码概括性的解释说明, 可以使用 javadoc 命令将文档注释提取出来生成帮助文档 Java 中的标识符 在编程过程中, 经常需要在程序中定义一些符号来标记一些名称, 如包名 类名 方法名 参数名 2

3 变量名等, 这些符号被称为标识符 标识符可以由字母 数字 下划线 (_) 和美元符号 ($) 组成, 但标识符不能以数字开头, 不能是 Java 中的关键字 下面的这些标识符都是合法的 username username123 user_name _username $username 注意, 下面的这些标识符都是不合法的! 123username class 98.3 Hello World 在 Java 程序中定义的标识符必须要严格遵守上面列出的规范, 否则程序在编译时会报错 除了上面列出的规范, 为了增强代码的可读性, 建议初学者在定义标识符时还应该遵循以下规则 : 1) 包名所有字母一律小写 例如 :cn.itcast.test 2) 类名和接口名每个单词的首字母都要大写 例如 :ArrayList Iterator 3) 常量名所有字母都大写, 单词之间用下划线连接 例如 :DAY_OF_MONTH 4) 变量名和方法名的第一个单词首字母小写, 从第二个单词开始每个单词首字母大写 例如 : linenumber getlinenumber 5) 在程序中, 应该尽量使用有意义的英文单词来定义标识符, 使得程序便于阅读 例如使用 username 表示用户名,password 表示密码 Java 中的关键字 关键字是编程语言里事先定义好并赋予了特殊含义的单词 和其他语言一样,Java 中预留了许多关键 字, 例如,class public 等, 下面列举的是 Java 中所有的关键字 abstract continue for new switch assert default goto package synchronized boolean do if private this break double implements protected throw byte else import public throws case enum instanceof return transient catch extends int short try char final interface static void class finally long strictfp volatile const float native super while 上面列举的关键字中, 每个关键字都有特殊的作用, 例如 package 关键字用于包的声明,import 关键 字用于引入包,class 关键字用于类的声明 在本书后面的章节将逐步对其他关键字进行讲解, 在此没有必 要对所有关键字进行记忆, 只需要了解即可 使用 Java 关键字时, 有几个值得注意的地方 : 所有的关键字都是小写的 3

4 程序中的标识符不能以关键字命名 const 和 goto 是保留字关键字, 虽然在 Java 中还没有任何意义, 但在程序中不能用来作为自定义的标识符 true false 和 null 不属于关键字, 它们是一个单独标识类型, 不能直接使用 Java 中的常量 常量就是在程序中固定不变的值, 是不能改变的数据 例如数字 1 字符'a' 浮点数 3.2 等 在 Java 中, 常量包括整型常量 浮点数常量 布尔常量 字符常量等 1. 整型常量整型常量是整数类型的数据, 有二进制 八进制 十进制和十六进制 4 种表示形式, 具体表示形式如下 二进制 : 由数字 0 和 1 组成的数字序列 在 JDK7.0 中允许使用字面值来表示二进制数, 前面要以 0b 或 0B 开头, 目的是为了和十进制进行区分, 如 0b B 八进制 : 以 0 开头并且其后由 0 ~7 范围内 ( 包括 0 和 7) 的整数组成的数字序列, 如 0342 十进制 : 由数字 0~9 范围内 ( 包括 0 和 9) 的整数组成的数字序列 如 198 十六进制 : 以 0x 或者 0X 开头并且其后由 0~9 A~F( 包括 0 和 9 A 和 F, 字母不区分大小写 ) 组成的数字序列, 如 0x25AF 需要注意的是, 在程序中为了标明不同的进制, 数据都有特定的标识, 八进制必须以 0 开头, 如 ; 十六进制必须以 0x 或 0X 开头, 如 :0xaf3 0Xff; 整数以十进制表示时, 第一位不能是 0,0 本身除外 例如十进制的 127, 用二进制表示为 0b 或者 0B , 用八进制表示为 0177, 用十六进制表示为 0x7F 或者 0X7F 2. 浮点数常量浮点数常量就是在数学中用到的小数, 分为 float 单精度浮点数和 double 双精度浮点数两种类型 其中, 单精度浮点数后面以 F 或 f 结尾, 而双精度浮点数则以 D 或 d 结尾 当然, 在使用浮点数时也可以在结尾处不加任何的后缀, 此时虚拟机会默认为 double 双精度浮点数 浮点数常量还可以通过指数形式来表示 具体示例如下 : 2e3f 3.6d 0f 3.84d 5.022e+23f 上述列出的浮点数常量中用到的 e 和 f, 初学者可能会感到困惑, 在后面的 小节中将会详细介绍 3. 字符常量字符常量用于表示一个字符, 一个字符常量要用一对英文半角格式的单引号 ' ' 引起来, 它可以是英文字母 数字 标点符号 以及由转义序列来表示的特殊字符 具体示例如下 : 'a' '1' '&' '\r' '\u0000' 上面的示例中,'\u0000' 表示一个空白字符, 即在单引号之间没有任何字符 之所以能这样表示, 是因为 Java 采用的是 Unicode 字符集,Unicode 字符以 \u 开头, 空白字符在 Unicode 码表中对应的值为 '\u0000' 4. 字符串常量字符串常量用于表示一串连续的字符, 一个字符串常量要用一对英文半角格式的双引号 (" ") 引起来, 具体示例如下 : "HelloWorld" "123" "Welcome \n XXX" "" 一个字符串可以包含一个字符或多个字符, 也可以不包含任何字符, 即长度为零 5. 布尔常量 4

5 布尔常量即布尔型的两个值 true 和 false, 该常量用于区分一个事物的真与假 6.null 常量 null 常量只有一个值 null, 表示对象的引用为空 关于 null 常量将会在第 3 章中详细介绍 多学一招 : 十进制和二进制之间的转换 通过前面的介绍可以知道, 整型常量可以分别用二进制 八进制 十进制和十六进制表示, 不同的进 制并不影响数据本身, 同一个整型常量可以在不同进制之间转换, 下面介绍较为常用的两种进制之间相互 转换的方式, 具体如下 1. 十进制转二进制 十进制转换成二进制就是一个除以 2 取余数的过程 把要转换的数, 除以 2, 得到商和余数, 将商继 续除以 2, 直到商为 0 最后将所有余数倒序排列, 得到的数就是转换结果 以十进制的 6 转换为二进制为例进行说明, 如图 2-1 所示 图 2-1 十进制转二进制三次除以 2 计算得到余数依次是 0 1 1, 将所有余数倒序排列是 110 所以十进制的 6 转换成二进制, 结果是 二进制转十进制二进制转化成十进制要从右到左用二进制位上的每个数去乘以 2 的相应次方, 例如, 将最右边第一位的数乘以 2 的 0 次方, 第二位的数乘以 2 的 1 次方, 第 n 位的数乘以 2 的 n-1 次方, 然后把所有相乘后的结果相加, 得到的结果就是转换后的十进制 如把一个二进制数 转换为十进制, 转换方式如下 : 0 * * * * * * * * 2 7 = 100 由于 0 乘以多少都是 0, 所以上述表达式也可以简写为 : 1 * * * 2 6 = 100 得到的结果 100 就是二进制数 转化后的十进制表现形式 2.2 Java 中的变量 变量的定义 在程序运行期间, 随时可能产生一些临时数据, 应用程序会将这些数据保存在一些内存单元中, 每个内存单元都用一个标识符来标识 这些内存单元被称为变量, 定义的标识符就是变量名, 内存单元中存储的数据就是变量的值 接下来, 通过具体的代码来学习变量的定义 int x = 0,y; 5

6 y = x+3; 上面的代码中, 第一行代码的作用是定义了两个变量 x 和 y, 也就相当于分配了两块内存单元, 在定义变量的同时为变量 x 分配了一个初始值 0, 而变量 y 没有分配初始值, 变量 x 和 y 在内存中的状态如图 2-2 所示 图 2-2 x y 变量在内存中的状态第二行代码的作用是为变量赋值, 在执行第二行代码时, 程序首先取出变量 x 的值, 与 3 相加后, 将结果赋值给变量 y, 此时变量 x 和 y 在内存中的状态发生了变化, 如图 2-3 所示 图 2-3 x y 变量在内存中的状态 变量的数据类型 Java 是一门强类型的编程语言, 它对变量的数据类型有严格的限定 在定义变量时必须声明变量的类型, 在为变量赋值时必须赋予和变量同一种类型的值, 否则程序会报错 在 Java 中变量的数据类型分为两种, 即基本数据类型和引用数据类型 Java 中所有的数据类型如图 2-4 所示 图 2-4 数据类型 其中,8 种基本数据类型是 Java 语言内嵌的, 在任何操作系统中都具有相同大小和属性, 而引用数据 类型是在 Java 程序中由编程人员自己定义的变量类型 本章此处重点介绍的是 Java 中的基本数据类型, 6

7 引用数据类型会在以后的章节中进行详细地讲解 1. 整数类型变量 整数类型变量用来存储整数数值, 即没有小数部分的值 在 Java 中, 为了给不同大小范围内的整数合 理地分配存储空间, 整数类型分为 4 种不同的类型 : 字节型 (byte) 短整型 (short) 整型 (int) 和长整 型 (long), 4 种类型所占存储空间的大小以及取值范围如表 2-1 所示 表 2-1 整数类型 类型名占用空间取值范围 byte 8 位 (1 个字节 ) -2 7 ~ short 16 位 (2 个字节 ) ~ int 32 位 (4 个字节 ) ~ long 64 位 (8 个字节 ) ~ 表 2-1 中, 列出了 4 种整数类型变量所占的空间大小和取值范围 其中, 占用空间指的是不同类型的 变量分别占用的内存大小, 如一个 int 类型的变量会占用 4 个字节大小的内存空间 取值范围是变量存储的值不能超出的范围, 如一个 byte 类型的变量存储的值必须是 -2 7 ~ 之间的整数 在为一个 long 类型的变量赋值时需要注意一点, 所赋值的后面要加上一个字母 L( 或小写 l), 说明赋 值为 long 类型 如果赋的值未超出 int 型的取值范围, 则可以省略字母 L( 或小写 l) 具体示例如下 : long num = L; // 所赋的值超出了 int 型的取值范围, 后面必须加上字母 L long num = 198L; long num = 198; 2. 浮点数类型变量 // 所赋的值未超出 int 型的取值范围, 后面可以加上字母 L // 所赋的值未超出 int 型的取值范围, 后面可以省略字母 L 浮点数类型变量用来存储小数数值 在 Java 中, 浮点数类型分为两种 : 单精度浮点数 (float) 和双精 度浮点数 (double), double 型所表示的浮点数比 float 型更精确, 两种浮点数所占存储空间的大小以及取 值范围如表 2-2 所示 表 2-2 浮点类型 类型名占用空间取值范围 float 32 位 (4 个字节 ) 1.4E-45 ~ 3.4E+38,-3.4E+38 ~ -1.4E-45 double 64 位 (8 个字节 ) 4.9E-324 ~ 1.7E+308, -1.7E+308 ~ -4.9E-324 表 2-2 中, 列出了两种浮点数类型变量所占的空间大小和取值范围, 在取值范围中,E( 或者小写 e ) 表示以 10 为底的指数,E 后面的 + 号和 - 号代表正指数和负指数, 例如 1.4E-45 表示 1.4*10-45 在 Java 中, 一个小数会被默认为 double 类型的值, 因此在为一个 float 类型的变量赋值时需要注意一 点, 所赋值的后面一定要加上字母 F( 或者小写 f), 而为 double 类型的变量赋值时, 可以在所赋值的后面 加上字母 D( 或小写 d), 也可以不加 具体示例如下 : float f = 123.4f; double d1 = 100.1; double d2 = 199.3d; // 为一个 float 类型的变量赋值, 后面必须加上字母 f // 为一个 double 类型的变量赋值, 后面可以省略字母 d // 为一个 double 类型的变量赋值, 后面可以加上字母 d 在程序中也可以为一个浮点数类型变量赋予一个整数数值, 例如下面的写法也是可以的 float f = 100; // 声明一个 float 类型的变量并赋整数值 double d = 100; // 声明一个 double 类型的变量并赋整数值 3. 字符类型变量 字符类型变量用于存储一个单一字符, 在 Java 中用 char 表示 Java 中每个 char 类型的字符变量都会 占用 2 个字节 在给 char 类型的变量赋值时, 需要用一对英文半角格式的单引号 ' ' 把字符括起来, 如 'a', 也可以将 char 类型的变量赋值为 0~65535 范围内的整数, 计算机会自动将这些整数转化为所对应的字符, 7

8 如数值 97 对应的字符为 'a' 下面的两行代码可以实现同样的效果 char c = 'a'; // 为一个 char 类型的变量赋值字符 a char ch = 97; // 为一个 char 类型的变量赋值整数 97, 相当于赋值字符 a 4. 布尔类型变量布尔类型变量用来存储布尔值, 在 Java 中用 boolean 表示, 该类型的变量只有两个值, 即 true 和 false 具体示例如下 : boolean flag = false; // 声明一个 boolean 类型的变量, 初始值为 false flag = true; // 改变 flag 变量的值为 true 变量的类型转换 在程序中, 当把一种数据类型的值赋给另一种数据类型的变量时, 需要进行数据类型转换 根据转换方式的不同, 数据类型转换可分为两种 : 自动类型转换和强制类型转换 1. 自动类型转换自动类型转换也叫隐式类型转换, 指的是两种数据类型在转换的过程中不需要显式地进行声明 要实现自动类型转换, 必须同时满足两个条件, 第一是两种数据类型彼此兼容, 第二是目标类型的取值范围大于源类型的取值范围 例如 : byte b = 3; int x = b; // 程序把 byte 类型的变量 b 转换成了 int 类型, 无须特殊声明上面的语句中, 将 byte 类型的变量 b 的值赋给 int 类型的变量 x, 由于 int 类型的取值范围大于 byte 类型的取值范围, 编译器在赋值过程中不会造成数据丢失, 所以编译器能够自动完成这种转换, 在编译时不报告任何错误 除了上述示例中演示的情况, 还有很多类型之间可以进行自动类型转换, 接下来就列出 3 种可以进行自动类型转换的情况, 具体如下 : 1 整数类型之间可以实现转换, 如 byte 类型的数据可以赋值给 short int long 类型的变量,short char 类型的数据可以赋值给 int long 类型的变量,int 类型的数据可以赋值给 long 类型的变量 2 整数类型转换为 float 类型, 如 byte char short int 类型的数据可以赋值给 float 类型的变量 3 其他类型转换为 double 类型, 如 byte char short int long float 类型的数据可以赋值给 double 类型的变量 2. 强制类型转换强制类型转换也叫显式类型转换, 指的是两种数据类型之间的转换需要进行显式地声明 当两种类型彼此不兼容, 或者目标类型取值范围小于源类型时, 自动类型转换无法进行, 这时就需要进行强制类型转换 先来看个例子, 如文件 2-1 所示 文件 2-1 Example01.java 1 public class Example01 { 3 int num = 4; 4 byte b = num; 5 System.out.println(b); 6 } 7 } 编译程序报错, 结果如图 2-5 所示 8

9 图 2-5 程序编译报错 Eclipse 在源文件被保存时会自动对源代码进行编译, 如果保存后出现红色波浪线, 说明此处代码出现了编译错误, 鼠标光标移到错误上方, 会出现一个悬浮框, 提示了编译错误的原因以及可能的快速解决方案 图 2-5 出现了编译错误, 提示数据类型不匹配, 不能将 int 类型转换成 byte 类型 出现这样错误的原因是将一个 int 型的值赋给 byte 类型的变量 b 时,int 类型的取值范围大于 byte 类型的取值范围, 这样的赋值会导致数值溢出, 也就是说一个字节的变量无法存储四个字节的整数值 在这种情况下, 就需要进行强制类型转换, 具体格式如下 : 目标类型变量 = ( 目标类型 ) 值将文件 2-1 中第 4 行代码修改为下面的代码 : byte b = (byte) num; 修改后保存源文件, 编译不会报错, 程序运行结果如图 2-6 所示 图 2-6 运行结果 需要注意的是, 在对变量进行强制类型转换时, 会发生取值范围较大的数据类型向取值范围较小的数 据类型的转换, 如将一个 int 类型的数转为 byte 类型, 这样做极容易造成数据精度的丢失 接下来通过一 个案例来演示数据精度丢失的情况, 如文件 2-2 所示 文件 2-2 Example02.java 1 public class Example02 { 3 byte a; // 定义 byte 类型的变量 a 4 int b = 298; // 定义 int 类型的变量 b 5 a = (byte) b; 6 System.out.println("b=" + b); 7 System.out.println("a=" + a); 8 } 9 } 运行结果如图 2-7 所示 9

10 图 2-7 运行结果文件 2-2 中的第 5 行发生了强制类型转换, 将一个 int 类型的变量 b 强制转换成 byte 类型, 然后再将强转后的结果赋值给变量 a 从图 2-7 所示的运行结果可以看出变量 b 本身的值为 298, 然而在赋值给变量 a 后, 其值为 42, 明显丢失了精度 出现这种现象的原因是, 变量 b 为 int 类型, 在内存中占用 4 个字节 byte 类型的数据在内存中占用 1 个字节, 当将变量 b 的类型强转为 byte 类型后, 前面 3 个高位字节的数据丢失, 数值发生改变 int 类型转 byte 类型的过程如图 2-8 所示 int byte 图 2-8 int 类型变量强制转换为 byte 类型 多学一招 : 表达式类型自动提升所谓表达式是指由变量和运算符组成的一个算式 变量在表达式中进行运算时, 也有可能发生自动类型转换, 这就是表达式数据类型的自动提升, 如一个 byte 型的变量在运算期间类型会自动提升为 int 型 先来看个例子, 如文件 2-3 所示 文件 2-3 Example03.java 1 public class Example03 { 3 byte b1 = 3; // 定义一个 byte 类型的变量 4 byte b2 = 4; 5 byte b3 = b1 + b2; // 两个 byte 类型变量相加, 赋值给一个 byte 类型变量 6 System.out.println("b3=" + b3); 7 } 8 } 编译程序报错, 结果如图 2-9 所示 图 2-9 程序编译报错 10

11 图 2-9 中出现了和图 2-5 相同的错误, 这是因为在表达式 b1+b2 运算期间, 变量 b1 和 b2 都被自动提升为 int 型, 表达式的运算结果也就成了 int 型, 这时如果将该结果赋给 byte 型的变量就会报错, 需要进行强制类型转换 要解决图 2-9 中的错误, 必须要将文件 2-3 中第 5 行的代码修改为 : byte b3 = (byte) (b1 + b2); 再次编译后, 程序不会报错, 运行结果如图 2-10 所示 图 2-10 运行结果 变量的作用域 在前面介绍过变量需要先定义后使用, 但这并不意味着在变量定义之后的语句中一定可以使用该变量 变量需要在它的作用范围内才可以被使用, 这个作用范围称为变量的作用域 在程序中, 变量一定会被定义在某一对大括号中, 该大括号所包含的代码区域便是这个变量的作用域 接下来通过一个代码片段来分析变量的作用域, 具体如下 : public static void main(string[] args) { int x=4; { int y=9; y 的作用域... }... } X 的作用域 上面的代码中, 有两层大括号 其中, 外层大括号所标识的代码区域就是变量 x 的作用域, 内层大括 号所标识的代码区域就是变量 y 的作用域 变量的作用域在编程中尤为重要, 接下来通过一个案例进一步熟悉变量的作用域, 如文件 2-4 所示 文件 2-4 Example04.java 1 public class Example04 { 3 int x = 12; // 定义了变量 x 4 { 5 int y = 96; // 定义了变量 y 6 System.out.println("x is " + x); // 访问变量 x 7 System.out.println("y is " + y); // 访问变量 y 8 } 9 y = x; // 访问变量 x, 为变量 y 赋值 10 System.out.println("x is " + x); // 访问变量 x 11 } 12 } 编译程序报错, 结果如图 2-11 示 11

12 图 2-11 程序编译报错 图 2-11 出现 y 不能被解析为一个变量 的错误 出错的原因在于在给变量 y 赋值时超出了它的作用 域 将文件 2-4 中的第 9 行代码去掉, 保存后文件将不再报错, 程序的运行结果如图 2-12 所示 图 2-12 运行结果 文件 2-4 修改后的代码中, 变量 x y 都在各自的作用域中, 因此都可以被访问到 2.3 Java 中的运算符 在程序中经常出现一些特殊符号, 如 + - * = > 等, 这些特殊符号称作运算符 运算符用于对数 据进行算术运算 赋值和比较等操作 在 Java 中, 运算符可分为算术运算符 赋值运算符 比较运算符 逻辑运算符等 算术运算符 在数学运算中最常见的就是加减乘除, 被称作四则运算 Java 中的算术运算符就是用来处理四则运算 的符号, 这是最简单 最常用的运算符号 接下来通过表 2-3 列出 Java 中的算术运算符及其用法 表 2-3 算数运算符 运算符 运算 范例 结果 + 正号 负号 b=4;-b; -4 + 加 减 * 乘 3*4 12 / 除 5/5 1 12

13 % 取模 ( 即算术中的求余数 ) 7% 自增 ( 前 ) a=2;b=++a; a=3;b=3; ++ 自增 ( 后 ) a=2;b=a++; a=3;b=2; -- 自减 ( 前 ) a=2;b=--a a=1;b=1; -- 自减 ( 后 ) a=2;b=a-- a=1;b=2; 算术运算符看上去都比较简单, 也很容易理解, 但在实际使用时还有很多需要注意的问题, 具体如下 : 1 在进行自增 ++ 和自减 -- 的运算时, 如果运算符 ++ 或 -- 放在操作数的前面则是先进行自增或自减运算, 再进行其他运算 反之, 如果运算符放在操作数的后面则是先进行其他运算再进行自增或自减运算 请仔细阅读下面的代码块, 思考运行的结果 int a = 1; int b = 2; int x = a + b++; System.out.print("b=" + b); System.out.print("x=" + x); 上面的代码块运行结果为 :b=3 x=3, 具体分析如下 : 在上述代码中, 定义了三个 int 类型的变量 a b x 其中 a=1 b=2 当进行 a+b++ 运算时, 由于运算符 ++ 写在了变量 b 的后面, 属于先运算再自增, 因此变量 b 在参与加法运算时其值仍然为 2, 而 x 的值应为 3 变量 b 在参与运算之后会进行自增, 因此 b 的最终值为 3 2 在进行除法运算时, 当除数和被除数都为整数时, 得到的结果也是一个整数 如果除法运算有小数参与, 得到的结果会是一个小数 例如,2510/1000 属于整数之间相除, 会忽略小数部分, 得到的结果是 2, 而 2.5/10 的结果为 0.25 请思考一下下面表达式的结果是多少 3500/1000*1000 结果为 3000 由于表达式的执行顺序是从左到右, 所以先执行除法运算 3500/1000, 得到结果为 3, 再乘以 1000, 得到的结果自然就是 3000 了 3 在进行取模 (%) 运算时, 运算结果的正负取决于被模数 (% 左边的数 ) 的符号, 与模数 (% 右边的数 ) 的符号无关 如 :(-5)%3=-2, 而 5%(-3)= 赋值运算符 赋值运算符的作用就是将常量 变量或表达式的值赋给某一个变量 接下来通过表 2-4 列出 Java 中的 赋值运算符及其用法 表 2-4 赋值运算符 运算符 运算 范例 结果 = 赋值 a=3;b=2; a=3;b=2; += 加等于 a=3;b=2;a+=b; a=5;b=2; -= 减等于 a=3;b=2;a-=b; a=1;b=2; *= 乘等于 a=3;b=2;a*=b; a=6;b=2; /= 除等于 a=3;b=2;a/=b; a=1;b=2; %= 模等于 a=3;b=2;a%=b; a=1;b=2; 在赋值过程中, 运算顺序从右往左, 将右边表达式的结果赋值给左边的变量 在赋值运算符的使用中, 需要注意以下几个问题 : 1 在 Java 中可以通过一条赋值语句对多个变量进行赋值, 具体示例如下 : 13

14 int x, y, z; x = y = z = 5; // 为三个变量同时赋值 在上述代码中, 一条赋值语句将变量 x,y,z 的值同时赋值为 5 需要特别注意的是, 下面的这种写 法在 Java 中是不可以的 int x = y = z = 5; // 这样写是错误的 2 在表 2-4 中, 除了 =, 其他的都是特殊的赋值运算符, 以 += 为例,x += 3 就相当于 x = x + 3, 首先会进行加法运算 x+3, 再将运算结果赋值给变量 x -= *= /= %= 赋值运算符都可依此类推 多学一招 : 在 小节中介绍过, 在为变量赋值时, 当两种类型彼此不兼容, 或者目标类型取值范围小于源类 型时, 需要进行强制类型转换 例如将一个 int 类型的值赋给一个 short 类型的变量, 需要显式地进行强制 类型转换 然而在使用 += -= *= /= %= 运算符进行赋值时, 强制类型转换会自动完成, 程序不需要 做任何显式地声明, 如文件 2-5 所示 1 public class Example05 { 文件 2-5 Example05.java 3 short s = 3; 4 int i = 5; 5 s += i; 6 System.out.println("s = " + s); 7 } 8 } 运行结果如图 2-13 所示 图 2-13 运行结果 文件 2-5 中, 第 5 行代码为赋值运算, 虽然变量 s 和 i 相加的运算结果为 int 型, 但通过运算符 += 将结 果赋值给了 short 型的变量 s 时,Java 虚拟机会自动完成类型转换, 从而得到 s= 比较运算符 比较运算符用于对两个数值或变量进行比较, 其结果是一个布尔值, 即 true 或 false 接下来通过表 2-5 列出 Java 中的比较运算符及其用法 表 2-5 比较运算符 运算符 运算 范例 结果 == 相等于 4 == 3 false!= 不等于 4!= 3 true < 小于 4 < 3 false > 大于 4 > 3 true <= 小于等于 4 <= 3 false 14

15 >= 大于等于 4 >= 3 true 比较运算符在使用时需要注意一个问题, 不能将比较运算符 == 误写成赋值运算符 = 逻辑运算符 逻辑运算符用于对布尔型的数据进行操作, 其结果仍是一个布尔型数据 接下来通过表 2-6 列出 Java 中的逻辑运算符及其用法 表 2-6 逻辑运算符 运算符 运算 范例 结果 true & true true & 与 true & false false false & false false false &true false true true true 或 true false true false false false false true true true ^ true false ^ 异或 true ^ false true false ^ false false false ^ true true! 非!true false!false true true && true true && 短路与 true && false false false && false false false && true false true true true 短路或 true false true false false false false true true 在使用逻辑运算符的过程中, 需要注意以下几个细节 : 1 逻辑运算符可以针对结果为布尔值的表达式进行运算 如 :x > 3 && y!= 0 2 运算符 & 和 && 都表示与操作, 当且仅当运算符两边的操作数都为 true 时, 其结果才为 true, 否则结果为 false 当运算符 & 和 && 的右边为表达式时, 两者在使用上还有一定的区别 在使用 & 进行运算时, 不论左边为 true 或者 false, 右边的表达式都会进行运算 如果使用 && 进行运算, 当左边为 false 时, 右边的表达式则不会进行运算, 因此 && 被称作短路与 接下来通过一个案例来深入了解一下两者的区别, 如文件 2-6 所示 文件 2-6 Example06.java 1 public class Example06 { 3 int x = 0; // 定义变量 x, 初始值为 0 4 int y = 0; // 定义变量 y, 初始值为 0 15

16 5 int z = 0; // 定义变量 z, 初始值为 0 6 boolean a, b; // 定义 boolean 变量 a 和 b 7 a = x > 0 & y++ > 1; // 逻辑运算符 & 对表达式进行运算 8 System.out.println(a); 9 System.out.println("y = " + y); 10 b = x > 0 && z++ > 1; // 逻辑运算符 && 对表达式进行运算 11 System.out.println(b); 12 System.out.println("z = " + z); 13 } 14 } 运行结果如图 2-14 所示 图 2-14 运行结果文件 2-6 中, 定义了三个整型变量 x y z, 初始值都为 0, 同时定义了两个布尔类型的变量 a 和 b 文件中的第 7 行代码使用 & 运算符对两个表达式进行运算, 左边表达式 x>0 的结果为 false, 这时无论右边表达式 y++>1 的比较结果是什么, 整个表达式 x > 0 & y++ > 1 的结果都会是 false 由于使用的是单个的运算符 &, 运算符两边的表达式都会进行运算, 因此变量 y 会进行自增, 整个表达式运算结束时 y 的值为 1 文件中的第 10 行代码也是与运算, 运算结果和第 7 行代码一样为 false, 区别在于在第 10 行中使用了短路与 && 运算符, 当左边为 false 时, 右边的表达式不进行运算, 因此变量 z 的值仍为 0 3 运算符 和 都表示或操作, 当运算符两边的操作数任何一边的值为 true 时, 其结果为 true, 当两边的值都为 false 时, 其结果才为 false 同与操作类似, 表示短路或, 当运算符 的左边为 true 时, 右边的表达式就不会进行运算, 具体示例如下 : int x = 0; int y = 0; boolean b = x==0 y++>0 上面的代码块执行完毕后,b 的值为 true,y 的值仍为 0 出现这样结果的原因是, 运算符 的左边 x==0 结果为 true, 那么右边表达式将不会进行运算,y 的值不发生任何变化 4 运算符 ^ 表示异或操作, 当运算符两边的布尔值相同时 ( 都为 true 或都为 false), 其结果为 false 当两边布尔值不相同时, 其结果为 true 运算符的优先级 在对一些比较复杂的表达式进行运算时, 要明确表达式中所有运算符参与运算的先后顺序, 通常把这 种顺序称作运算符的优先级 接下来通过表 2-7 列出 Java 中运算符的优先级, 数字越小优先级越高 表 2-7 运算符优先级 优先级 运算符 1. [] () ~! ( 数据类型 ) 16

17 3 * / % << >> >>> 6 < > <= >= 7 ==!= 8 & 9 ^ && 12 13?: 14 = *= /= %= += -= <<= >>= >>>= &= ^= = 根据表 2-7 所示的运算符优先级, 分析下面代码的运行结果 int a =2; int b = a + 3*a; System.out.println(b); 运行结果为 8, 由于运算符 * 的优先级高于运算符 +, 因此先运算 3*a, 得到的结果是 6, 再将 6 与 a 相加, 得到最后的结果 8 int a =2; int b = (a+3) * a; System.out.println(b); 运行结果为 10, 由于运算符 () 的优先级最高, 因此先运算括号内的 a+3, 得到的结果是 5, 再将 5 与 a 相乘, 得到最后的结果 10 其实没有必要去刻意记忆运算符的优先级 编写程序时, 尽量使用括号 () 来实现想要的运算顺序, 以免产生歧义 任务 2-1 商城库存清单程序设计 任务介绍 1. 任务描述编写一个模拟商城库存清单的程序, 打印出库存中每种商品的详细信息以及所有商品的汇总信息 每种商品的详细信息包括品牌型号 尺寸 价格 配置和库存数, 所有商品的汇总信息包括总库存数和库存商品总金额 2. 运行结果任务运行结果如图 2-15 所示 17

18 图 2-15 运行结果 任务目标 学会分析 商城库存清单 任务实现的逻辑思路 能够独立完成 商城库存清单 程序的源代码编写 编译及运行 能够在程序中使用算术运算符进行运算操作 能够在程序中使用赋值运算符进行赋值操作 掌握 Java 中的变量和运算符的知识点 实现思路 (1) 观察清单后, 可将清单分解为三个部分 ( 清单顶部 清单中部 清单底部 ) (2) 清单顶部为固定的数据, 直接打印即可 (3) 清单中部为商品, 为变化的数据, 需要记录商品信息后打印 经过观察, 可以确定一项商品应该有如下几个属性 品牌型号 : 即商品名称,String 类型尺寸 : 物品大小,double 类型价格 : 物品单价,double 类型配置 : 这一项为每种商品的配置信息,String 类型库存数 : 这一项为每种商品的库存个数,int 类型 (4) 清单底部包含了统计操作, 需经过计算后打印, 可以设置两个单独的变量 总库存数 : 所有商品库存的总数,int 类型库存商品总金额 : 所有商品的总金额,double 类型 实现代码 计算商城库存清单功能的实现代码, 如文件 2-7 所示 18

19 文件 2-7 StoreList.java 1 package cn.itcast.chapter02.task01; 2 public class StoreList { 3 public static void main(string[] args) { 4 // 苹果笔记本电脑 5 String macbrand = "MacBookAir"; 6 double macsize = 13.3; 7 double macprice = ; 8 String macconfig = "i5 处理器 4GB 内存 128G 固态硬盘 "; 9 int maccount = 5; // 联想 Thinkpad 笔记本电脑 12 String thinkpadbrand = "ThinkpadT450"; 13 double thinkpadsize = 14.0; 14 double thinkpadprice = ; 15 String thinkpadconfig = "i5 处理器 4GB 内存 500G 硬盘 "; 16 int thinkpadcount = 10; // 华硕 ASUS 笔记本电脑 19 String ASUSBrand = "ASUS-FL5800"; 20 double ASUSSize = 15.6; 21 double ASUSPrice = ; 22 String ASUSConfig = "i7 处理器 4GB 内存 128G 固态硬盘 "; 23 int ASUSCount = 18; // 列表顶部 26 System.out.println(" 商城库存清单 " 27 + " "); 28 System.out.println(" 品牌型号 尺寸价格 配置 库存数 "); // 列表中部 31 System.out.println(macBrand+" "+macsize+" "+macprice+" "+ 32 macconfig+" "+maccount); 33 System.out.println(thinkpadBrand+" "+thinkpadsize+" "+thinkpadprice+" "+ 34 thinkpadconfig+" "+thinkpadcount); 35 System.out.println(ASUSBrand+" "+ASUSSize+" "+ASUSPrice+" "+ 36 ASUSConfig+" "+ASUSCount); // 统计总库存数 库存总金额 39 int totalcount = maccount + thinkpadcount + ASUSCount; 40 double totalmoney = (maccount * macprice) + (thinkpadcount * thinkpadprice) 41 + (ASUSCount * ASUSPrice); // 列表底部 19

20 44 System.out.println(" " 45 + " "); 46 System.out.println(" 总库存数 :"+totalcount); 47 System.out.println(" 库存商品总金额 :"+totalmoney); } 50 } 在文件 2-7 中, 第 4~23 行代码记录了清单中 3 种商品的详细信息, 包括品牌型号 尺寸 价格 配置和库存数 ; 第 25~28 行代码用于打印清单顶部, 清单顶部为固定的数据, 因此直接打印即可 ; 第 30~36 行代码用于打印清单中部的商品信息, 需要注意的是, 此处商品各种信息应该和列表顶部的商品信息的顺序一致, 否则会造成商品信息显示错乱 ; 第 43~47 行代码用于打印清单列表底部信息, 包括总库存数和库存商品总金额, 它们都是需要通过计算获得的, 第 38~41 行代码就是用于计算库存总个数和库存总金额的代码 2.4 选择结构语句 在实际生活中经常需要做出一些判断, 比如开车来到一个十字路口, 这时需要对红绿灯进行判断, 如果前面是红灯, 就停车等候, 如果是绿灯, 就通行 Java 中有一种特殊的语句叫做选择语句, 它也需要对一些条件做出判断, 从而决定执行哪一段代码 选择语句分为 if 条件语句和 switch 条件语句 接下来针对选择语句进行详细地讲解 if 条件语句 if 条件语句分为三种语法格式, 每一种格式都有其自身的特点, 下面分别进行介绍 1.if 语句 if 语句是指如果满足某种条件, 就进行某种处理 例如, 小明妈妈跟小明说 如果你考试得了 100 分, 星期天就带你去游乐场玩 这句话可以通过下面的一段伪代码来描述 如果小明考试得了 100 分妈妈星期天带小明去游乐场在上面的伪代码中, 如果 相当于 Java 中的关键字 if, 小明考试得了 100 分 是判断条件, 需要用 () 括起来, 妈妈星期天带小明去游乐场 是执行语句, 需要放在 {} 中 修改后的伪代码如下 : if ( 小明考试得了 100 分 ) { 妈妈星期天带小明去游乐场 } 上面的例子就描述了 if 语句的用法, 在 Java 中,if 语句的具体语法格式如下 : if ( 条件语句 ){ 代码块 } 上述格式中, 判断条件是一个布尔值, 当判断条件为 true 时,{} 中的执行语句才会执行 if 语句的执行流程如图 2-16 所示 20

21 判断条件 true 执行语句 false 图 2-16 if 语句流程图接下来通过一个案例来学习一下 if 语句的具体用法, 如文件 2-8 所示 文件 2-8 Example07.java 1 public class Example07 { 3 int x = 5; 4 if (x < 10) { 5 x++; 6 } 7 System.out.println("x=" + x); 8 } 9 } 运行结果如图 2-17 所示 图 2-17 运行结果文件 2-8 中, 定义了一个变量 x, 其初始值为 5 在 if 语句的判断条件中判断 x 的值是否小于 10, 很明显条件成立,{} 中的语句会被执行, 变量 x 的值将进行自增 从图 2-16 的运行结果可以看出,x 的值已由原来的 5 变成了 6 2.if else 语句 if else 语句是指如果满足某种条件, 就进行某种处理, 否则就进行另一种处理 例如, 要判断一个正整数的奇偶, 如果该数字能被 2 整除则是一个偶数, 否则该数字就是一个奇数 if else 语句具体语法格式如下 : if ( 判断条件 ){ 执行语句 1 }else{ 执行语句 2 } 上述格式中, 判断条件是一个布尔值 当判断条件为 true 时,if 后面 {} 中的执行语句 1 会执行 当判 21

22 断条件为 false 时,else 后面 {} 中的执行语句 2 会执行 if else 语句的执行流程如图 2-18 所示 判断条件 true false 执行语句 1 执行语句 2 图 2-18 if else 语句流程图接下来通过一个案例来实现判断奇偶数的程序, 如文件 2-9 所示 文件 2-9 Example08.java 1 public class Example08 { 3 int num = 19; 4 if (num % 2 == 0) { 5 // 判断条件成立,num 被 2 整除 6 System.out.println("num 是一个偶数 "); 7 } else { 8 System.out.println("num 是一个奇数 "); 9 } 10 } 11 } 运行结果如图 2-19 所示 图 2-19 运行结果 文件 2-9 中, 变量 num 的值为 19, 与 2 取模的结果为 1, 不等于 0, 判断条件不成立 因此会执行 else 后面 {} 中的语句, 打印 num 是一个奇数 多学一招 : 在 Java 中有一种特殊的运算叫做三元运算, 它和 if-else 语句类似, 语法如下 : 判断条件? 表达式 1 : 表达式 2 三元运算会得到一个结果, 通常用于对某个变量进行赋值, 当判断条件成立时, 运算结果为表达式 1 的值, 否则结果为表达式 2 的值 例如求两个数 x y 中的较大者, 如果用 if else 语句来实现, 具体代码如下 : int x = 0; 22

23 int y = 1; int max; if (x > y) { max = x; } else { max = y; } 上面的代码运行之后, 变量 max 的值为 1 上述代码片段中的 if else 语句可以使用下面的三元运算来替换 int max = x > y? x : y; 3.if else if else 语句 if else if else 语句用于对多个条件进行判断, 进行多种不同的处理 例如, 对一个学生的考试成绩进行等级的划分, 如果分数大于 80 分等级为优, 否则, 如果分数大于 70 分等级为良, 否则, 如果分数大于 60 分等级为中, 否则, 等级为差 if else if else 语句具体语法格式如下 : if ( 判断条件 1) { 执行语句 1 } else if ( 判断条件 2) { 执行语句 2 }... else if ( 判断条件 n) { 执行语句 n } else { 执行语句 n+1 } 上述格式中, 判断条件是一个布尔值 当判断条件 1 为 true 时,if 后面 {} 中的执行语句 1 会执行 当判断条件 1 为 false 时, 会继续执行判断条件 2, 如果为 true 则执行语句 2, 依此类推, 如果所有的判断条件都为 false, 则意味着所有条件均未满足,else 后面 {} 中的执行语句 n+1 会执行 if else if else 语句的执行流程如图 2-20 所示 23

24 true 判断条件 1 false 执行语句 1 true 判断条件 2 false 执行语句 2 true... false... true 判断条件 n false 执行语句 n 执行语句 n+1 图 2-20 if else if else 语句的流程图接下来通过一个案例来实现对学生考试成绩进行等级划分的程序, 如文件 2-10 所示 文件 2-10 Example09.java 1 public class Example09 { 3 int grade = 75; // 定义学生成绩 4 if (grade > 80) { 5 // 满足条件 grade > 80 6 System.out.println(" 该成绩的等级为优 "); 7 } else if (grade > 70) { 8 // 不满足条件 grade > 80, 但满足条件 grade > 70 9 System.out.println(" 该成绩的等级为良 "); 10 } else if (grade > 60) { 11 // 不满足条件 grade > 70, 但满足条件 grade > System.out.println(" 该成绩的等级为中 "); 13 } else { 14 // 不满足条件 grade > System.out.println(" 该成绩的等级为差 "); 16 } 17 } 18 } 运行结果如图 2-21 所示 图 2-21 运行结果 24

25 文件 2-10 中, 定义了学生成绩 grade 为 75 它不满足第一个判断条件 grade>80, 会执行第二个判断条 件 grade>70, 条件成立, 因此会打印 该成绩的等级为良 switch 条件语句 switch 条件语句也是一种很常用的选择语句, 和 if 条件语句不同, 它只能针对某个表达式的值做出判断, 从而决定程序执行哪一段代码 例如, 在程序中使用数字 1~7 来表示星期一到星期天, 如果想根据某个输入的数字来输出对应中文格式的星期值, 可以通过下面的一段伪代码来描述 : 用于表示星期的数字如果等于 1, 则输出星期一如果等于 2, 则输出星期二如果等于 3, 则输出星期三如果等于 4, 则输出星期四如果等于 5, 则输出星期五如果等于 6, 则输出星期六如果等于 7, 则输出星期天对于上面一段伪代码的描述, 大家可能会立刻想到用刚学过得 if else if else 语句来实现, 但是由于判断条件比较多, 实现起来代码过长, 不便于阅读 Java 中提供了一种 switch 语句来实现这种需求, 在 switch 语句中使用 switch 关键字来描述一个表达式, 使用 case 关键字来描述和表达式结果比较的目标值, 当表达式的值和某个目标值匹配时, 会执行对应 case 下的语句 具体实现代码如下 : switch( 用于表示星期的数字 ) { case 1 : 输出星期一 ; break; case 2 : 输出星期二 ; break; case 3 : 输出星期三 break; case 4 : 输出星期四 ; break; case 5 : 输出星期五 ; break; case 6: 输出星期六 ; break; case 7: 输出星期天 ; break; } 上面改写后的伪代码便描述了 switch 语句的基本语法格式, 具体如下 : 25

26 switch ( 表达式 ){ case 目标值 1: 执行语句 1 break; case 目标值 2: 执行语句 2 break;... case 目标值 n: 执行语句 n break; default: 执行语句 n+1 break; } 在上面的格式中,switch 语句将表达式的值与每个 case 中的目标值进行匹配, 如果找到了匹配的值, 会执行对应 case 后的语句, 如果没找到任何匹配的值, 就会执行 default 后的语句 switch 语句中的 break 关键字将在后面的小节中做具体介绍, 此处, 初学者只需要知道 break 的作用是跳出 switch 语句即可 需要注意的是, 在 JDK5.0 之前,switch 语句中的表达式只能是 byte short char int 类型的值, 如果传入其他类型的值, 程序会报错 在 JDK5.0 中, 引入的新特性 enum 枚举可以作为 switch 语句表达式的值, 在 JDK7.0 中也引入了新特性,switch 语句可以接收一个 String 类型的值 关于这两个新特性此处不便进行详细讲解, 感兴趣的同学可以通过查阅官方资料进行自学 接下来通过一个案例来演示使用 switch 语句根据给出的数值来输出对应中文格式的星期, 如文件 2-11 所示 文件 2-11 Example10.java 1 public class Example10{ 3 int week = 5; 4 switch (week) { 5 case 1: 6 System.out.println(" 星期一 "); 7 break; 8 case 2: 9 System.out.println(" 星期二 "); 10 break; 11 case 3: 12 System.out.println(" 星期三 "); 13 break; 14 case 4: 15 System.out.println(" 星期四 "); 16 break; 17 case 5: 18 System.out.println(" 星期五 "); 19 break; 26

27 20 case 6: 21 System.out.println(" 星期六 "); 22 break; 23 case 7: 24 System.out.println(" 星期天 "); 25 break; 26 default: 27 System.out.println(" 输入的数字不正确..."); 28 break; 29 } 30 } 31 } 运行结果如图 2-22 所示 图 2-22 运行结果文件 2-11 中, 由于变量 week 的值为 5,switch 语句判断的结果满足文件 2-11 中第 17 行代码的条件, 因此打印出 星期五, 文件中的 default 语句用于处理和前面的 case 都不匹配的值, 将第 3 行代码替换为 int week = 8, 再次运行程序, 输出结果如图 2-23 所示 图 2-23 运行结果在使用 switch 语句的过程中, 如果多个 case 条件后面的执行语句是一样的, 则该执行语句只需书写一次即可, 这是一种简写的方式 例如, 要判断一周中的某一天是否为工作日, 同样使用数字 1~7 来表示星期一到星期天, 当输入的数字为 时就视为工作日, 否则就视为休息日 接下来通过一个案例来实现上面描述的情况, 如文件 2-12 所示 文件 2-12 Example11.java 1 public class Example11 { 3 int week = 2; 4 switch (week) { 5 case 1: 6 case 2: 7 case 3: 8 case 4: 9 case 5: 10 // 当 week 满足值 中任意一个时, 处理方式相同 11 System.out.println(" 今天是工作日 "); 12 break; 13 case 6: 27

28 14 case 7: 15 // 当 week 满足值 6 7 中任意一个时, 处理方式相同 16 System.out.println(" 今天是休息日 "); 17 break; 18 } 19 } 20 } 运行结果如图 2-24 所示 图 2-24 运行结果 文件 2-12 中, 当变量 week 值为 中任意一个值时, 处理方式相同, 都会打印 今天是 工作日 ; 当变量 week 值为 6 7 中任意一个值时, 打印 今天是休息日 2.5 循环结构语句 在实际生活中经常会将同一件事情重复做很多次 比如在做眼保健操的第四节轮刮眼眶时, 会重复刮眼眶的动作 ; 打乒乓球时, 会重复挥拍的动作等 在 Java 中有一种特殊的语句叫做循环语句, 它可以实现将一段代码重复执行, 例如循环打印 100 位学生的考试成绩 循环语句分为 while 循环语句 do while 循环语句和 for 循环语句三种 接下来针对这三种循环语句分别进行详细地讲解 while 循环语句 while 循环语句和 2.4 节讲到的条件判断语句有些相似, 都是根据条件判断来决定是否执行大括号内的执行语句 区别在于,while 语句会反复地进行条件判断, 只要条件成立,{} 内的执行语句就会执行, 直到条件不成立,while 循环结束 while 循环语句的语法结构如下 : while( 循环条件 ){ 执行语句... } 在上面的语法结构中,{} 中的执行语句被称作循环体, 循环体是否执行取决于循环条件 当循环条件为 true 时, 循环体就会执行 循环体执行完毕时会继续判断循环条件, 如条件仍为 true 则会继续执行, 直到循环条件为 false 时, 整个循环过程才会结束 while 循环的执行流程如图 2-25 所示 28

29 图 2-25 while 循环的流程图 接下来通过一个案例来实现打印 1~4 之间的自然数, 如文件 2-13 所示 文件 2-13 Example12.java 1 public class Example12 { 3 int x = 1; // 定义变量 x, 初始值为 1 4 while (x <= 4) { // 循环条件 5 System.out.println("x = " + x); // 条件成立, 打印 x 的值 6 x++; // x 进行自增 7 } 8 } 9 } 运行结果如图 2-26 所示 图 2-26 运行结果文件 2-13 中,x 初始值为 1, 在满足循环条件 x <= 4 的情况下, 循环体会重复执行, 打印 x 的值并让 x 进行自增 因此打印结果中 x 的值分别为 值得注意的是, 文件中第 6 行代码用于在每次循环时改变变量 x 的值, 从而达到最终改变循环条件的目的 如果没有这行代码, 整个循环会进入无限循环的状态, 永远不会结束 do while 循环语句 do while 循环语句和 while 循环语句功能类似, 其语法结构如下 : do { 执行语句... } while( 循环条件 ); 在上面的语法结构中, 关键字 do 后面 {} 中的执行语句是循环体 do while 循环语句将循环条件放在了循环体的后面 这也就意味着, 循环体会无条件执行一次, 然后再根据循环条件来决定是否继续执行 29

30 do while 循环的执行流程如图 2-27 所示 图 2-27 do while 循环的执行流程 接下来使用 do while 循环语句将文件 2-13 进行改写, 如文件 2-14 所示 文件 2-14 Example13.java 1 public class Example13 { 3 int x = 1; // 定义变量 x, 初始值为 1 4 do { 5 System.out.println("x = " + x); // 打印 x 的值 6 x++; // 将 x 的值自增 7 } while (x <= 4); // 循环条件 8 } 9 } 运行结果如图 2-28 所示 图 2-28 运行结果文件 2-14 和文件 2-13 运行结果一致, 这就说明 do while 循环和 while 循环能实现同样的功能 然而在程序运行过程中, 这两种语句还是有差别的 如果循环条件在循环语句开始时就不成立, 那么 while 循环的循环体一次都不会执行, 而 do while 循环的循环体还是会执行一次 例如将文件中的循环条件 x<=4 改为 x < 1, 文件 2-14 会打印 x=1, 而文件 2-13 什么也不会打印 for 循环语句 for 循环语句是最常用的循环语句, 一般用在循环次数已知的情况下 for 循环语句的语法格式如下 : for( 初始化表达式 ; 循环条件 ; 操作表达式 ){ 执行语句... } 在上面的语法结构中,for 关键字后面 () 中包括了三部分内容 : 初始化表达式 循环条件和操作表达式, 30

31 它们之间用 (;) 分隔,{} 中的执行语句为循环体 接下来分别用 1 表示初始化表达式,2 表示循环条件,3 表示操作表达式,4 表示循环体, 通过序号 来具体分析 for 循环的执行流程 具体如下 : for(1 ; 2 ; 3){ 4 } 第一步, 执行 1 第二步, 执行 2, 如果判断结果为 true, 执行第三步, 如果判断结果为 false, 执行第五步 第三步, 执行 4 第四步, 执行 3, 然后重复执行第二步 第五步, 退出循环 接下来通过一个案例对自然数 1~4 进行求和, 如文件 2-15 所示 文件 2-15 Example14.java 1 public class Example14 { 3 int sum = 0; // 定义变量 sum, 用于记住累加的和 4 for (int i = 1; i <= 4; i++) { // i 的值会在 1~4 之间变化 5 sum += i; // 实现 sum 与 i 的累加 6 } 7 System.out.println("sum = " + sum); // 打印累加的和 8 } 9 } 运行结果如图 2-29 所示 图 2-29 运行结果 文件 2-15 中, 变量 i 的初始值为 1, 在判断条件 i<=4 为 true 的情况下, 会执行循环体 sum+=i, 执行 完毕后, 会执行操作表达式 i++,i 的值变为 2, 然后继续进行条件判断, 开始下一次循环, 直到 i=5 时, 条件 i<=4 为 false, 结束循环, 执行 for 循环后面的代码, 打印 sum=10 为了让初学者能熟悉整个 for 循环的执行过程, 现将文件 2-15 运行期间每次循环中变量 sum 和 i 的值 通过表 2-8 罗列出来 表 2-8 sum 和 i 循环中的值 循环次数 sum i 第一次 1 1 第二次 3 2 第三次 6 3 第四次

32 2.5.4 循环嵌套 嵌套循环是指在一个循环语句的循环体中再定义一个循环语句的语法结构 while do while for 循 环语句都可以进行嵌套, 并且它们之间也可以互相嵌套, 其中最常见的是在 for 循环中嵌套 for 循环, 格式 如下 : for( 初始化表达式 ; 循环条件 ; 操作表达式 ) {... for( 初始化表达式 ; 循环条件 ; 操作表达式 ) { 执行语句... }... } 接下来通过一个案例来实现使用 * 打印直角三角形, 如文件 2-16 所示 文件 2-16 Example15.java 1 public class Example15 { 3 int i, j; // 定义两个循环变量 4 for (i = 1; i <= 9; i++) { // 外层循环 5 for (j = 1; j <= i; j++) { // 内层循环 6 System.out.print("*"); // 打印 * 7 } 8 System.out.print("\n"); // 换行 9 } 10 } 11 } 运行结果如图 2-30 所示 图 2-30 运行结果在文件 2-16 中定义了两层 for 循环, 分别为外层循环和内层循环, 外层循环用于控制打印的行数, 内层循环用于打印 *, 每一行的 * 个数逐行增加, 最后输出一个直角三角形 由于嵌套循环程序比较复杂, 下面分步骤进行详细地讲解, 具体如下 : 第一步, 在第 3 行代码定义了两个循环变量 i 和 j, 其中 i 为外层循环变量,j 为内层循环变量 第二步, 在第 4 行代码将 i 初始化为 1, 条件 i <= 9 为 true, 首次进入外层循环的循环体 第三步, 在第 5 行代码将 j 初始化为 1, 由于此时 i 的值为 1, 条件 j <= i 为 true, 首次进入内层循环的循环体, 打印一个 * 32

33 第四步, 执行第 5 行代码中内层循环的操作表达式 j++, 将 j 的值自增为 2 第五步, 执行第 5 行代码中的判断条件 j<=i, 判断结果为 false, 内层循环结束 执行后面的代码, 打印换行符 第六步, 执行第 4 行代码中外层循环的操作表达式 i++, 将 i 的值自增为 2 第七步, 执行第 4 行代码中的判断条件 i<=9, 判断结果为 true, 进入外层循环的循环体, 继续执行内层循环 第八步, 由于 i 的值为 2, 内层循环会执行两次, 即在第 2 行打印两个 * 在内层循环结束时会打印换行符 第九步, 依此类推, 在第 3 行会打印 3 个 *, 逐行递增, 直到 i 的值为 10 时, 外层循环的判断条件 i <= 9 结果为 false, 外层循环结束, 整个程序也就结束了 跳转语句 (break continue) 跳转语句用于实现循环执行过程中程序流程的跳转, 在 Java 中的跳转语句有 break 语句和 continue 语 句 接下来分别进行详细地讲解 1.break 语句 在 switch 条件语句和循环语句中都可以使用 break 语句 当它出现在 switch 条件语句中时, 作用是终 止某个 case 并跳出 switch 结构 当它出现在循环语句中, 作用是跳出循环语句, 执行后面的代码 关于在 switch 语句中使用 break 前面的文件已经用过了, 接下来将文件 2-13 稍作修改, 当变量 x 的值为 3 时使用 break 语句跳出循环, 修改后的代码如文件 2-17 所示 文件 2-17 Example16.java 1 public class Example16 { 3 int x = 1; // 定义变量 x, 初始值为 1 4 while (x <= 4) { // 循环条件 5 System.out.println("x = " + x); // 条件成立, 打印 x 的值 6 if (x == 3) { 7 break; 8 } 9 x++; // x 进行自增 10 } 11 } 12 } 运行结果如图 2-31 所示 图 2-31 运行结果 文件 2-17 中, 通过 while 循环打印 x 的值, 当 x 的值为 3 时使用 break 语句跳出循环 因此打印结果 中并没有出现 x=4 33

34 当 break 语句出现在嵌套循环中的内层循环时, 它只能跳出内层循环, 如果想使用 break 语句跳出外 层循环则需要对外层循环添加标记 接下来将文件 2-16 稍作修改, 控制程序只打印 4 行 *, 如文件 2-18 所示 文件 2-18 Example17.java 1 public class Example17 { 3 int i, j; // 定义两个循环变量 4 itcast: for (i = 1; i <= 9; i++) { // 外层循环 5 for (j = 1; j <= i; j++) { // 内层循环 6 if (i > 4) { // 判断 i 的值是否大于 4 7 break itcast; // 跳出外层循环 8 } 9 System.out.print("*"); // 打印 * 10 } 11 System.out.print("\n"); // 换行 12 } 13 } 14 } 运行结果如图 2-32 所示 图 2-32 运行结果 文件 2-18 与文件 2-16 实现原理类似, 只是在外层 for 循环前面增加了标记 itcast 当 i>4 时, 使用 break itcast; 语句跳出外层循环 因此程序只打印了 4 行 * 2.continue 语句 continue 语句用在循环语句中, 它的作用是终止本次循环, 执行下一次循环 接下来通过一个案例对 1~100 之内的奇数求和, 如文件 2-19 所示 文件 2-19 Example18.java 1 public class Example18 { 3 int sum = 0; // 定义变量 sum, 用于记住和 4 for (int i = 1; i <= 100; i++) { 5 if (i % 2 == 0) { // i 是一个偶数, 不累加 6 continue; // 结束本次循环 7 } 8 sum += i; // 实现 sum 和 i 的累加 9 } 10 System.out.println("sum = " + sum); 11 } 12 } 34

35 运行结果如图 2-33 所示 图 2-33 运行结果文件 2-19 使用 for 循环让变量 i 的值在 1~100 之间循环, 在循环过程中, 当 i 的值为偶数时, 将执行 continue 语句结束本次循环, 进入下一次循环, 当 i 的值为奇数时,sum 和 i 进行累加, 最终得到 1~100 之间所有奇数的和, 打印 sum = 2500 在嵌套循环语句中,continue 语句后面也可以通过使用标记的方式结束本次外层循环, 用法与 break 语句相似, 在此不再举例说明 任务 2-2 猜数字游戏 任务介绍 1. 任务描述编写一个猜数字游戏的程序, 顾名思义, 这个游戏就是你出个数字 我来猜 程序后台预先生成一个 0~9 之间的随机数, 用户键盘录入一个所猜的数字, 如果输入的数字和后台预先生成的数字相同, 则表示猜对了, 这时, 程序会打印 恭喜您, 答对了, 如果不相同, 则比较输入的数字和后台预先生成的数字的大小, 如果大了, 打印 sorry, 您猜大了! ; 如果小了, 打印 sorry, 您猜小了! ; 如果一直猜错, 则游戏一直继续, 直到数字猜对为止 2. 运行结果任务运行结果如图 2-34 所示 图 2-34 运行结果 任务目标 学会分析 猜数字游戏 程序的实现思路 根据思路独立完成 猜数字游戏 的源代码编写 编译及运行 掌握在程序中使用 if 选择结构和 while 循环结构语句进行运算操作 35

36 实现思路 (1) 从任务描述中分析可知, 要实现此功能, 首先程序后台要预先生成一个 0~9 之间的随机数, 生成随机数可以使用 Random 类中的 nextint(int n) 方法, 其具体的方法定义如下 : public int nextint(int n) (2) 要使用键盘输入所猜的数字, 可以使用 Scanner 类, 以下代码使用户能够从 System.in 中读取一个数字 : Scanner sc = new Scanner(System.in); int i = sc.nextint(); (3) 输入数字后, 需要比较键盘输入的数字和后台预先生成的数字, 由于猜数字并非一定一次成功, 很可能是多次进行, 因此可以通过 while 循环使程序能够多次键盘输入, 每次输入都进行猜数字对错判断 如果猜对了, 跳出循环, 输出 恭喜您, 答对了!, 结束游戏 (4) 如果猜错, 这时使用 if...else 语句判断, 将错误分为猜大了和猜小了两种结果 如果猜大了, 打印 sorry, 您猜大了! 继续下一次循环, 如果猜小了, 打印 sorry, 您猜小了! 继续下一次循环 根据结果, 给出提示, 接着继续猜数字, 游戏继续 实现代码 猜数字游戏的实现代码, 如文件 2-20 所示 文件 2-20 GuessNumber.java 1 package cn.itcast.chapter02.task02; 2 import java.util.random; 3 import java.util.scanner; 4 public class GuessNumber { 5 public static void main(string[] args) { 6 //1. 通过 Random 类中的 nextint(int n) 方法, 生成一个 0-9 之间的随机数 7 int randomnumber = new Random().nextInt(10); 8 System.out.println(" 随机数已生成!"); 9 //2. 输入猜的数字 10 System.out.println("---- 请输入您猜的数字 :----"); 11 Scanner sc = new Scanner(System.in); 12 int enternumber = sc.nextint(); 13 //3. 通过 while 循环, 进行猜数字对错判断 14 // 猜对, 跳出循环, 游戏结束 15 while(enternumber!= randomnumber){ 16 // 猜错了, 根据结果, 给出提示, 接着猜数字, 游戏继续 17 if(enternumber>randomnumber) { 18 // 如果猜大了, 打印 sorry, 您猜大了! 继续下一次循环 19 System.out.println("sorry, 您猜大了!"); 20 }else { 21 // 如果猜小了, 打印 sorry, 您猜小了! 继续下一次循环 22 System.out.println("sorry, 您猜小了!"); 23 } 36

37 24 // 输入猜的数字 25 System.out.println("---- 请输入您猜的数字 :----"); 26 enternumber = sc.nextint(); 27 } 28 System.out.println(" 恭喜您, 答对了!"); 29 } 30 } 在文件 2-20 中, 第 7 行代码通过 Random 类中的方法 nextint(int n) 生成一个 0-9 之间的随机数, 需要注意的是, 此方法用于生成在 0( 包括 ) 和指定值 n( 不包括 ) 之间的随机数值 ; 第 11~12 行代码用于获取键盘输入的数字 ; 第 15~28 行代码用于比较键盘输入的数字和后台预先生成的数字 其中使用了 while 循环语句来判断如果猜对了, 跳出循环, 游戏结束 ; 如果猜错了, 通过 while 循环语句进行继续猜数字操作, 并在循环内部使用 if...else 语句对猜错的情况进行提示, 以便提高下一次猜数字的准确性 需要注意的是,Scanner 和 Random 类都是 java.util 包下的类, 在程序中使用时需要通过 import 语句引入这两个类所在的包 关于 Random 类更多知识, 将在后面的章节中进行专门地讲解 2.6 方法 什么是方法 方法就是一段可以重复调用的代码 假设有一个游戏程序, 程序在运行过程中, 要不断地发射炮弹 发射炮弹的动作需要编写 100 行的代码, 其中包含获得炮弹 将炮弹放入炮身和发射的动作, 在每次实现发射炮弹的地方都需要重复地编写这 100 行代码, 这样程序会变得很臃肿, 可读性也非常差 为了解决上述的问题, 通常会将发射炮弹的代码提取出来, 然后根据不同的操作, 将代码分别放在不同的 {} 中, 并分别为这些段代码起名, 每一部分提取出来的代码可以被看作是程序中定义的一个方法, 这样在每次发射炮弹的地方, 只需通过这些名字依次来调用这些方法, 来完成发射炮弹的动作 例如, 要完成炮弹发射前的准备工作, 这时根据需求, 只需调用获得炮弹和将炮弹放入炮身这两个方法即可 需要注意的是, 在有些书中也会把方法称为函数, 这两者本身并没有什么区别, 是同样的概念, 只是称呼方式不一样 接下来通过一些案例来介绍方法在程序中起到的作用, 先来看一下在不使用方法时如何实现打印三个长宽不同的矩形, 如文件 2-21 所示 文件 2-21 Example19.java 1 public class Example19 { 3 // 下面的循环是使用 * 打印一个宽为 5 高为 3 的矩形 4 for (int i = 0; i < 3; i++) { 5 for (int j = 0; j < 5; j++) { 6 System.out.print("*"); 7 } 8 System.out.print("\n"); 9 } 10 System.out.print("\n"); 11 // 下面的循环是使用 * 打印一个宽为 4 高为 2 的矩形 12 for (int i = 0; i < 2; i++) { 37

38 13 for (int j = 0; j < 4; j++) { 14 System.out.print("*"); 15 } 16 System.out.print("\n"); 17 } 18 System.out.print("\n"); 19 // 下面的循环是使用 * 打印一个宽为 10 高为 6 的矩形 20 for (int i = 0; i < 6; i++) { 21 for (int j = 0; j < 10; j++) { 22 System.out.print("*"); 23 } 24 System.out.print("\n"); 25 } 26 System.out.print("\n"); 27 } 28 } 运行结果如图 2-35 所示 图 2-35 运行结果在文件 2-21 中, 分别使用 3 个嵌套 for 循环完成了三个矩形的打印, 仔细观察会发现, 这 3 个嵌套 for 循环的代码是重复的, 都在做一样的事情 此时, 就可以将使用 * 打印矩形的功能定义为方法, 在程序中调用三次即可, 修改后的代码如文件 2-22 所示 文件 2-22 Example20.java 1 public class Example20 { 3 printrectangle(3, 5); // 调用 printrectangle() 方法实现打印矩形 4 printrectangle(2, 4); 5 printrectangle(6, 10); 6 } 7 // 下面定义了一个打印矩形的方法, 接收两个参数, 其中 height 为高,width 为宽 8 public static void printrectangle(int height, int width) { 9 // 下面是使用嵌套 for 循环实现 * 打印矩形 10 for (int i = 0; i < height; i++) { 11 for (int j = 0; j < width; j++) { 38

39 12 System.out.print("*"); 13 } 14 System.out.print("\n"); 15 } 16 System.out.print("\n"); 17 } 18 } 运行结果同文件 2-21 的运行结果相同, 如图 2-36 所示 图 2-36 运行结果文件 2-22 中的第 8~17 行代码就定义了一个方法, 其中 {} 内实现打印矩形的代码是方法体, printrectangle 是方法名, 第 8 行 () 中的 height 和 width 是方法的参数, 方法名前面的 void 是方法的返回值类型 在 Java 中, 声明一个方法的具体语法格式如下 : 修饰符返回值类型方法名 ([ 参数类型参数名 1, 参数类型参数名 2,... ]){ 执行语句... return 返回值 ; } 对于上面的语法格式具体说明如下 : 修饰符 : 方法的修饰符比较多, 有对访问权限进行限定的, 有静态修饰符 static, 还有最终修饰符 final 等, 这些修饰符在后面的学习过程中会逐步介绍 返回值类型 : 用于限定方法返回值的数据类型 参数类型 : 用于限定调用方法时传入参数的数据类型 参数名 : 是一个变量, 用于接收调用方法时传入的数据 return 关键字 : 用于结束方法以及返回方法指定类型的值 返回值 : 被 return 语句返回的值, 该值会返回给调用者 需要特别注意的是, 方法中的 参数类型参数名 1, 参数类型参数名 2 被称作参数列表, 它用于描述方法在被调用时需要接收的参数, 如果方法不需要接收任何参数, 则参数列表为空, 即 () 内不写任何内容 方法的返回值必须为方法声明的返回值类型, 如果方法中没有返回值, 返回值类型要声明为 void, 此时, 方法中 return 语句可以省略 文件 2-22 中的 printrectangle() 方法是没有返回值的, 接下来通过一个案例来演示方法中有返回值的情况, 如文件 2-23 所示 文件 2-23 Example21.java 39

40 1 public class Example21 { 3 int area = getarea(3, 5); // 调用 getarea 方法 4 System.out.println(" The area is " + area); 5 } 6 // 下面定义了一个求矩形面积的方法, 接收两个参数, 其中 x 为高,y 为宽 7 public static int getarea(int x, int y) { 8 int temp = x * y; // 使用变量 temp 记住运算结果 9 return temp; // 将变量 temp 的值返回 10 } 11 } 运行结果如图 2-37 所示 图 2-37 运行结果在文件 2-23 中, 定义了一个 getarea() 方法用于求矩形的面积, 参数 x 和 y 分别用于接收调用方法时传入的高和宽,return 语句用于返回计算所得的面积 在 main() 方法中通过调用 getarea() 方法, 获得矩形的面积, 并将结果打印 接下来通过一个图例演示 getarea() 方法的整个调用过程, 如图 2-38 所示 图 2-38 getarea() 方法的调用过程从图 2-38 中可以看出, 在程序运行期间, 参数 x 和 y 相当于在内存中定义的两个变量 当调用 getarea() 方法时, 传入的参数 3 和 5 分别赋值给变量 x 和 y, 并将 x*y 的结果通过 return 语句返回, 整个方法的调用过程结束, 变量 x 和 y 被释放 方法的重载 假设要在程序中实现一个对数字求和的方法, 由于参与求和数字的个数和类型都不确定, 因此要针对不同的情况去设计不同的方法 接下来通过一个案例来实现对两个整数相加 对三个整数相加以及对两个小数相加的功能, 具体实现如文件 2-24 所示 文件 2-24 Example22.java 1 public class Example22 { 40

41 3 // 下面是针对求和方法的调用 4 int sum1 = add01(1, 2); 5 int sum2 = add02(1, 2, 3); 6 double sum3 = add03(1.2, 2.3); 7 // 下面的代码是打印求和的结果 8 System.out.println("sum1=" + sum1); 9 System.out.println("sum2=" + sum2); 10 System.out.println("sum3=" + sum3); 11 } 12 // 下面的方法实现了两个整数相加 13 public static int add01(int x, int y) { 14 return x + y; 15 } 16 // 下面的方法实现了三个整数相加 17 public static int add02(int x, int y, int z) { 18 return x + y + z; 19 } 20 // 下面的方法实现了两个小数相加 21 public static double add03(double x, double y) { 22 return x + y; 23 } 24 } 运行结果如图 2-39 所示 图 2-39 运行结果从文件 2-24 中的代码不难看出, 程序需要针对每一种求和的情况都定义一个方法, 如果每个方法的名称都不相同, 在调用时就很难分清哪种情况该调用哪个方法 为了解决这个问题,Java 允许在一个程序中定义多个名称相同的方法, 但是参数的类型或个数必须不同, 这就是方法的重载 接下来通过方法重载的方式将文件 2-24 进行修改, 如文件 2-25 所示 文件 2-25 Example23.java 1 public class Example23 { 3 // 下面是针对求和方法的调用 4 int sum1 = add(1, 2); 5 int sum2 = add(1, 2, 3); 6 double sum3 = add(1.2, 2.3); 7 // 下面的代码是打印求和的结果 8 System.out.println("sum1=" + sum1); 9 System.out.println("sum2=" + sum2); 41

42 10 System.out.println("sum3=" + sum3); 11 } 12 // 下面的方法实现了两个整数相加 13 public static int add(int x, int y) { 14 return x + y; 15 } 16 // 下面的方法实现了三个整数相加 17 public static int add(int x, int y, int z) { 18 return x + y + z; 19 } 20 // 下面的方法实现了两个小数相加 21 public static double add(double x, double y) { 22 return x + y; 23 } 24 } 文件 2-25 的运行结果和文件 2-24 一样, 如图 2-39 所示 文件 2-25 中定义了三个同名的 add() 方法, 但它们的参数个数或类型不同, 从而形成了方法的重载 在 main() 方法中调用 add() 方法时, 通过传入不同 的参数便可以确定调用哪个重载的方法, 如 add(1,2) 调用的是两个整数求和的方法 值得注意的是, 方法 的重载与返回值类型无关, 它需要满足两个条件, 一是方法名相同, 二是参数个数或参数类型不相同 2.7 数组 现在需要统计某公司员工的工资情况, 例如计算平均工资 最高工资等 假设该公司有 50 名员工, 用前面所学的知识, 程序首先需要声明 50 个变量来分别记住每位员工的工资, 这样做会显得很麻烦 在 Java 中, 可以使用一个数组来记住这 50 名员工的工资 数组是指一组数据的集合, 数组中的每个数据被称作元素 数组可以存放任意类型的元素, 但同一个数组里存放的元素类型必须一致 数组可分为一维数组和多维数组, 本节将围绕数组进行详细地讲解 数组的定义 在 Java 中, 可以使用以下格式来定义一个数组 : int[] x = new int[100]; 上述语句就相当于在内存中定义了 100 个 int 类型的变量, 第一个变量的名称为 x[0], 第二个变量的名称为 x[1], 依此类推, 第 100 个变量的名称为 x[99], 这些变量的初始值都是 0 为了更好地理解数组的这种定义方式, 可以将上面的一句代码分成两句来写, 具体如下 : int[] x; // 声明一个 int[] 类型的变量 x = new int[100]; // 创建一个长度为 100 的数组接下来, 通过两张内存图来详细地说明数组在创建过程中内存的分配情况 第一行代码 int[] x; 声明了一个变量 x, 该变量的类型为 int[], 即一个 int 类型的数组 变量 x 会占用一块内存单元, 它没有被分配初始值 内存中的状态如图 2-40 所示 42

43 图 2-40 内存状态图 第二行代码 x = new int[100]; 创建了一个数组, 将数组的地址赋值给变量 x 在程序运行期间可以使 用变量 x 来引用数组, 这时内存中的状态会发生变化, 如图 2-41 所示 int[] x 内存 0x3000 ( 数组的首地址 ) 0x3000 new int[100] X[0] X[1] X[98] X[99] 图 2-41 内存状态图 图 2-41 中描述了变量 x 引用数组的情况 该数组中有 100 个元素, 初始值都为 0 数组中的每个元素 都有一个索引 ( 也可称为角标 ), 要想访问数组中的元素可以通过 x[0] x[1] x[98] x[99] 的形式 需要注意的是, 数组中最小的索引是 0, 最大的索引是 数组的长度 -1 在 Java 中, 为了方便获得数组的 长度, 提供了一个 length 属性, 在程序中可以通过 数组名.length 的方式来获得数组的长度, 即元素的 个数 接下来, 通过一个案例来演示如何定义数组以及访问数组中的元素, 如文件 2-26 所示 文件 2-26 Example24.java 1 public class Example24 { 3 int[] arr; // 声明变量 4 arr = new int[3]; // 创建数组对象 5 System.out.println("arr[0]=" + arr[0]); // 访问数组中的第一个元素 6 System.out.println("arr[1]=" + arr[1]); // 访问数组中的第二个元素 7 System.out.println("arr[2]=" + arr[2]); // 访问数组中的第三个元素 8 System.out.println(" 数组的长度是 :" + arr.length); // 打印数组长度 9 } 10 } 运行结果如图 2-42 所示 图 2-42 运行结果在文件 2-26 中, 第 3 行代码声明了一个 int[] 类型变量 arr, 第 4 行代码创建了一个长度为 3 的数组, 并将数组在内存中的地址赋值给变量 arr 在第 5~7 行代码中, 通过角标来访问数组中的元素, 第 8 行代码通过 length 属性访问数组中元素的个数 从打印结果可以看出, 数组的长度为 3, 且三个元素初始值都 43

44 为 0, 这是因为当数组被成功创建后, 数组中元素会被自动赋予一个默认值, 根据元素类型的不同, 默认初始化的值也是不一样的 具体如表 2-9 所示 表 2-9 元素默认值数据类型默认初始化值 byte short int long 0 float double 0.0 char 一个空字符, 即 \u0000 boolean false 引用数据类型 null, 表示变量不引用任何对象如果在使用数组时, 不想使用这些默认初始值, 也可以显式地为这些元素赋值 接下来通过一个案例来学习如何为数组的元素赋值, 如文件 2-27 所示 文件 2-27 Example25.java 1 public class Example25 { 3 int[] arr = new int[4]; // 定义可以存储 4 个元素的整数类型数组 4 arr[0] = 1; // 为第 1 个元素赋值 1 5 arr[1] = 2; // 为第 2 个元素赋值 2 6 // 依次打印数组中每个元素的值 7 System.out.println("arr[0]=" + arr[0]); 8 System.out.println("arr[1]=" + arr[1]); 9 System.out.println("arr[2]=" + arr[2]); 10 System.out.println("arr[3]=" + arr[3]); 11 } 12 } 运行结果如图 2-43 所示 图 2-43 运行结果在文件 2-27 中, 第 3 行代码定义了一个数组, 此时数组中每个元素都为默认初始值 0 第 4 5 行代码通过赋值语句将数组中的元素 arr[0] 和 arr[1] 分别赋值为 1 和 2, 而元素 arr[2] 和 arr[3] 没有赋值, 其值仍为 0, 因此打印结果中四个元素的值依次为 在定义数组时只指定数组的长度, 由系统自动为元素赋初值的方式称作动态初始化 在初始化数组时还有一种方式叫做静态初始化, 就是在定义数组的同时就为数组的每个元素赋值 数组的静态初始化有两种方式, 具体格式如下 : 1. 类型 [] 数组名 = new 类型 []{ 元素, 元素, }; 2. 类型 [] 数组名 = { 元素, 元素, 元素, }; 上面的两种方式都可以实现数组的静态初始化, 但是为了简便, 建议采用第二种方式 接下来通过一个案例来演示数组静态初始化的效果, 如文件 2-28 所示 文件 2-28 Example26.java 1 public class Example26 { 44

45 3 int[] arr = { 1, 2, 3, 4 }; // 静态初始化 4 // 依次访问数组中的元素 5 System.out.println("arr[0] = " + arr[0]); 6 System.out.println("arr[1] = " + arr[1]); 7 System.out.println("arr[2] = " + arr[2]); 8 System.out.println("arr[3] = " + arr[3]); 9 } 10 } 运行结果如图 2-44 所示 图 2-44 运行结果 文件 2-28 采用静态初始化的方式为每个元素赋予初值, 其值分别是 值得注意的是, 文 件中的第 3 行代码千万不可写成 int[] x = new int[4]{1,2,3,4};, 这样写编译器会报错 原因在于编译器会认 为数组限定的元素个数 [4] 与实际存储的元素 {1,2,3,4} 个数有可能不一致, 存在一定的安全隐患 脚下留心 : 1. 每个数组的索引都有一个范围, 即 0~length-1 在访问数组的元素时, 索引不能超出这个范围, 否 则程序会报错, 如文件 2-29 所示 1 public class Example27 { 文件 2-29 Example27.java 3 int[] arr = new int[4]; // 定义一个长度为 4 的数组 4 System.out.println("arr[0]=" + arr[4]); // 通过角标 4 访问数组元素 5 } 6 } 运行结果如图 2-45 所示 图 2-45 运行结果图 2-45 的运行结果中所提示的错误信息是数组越界异常 ArrayIndexOutOfBoundsException, 出现这个异常的原因是数组的长度为 4, 其索引范围为 0~3, 文件 2-29 中的第 4 行代码使用索引 4 来访问元素时超出了数组的索引范围 所谓异常指程序中出现的错误, 它会报告出错的异常类型 出错的行号以及出错的原因, 关于异常在后面的章节会有详细地讲解 2. 在使用变量引用一个数组时, 变量必须指向一个有效的数组对象, 如果该变量的值为 null, 则意味着没有指向任何数组, 此时通过该变量访问数组的元素会出现空指针异常, 接下来通过一个案例来演示这 45

46 种异常, 如文件 2-30 所示 文件 2-30 Example28.java 1 public class Example28 { 3 int[] arr = new int[3]; // 定义一个长度为 3 的数组 4 arr[0] = 5; // 为数组的第一个元素赋值 5 System.out.println("arr[0]=" + arr[0]); // 访问数组的元素 6 arr = null; // 将变量 arr 置为 null 7 System.out.println("arr[0]=" + arr[0]); // 访问数组的元素 8 } 9 } 运行结果如图 2-46 所示 图 2-46 运行结果 通过图 2-46 所示的运行结果可以看出, 文件 2-30 的第 4 5 行代码都能通过变量 arr 正常地操作数组, 第 6 行代码将变量置为 null, 当第 7 行代码再次访问数组时就出现了空指针异常 NullPointerException 数组的常见操作 数组在编写程序时应用非常广泛, 灵活地使用数组对实际开发很重要 接下来, 本节将针对数组的常 见操作 ( 如数组的遍历 最值的获取 数组的排序等 ) 进行详细地讲解 1. 数组遍历 在操作数组时, 经常需要依次访问数组中的每个元素, 这种操作称作数组的遍历 接下来通过一个案 例来学习如何使用 for 循环遍历数组, 如文件 2-31 所示 文件 2-31 Example29.java 1 public class Example29 { 3 int[] arr = { 1, 2, 3, 4, 5 }; // 定义数组 4 // 使用 for 循环遍历数组的元素 5 for (int i = 0; i < arr.length; i++) { 6 System.out.println(arr[i]); // 通过索引访问元素 7 } 8 } 9 } 运行结果如图 2-47 所示 46

47 图 2-47 运行结果 文件 2-31 中, 定义一个长度为 5 的数组 arr, 数组的角标为 0~4 由于 for 循环中定义的变量 i 的值在 循环过程中为 0~4, 因此可以作为索引, 依次去访问数组中的元素, 并将元素的值打印出来 2. 数组最值 在操作数组时, 经常需要获取数组中元素的最值 接下来通过一个案例来演示如何获取数组中元素的 最大值, 如文件 2-32 所示 文件 2-32 Example30.java 1 public class Example30 { 3 int[] arr = { 4, 1, 6, 3, 9, 8 }; // 定义一个数组 4 int max = getmax(arr); // 调用获取元素最大值的方法 5 System.out.println("max=" + max); // 打印最大值 6 } 7 static int getmax(int[] arr) { 8 int max = arr[0]; // 定义变量 max 用于记住最大数, 首先假设第一个元素为最大值 9 // 下面通过一个 for 循环遍历数组中的元素 10 for (int x = 1; x < arr.length; x++) { 11 if (arr[x] > max) { // 比较 arr[x] 的值是否大于 max 12 max = arr[x]; // 条件成立, 将 arr[x] 的值赋给 max 13 } 14 } 15 return max; // 返回最大值 max 16 } 17 } 运行结果如图 2-48 所示 图 2-48 运行结果文件 2-32 的 getmax() 方法用于求数组中的最大值, 该方法中定义了一个临时变量 max, 用于记住数组的最大值 首先假设数组中第一个元素 arr[0] 为最大值, 然后使用 for 循环对数组进行遍历, 在遍历的过程中只要遇到比 max 值还大的元素, 就将该元素赋值给 max 这样一来, 变量 max 就能够在循环结束时记住数组中的最大值 需要注意的是,for 循环中的变量 i 是从 1 开始的, 这样写的原因是程序已经假设第一个元素为最大值,for 循环只需要从第二个元素开始比较, 从而提高程序的运行效率 3. 数组排序在操作数组时, 经常需要对数组中的元素进行排序 下面将为读者介绍一种比较常见的排序算法 47

48 冒泡排序 在冒泡排序的过程中, 不断地比较数组中相邻的两个元素, 较小者向上浮, 较大者往下沉, 整 个过程和水中气泡上升的原理相似 接下来通过几个步骤来具体分析一下冒泡排序的整个过程, 具体如下 : 第一步, 从第一个元素开始, 将相邻的两个元素依次进行比较, 直到最后两个元素完成比较 如果前 一个元素比后一个元素大, 则交换它们的位置 整个过程完成后, 数组中最后一个元素自然 就是最大值, 这样也就完成了第一轮比较 第二步, 除了最后一个元素, 将剩余的元素继续进行两两比较, 过程与第一步相似, 这样就可以将数 组中第二大的数放在倒数第二个位置 第三步, 依此类推, 持续对越来越少的元素重复上面的步骤, 直到没有任何一对元素需要比较为止 了解了冒泡排序的原理之后, 接下来通过一个案例来实现冒泡排序, 如文件 2-33 所示 文件 2-33 Example31.java 1 public class Example31 { 3 int[] arr = { 9, 8, 3, 5, 2 }; 4 System.out.print(" 冒泡排序前 :"); 5 printarray(arr); // 打印数组元素 6 bubblesort(arr); // 调用排序方法 7 System.out.print(" 冒泡排序后 :"); 8 printarray(arr); // 打印数组元素 9 } 10 // 定义打印数组元素的方法 11 public static void printarray(int[] arr) { 12 // 循环遍历数组的元素 13 for (int i = 0; i < arr.length; i++) { 14 System.out.print(arr[i] + " "); // 打印元素和空格 15 } 16 System.out.print("\n"); 17 } 18 // 定义对数组排序的方法 19 public static void bubblesort(int[] arr) { 20 // 定义外层循环 21 for (int i = 0; i < arr.length - 1; i++) { 22 // 定义内层循环 23 for (int j = 0; j < arr.length - i - 1; j++) { 24 if (arr[j] > arr[j + 1]) { // 比较相邻元素 25 // 下面的三行代码用于交换两个元素 26 int temp = arr[j]; 27 arr[j] = arr[j + 1]; 28 arr[j + 1] = temp; 29 } 30 } 31 System.out.print(" 第 " + (i + 1) + " 轮排序后 :"); 32 printarray(arr); // 每轮比较结束打印数组元素 33 } 48

49 34 } 35 } 运行结果如图 2-49 所示 图 2-49 运行结果文件 2-33 中,bubbleSort () 方法中通过一个嵌套 for 循环实现了冒泡排序 其中, 外层循环用来控制进行多少轮比较, 每一轮比较都可以确定一个元素的位置, 由于最后一个元素不需要进行比较, 因此外层循环的次数为 arr.length-1 内层循环的循环变量用于控制每轮比较的次数, 它被作为角标去比较数组的元素, 由于变量在循环过程中是自增的, 这样就可以实现相邻元素依次进行比较, 在每次比较时如果前者小于后者, 就交换两个元素的位置, 具体执行过程如图 2-50 所示 图 2-50 冒泡排序 在图 2-50 的第一轮比较中, 第一个元素 9 为最大值, 因此它在每次比较时都会发生位置的交换, 被放到最后一个位置 第二轮比较与第一轮过程类似, 元素 8 被放到倒数第二个位置 第三轮比较中, 第一次比较没有发生位置的交换, 在第二次比较时才发生位置交换, 元素 5 被放到倒数第三个位置 第四轮比较只针对最后两个元素, 它们比较后发生了位置的交换, 元素 3 被放到第二个位置 通过四 轮比较, 很明显, 数组中的元素已经完成了排序 值得一提的是, 文件 2-33 中的 26~28 行代码实现了数组中两个元素的交换 首先定义了一个变量 temp 用于记住数组元素 arr[j] 的值, 然后将 arr[j+1] 的值赋给 arr[j], 最后再将 temp 的值赋给 arr[j+1], 这样便完成 了两个元素的交换 整个交换过程如图 2-51 所示 arr[j] 假设 j=1 定义变量 int temp; 8 temp arr[j] arr[j+1] 第一步 : 第二步 : 第三步 : temp=arr[j] arr[j]=arr[j+1] arr[j+1]=temp 图 2-51 交换步骤 arr[j+1] temp=8 49

50 2.7.3 多维数组 在程序中可以通过一个数组来保存某个班级学生的考试成绩, 试想一下, 如果要统计一个学校各个班级学生的考试成绩, 又该如何实现呢? 这时就需要用到多维数组, 多维数组可以简单地理解为在数组中嵌套数组 在程序中比较常见的就是二维数组, 下面将针对二维数组进行详细地讲解 二维数组的定义有很多方式, 接下来针对几种常见的方式进行详细地讲解, 具体如下 : 第一种方式 : int[][] arr = new int[3][4]; 上面的代码相当于定义了一个 3*4 的二维数组, 即二维数组的长度为 3, 每个二维数组中的元素又是一个长度为 4 的数组, 接下来通过一个图来表示这种情况, 如图 2-52 所示 图 2-52 二维数组第二种方式 : int[][] arr = new int[3][]; 第二种方式和第一种类似, 只是数组中每个元素的长度不确定, 接下来通过一个图来表示这种情况, 如图 2-53 所示 图 2-53 二维数组第三种方式 : int[][] arr = {{1,2},{3,4,5,6},{7,8,9}}; 上面的二维数组中定义了三个元素, 这三个元素都是数组, 分别为 {1,2} {3,4,5,6} {7,8,9}, 接下来通过一个图来表示这种情况, 如图 2-54 所示 图 2-54 二维数组 对二维数组中元素的访问也是通过角标的方式, 如需访问二维数组中第一个元素数组的第二个元素, 具体代码如下 : arr[0][1]; 接下来通过一个案例来熟悉二维数组的使用, 例如要统计一个公司三个销售小组中每个小组的总销售 额以及整个公司的销售额, 如文件 2-34 所示 文件 2-34 Example32.java 1 public class Example32 { 3 int[][] arr = new int[3][]; // 定义一个长度为 3 的二维数组 4 arr[0] = new int[] { 11, 12 }; // 为数组的元素赋值 5 arr[1] = new int[] { 21, 22, 23 }; 50

51 6 arr[2] = new int[] { 31, 32, 33, 34 }; 7 int sum = 0; // 定义变量记录总销售额 8 for (int i = 0; i < arr.length; i++) { // 遍历数组元素 9 int groupsum = 0; // 定义变量记录小组销售总额 10 for (int j = 0; j < arr[i].length; j++) { // 遍历小组内每个人的销售额 11 groupsum = groupsum + arr[i][j]; 12 } 13 sum = sum + groupsum; // 累加小组销售额 14 System.out.println(" 第 " + (i + 1) + " 小组销售额为 :" + groupsum + " 万元 "); 15 } 16 System.out.println(" 总销售额为 : " + sum + " 万元 "); 17 } 18 } 运行结果如图 2-55 所示 图 2-55 运行结果在文件 2-34 中, 第 3 行代码定义了一个长度为 3 的二维数组, 并在 4~6 行代码中为数组的每个元素赋值 文件中还定义了两个变量 sum 和 groupsum, 其中 sum 用来记录公司的总销售额,groupSum 用来记录每个销售小组的销售额 当通过嵌套 for 循环统计销售额时, 外层循环对三个销售小组进行遍历, 内层循环对每个小组员工的销售额进行遍历, 内层循环每循环一次就相当于将一个小组员工的销售额累加到本小组的销售总额 groupsum 中, 内层循环结束, 相当于本小组销售总金额计算完毕, 把 groupsum 的值与 sum 的值相加赋值给 sum 当外层循环结束时, 三个销售小组的销售总额 groupsum 都累加到 sum 中, 即统计出了整个公司的销售总额 任务 2-3 随机点名器 任务介绍 1. 任务描述编写一个随机点名的程序, 使其能够在全班同学中随机点中某一名同学的名字 随机点名器具备 3 个功能, 包括存储全班同学姓名 总览全班同学姓名和随机点取其中一人姓名 比如随机点名器首先分别向班级存入张飞 刘备和关羽这 3 位同学的名字, 然后总览全班同学的姓名, 打印出这 3 位同学的名字, 最后在这 3 位同学中随机选择一位, 并打印出他的名字, 至此随机点名成功 2. 运行结果任务运行结果如果 2-56 所示 51

52 图 2-56 运行结果 任务目标 学会分析 随机点名器 任务实现的逻辑思路 能够独立完成 随机点名器 的源代码编写 编译及运行 能够根据 随机点名器 程序功能的不同, 将功能封装到不同的方法中 能够使用数组解决多个同学姓名的存储问题 掌握方法和数组的使用 实现思路 (1) 在存储同学姓名时, 如果对每一个同学都定义一个变量进行姓名存储, 则会出现过多孤立的变量, 很难一次性将全部数据持有 此时, 可以使用数组解决多个数据的存储问题 创建一个可以存储多个同学姓名的数组, 打算存几个同学姓名就创建相应长度的数组 (2) 键盘输入同学姓名, 将输入的姓名依次赋值给数组各元素, 此时便存储了全班同学姓名 键盘输入需要使用 Scanner 类, 以下代码能够从键盘输入中读取一个字符串 : Scanner sc = new Scanner(System.in); String str = sc.next (); (3) 对数组进行遍历, 打印出数组中每个元素的值, 即实现了对全班每一位同学姓名的总览 ; (4) 根据数组长度, 获取随机索引, 例如数组长度为 3, 则获取的随机索引只能在 0~2 之间, 通过随机索引获取数组中的姓名, 该姓名也就是随机的姓名 获取随机索引可以使用 Random 类中的 nextint(int n) 方法 (5) 随机点名器 明确地分为了三个功能, 如果将多个独立功能的代码写到一起, 则代码相对冗长, 可以针对不同的功能将其封装到不同的方法中, 将完整独立的功能分离出来, 然后只需要在程序的 main() 方法中调用这 3 个方法即可 实现代码 随机点名器程序的实现代码, 如文件 2-35 所示 1 package cn.itcast.chapter02.task03; 文件 2-35 CallName.java 52

53 2 import java.util.random; 3 import java.util.scanner; 4 public class CallName { 5 /** 6 * 1. 存储全班同学姓名 7 * 创建一个存储多个同学姓名的容器 ( 数组 ) 8 * 键盘输入每个同学的姓名, 存储到容器中 ( 数组 ) 9 */ 10 public static void addstudentname(string[] students) { 11 // 键盘输入多个同学姓名存储到容器中 12 Scanner sc = new Scanner(System.in); 13 for (int i = 0; i < students.length; i++) { 14 System.out.println(" 存储第 "+(i+1)+" 个姓名 :"); 15 // 接收控制台录入的姓名字符串 16 students[i] = sc.next(); 17 } 18 } /** 21 * 2. 总览全班同学姓名 22 */ 23 public static void printstudentname(string[] students) { 24 // 遍历数组, 得到每个同学姓名 25 for (int i = 0; i < students.length; i++) { 26 String name = students[i]; 27 // 打印同学姓名 28 System.out.println(" 第 "+(i+1)+" 个学生姓名 :" + name); 29 } 30 } /** 33 * 3. 随机点名其中一人 34 */ 35 public static String randomstudentname(string[] students) { 36 // 根据数组长度, 获取随机索引 37 int index = new Random().nextInt(students.length); 38 // 通过随机索引从数组中获取姓名 39 String name = students[index]; 40 // 返回随机点到的姓名 41 return name; 42 } public static void main(string[] args) { 45 System.out.println(" 随机点名器 "); 53

54 46 // 创建一个可以存储多个同学姓名的容器 ( 数组 ) 47 String[] students = new String[3]; 48 /* 49 * 1. 存储全班同学姓名 50 */ 51 addstudentname(students); 52 /* 53 * 2. 总览全班同学姓名 54 */ 55 printstudentname(students); 56 /* 57 * 3. 随机点名其中一人 58 */ 59 String randomname = randomstudentname(students); 60 System.out.println(" 被点到名的同学是 :" + randomname); 61 } 62 } 在文件 2-35 中, 第 10~18 行代码定义了一个 addstudentname() 方法, 用于实现存储全班同学姓名的功 能, 其中通过创建一个 String 类型的数组 students 来存储多个同学的姓名, 借助 Scanner 类通过键盘输入 的方式输入同学的姓名, 并将这些姓名依次存储到数组元素中 ; 第 23~30 行代码定义一个 printstudentname () 方法, 用于实现总览全班同学姓名的功能, 通过遍历数组 students 的方式打印全班每一位同学的姓名 ; 第 35~42 行代码定义一个 randomstudentname() 方法, 用于实现随机点名其中一人的功能, 通过 Random 类 的 nextint(int n) 方法获取随机索引, 然后根据随机索引从数组中获取姓名, 这个姓名就是随机点名到的同 学姓名 2.8 本章小结 本章主要介绍了学习 Java 所需的基础知识 首先介绍了 Java 语言的基本语法 常量 变量的定义以及一些常见运算符的使用, 然后介绍了条件选择结构语句和循环结构语句的概念和使用, 最后介绍了方法的一些知识以及数组的相关操作 通过本章的学习, 读者能够掌握 Java 程序的基本语法 格式以及变量和运算符的使用, 能够掌握几种流程控制语句的使用方式, 能够掌握方法的定义和方法的调用方式, 能够掌握数组的声明 初始化和使用等知识 思考题 1 请简述& 与 && 的区别 2 简述 break continue 和 return 语句的区别 扫描右方二维码, 查看思考题答案! 54

55 55