JAVA快速入门练习2

第2章 实验 – JAVA基本语法1

2.1实验目标

(1) (2) (3) (4) (5)

算术运算符、算术表达式 布尔及关系算符和表达式 if/else控制结构 while循环语句 练习使用对话框

2.2实验说明

在上一章的实验中所看到的程序都是顺序执行的。本章实验教程将介绍如何使用JAVA选择控制语句，使程序能基于条件进行判断，从而选择执行相应的逻辑分支。

以下的实验包括4种类型， 每种类型都用括号里面的字母表示： D - 例程, 表示这是一个例子, 要求练习者阅读指南和代码; I - 交互式练习, 练习者完成实验指定的简单任务，如修改部分代码, 观察程序运行时的变化等; W - 热身练习, 练习者的编程工作量逐渐加大。

P - 完整编程，要求练习者根据要求，完成完整的JAVA程序。

2.3实验准备

从本实验教程光盘中拷贝Lab02文件目录到本地磁盘, 如C: 盘。Lab02 文件目录中将包含本次实验所需的所有资料。 Lab02的相关资料也可以从本实验教程的网站下载。

2.4实验任务

实验2.4.1: (D)运行四个Java程序

在已经安装JAVA SDK 5.0 的电脑上编译、运行4个JAVA程序IntDiv.java、 FloDiv.java、DouDiv.java 和 MinSec.java，观察程序的运行结果。在这四个程序中，运用了另外一种键盘读入的形式JOptionPane对话框。这种图形界面对用户来讲比命令行的数据输入方式更友好。用记事本或EditPlus 打开这几个程序,比较程序源代码。 IntDiv.java、 FloDiv.java、 DouDiv.java 和MinSec.java 都是按照这样的步骤执行的：(1) 提示用户输入数字。 这些数字是以字符串的形式被读取，而后又被转换成数字; (2) 适当的运算；(3) 输出显示。

MinSec.java （见程序清单2-1）包括以下的语句:

1

int totalSeconds = Integer.parseInt(

JOptionPane.showInputDialog(

\这个语句可以看作是以下两个语句的缩写：

String totalSecondsText = JOptionPane.showInputDialog(

\ int totalSeconds = Integer.parseInt(totalSecondsText);

程序清单2-1：MinSec.java

// MinSec.java

// 将总秒数转换为分钟和剩余秒数

import javax.swing.JOptionPane;

public class MinSec {

public static void main( String[] args ) { JOptionPane.showMessageDialog( null,

\将输入总秒数 \\n\ \转换为相应的 \\n\ \分钟数和秒数 。\

// 读取总秒数 ：

int totalSeconds = Integer.parseInt(

JOptionPane.showInputDialog( \输入总秒数 (整数)\

// 计算分钟和秒数

int minutes = totalSeconds / 60; int seconds = totalSeconds % 60;

// 显示结果

JOptionPane.showMessageDialog( null,

totalSeconds + \秒等于 \ minutes + \分钟加 \ seconds + \秒。\

System.exit( 0 ); // 结束程序 } // method main } // class MinSec

程序清单2-2：IntDiv.java // IntDiv.java

2

import javax.swing.JOptionPane;

public class IntDiv {

public static void main( String[] args ) {

// 从用户处得到一个字符串型的数字

String dividendText = JOptionPane.showInputDialog( \输入被除数 (整数)\

// 再从用户处取得一个字符串型的数字

String divisorText = JOptionPane.showInputDialog( \输入除数 (整数)\

// 将类型String转换为类型int

int dividend = Integer.parseInt( dividendText ); int divisor = Integer.parseInt( divisorText );

// 进行除运算

int quotient = dividend / divisor; int remainder = dividend % divisor;

// 显示结果

JOptionPane.showMessageDialog( null,

dividend + \除以 \等于\\n\ quotient + \再加余数 \ \结果\

JOptionPane.PLAIN_MESSAGE );

System.exit( 0 ); // 结束程序 } // method main } // class IntDiv 程序清单2-3：FloDiv.java

// FloDiv.java

// 演示浮点型的浮点数除法

import javax.swing.JOptionPane;

public class FloDiv {

public static void main( String[] args ) { //从用户处得到一个字符串型的数字

String dividendText = JOptionPane.showInputDialog( \键入被除数 (浮点数)\

//再从用户处取得一个字符串型的数字

3

String divisorText = JOptionPane.showInputDialog( \键入除数(浮点数)\

//将类型String转换为类型float

float dividend = Float.parseFloat( dividendText ); float divisor = Float.parseFloat( divisorText );

//进行除运算

float quotient = dividend / divisor;

//显示结果

JOptionPane.showMessageDialog( null,

dividend + \除以 \等于\\n\ quotient + \ \结果\

JOptionPane.PLAIN_MESSAGE );

System.exit( 0 ); //结束程序 } // method main } // class FloDiv 程序清单2-4：DouDiv.java

// DouDiv.java

// 演示double型的浮点数除法

import javax.swing.JOptionPane;

public class DouDiv {

public static void main( String[] args ) { //从用户处得到一个字符串型的数字

String dividendText = JOptionPane.showInputDialog( \键入被除数(浮点数)\

//再从用户处取得一个字符串型的数字

String divisorText = JOptionPane.showInputDialog( \键入除数(浮点数)\

// 将类型String转换为类型double

double dividend = Double.parseDouble( dividendText ); double divisor = Double.parseDouble( divisorText );

//进行除运算

double quotient = dividend / divisor;

4

// 显示结果

JOptionPane.showMessageDialog( null,

dividend + \除以 \等于\\n\ quotient + \ \结果\

JOptionPane.PLAIN_MESSAGE );

System.exit( 0 ); // 结束程序 } // method main } // class DouDiv

实验2.4.2: (D)if选择语句

编译MinSecWithIf.java，使用如下命令运行程序:

java MinSecWithIf 100 注意使用的命令不是

java MinSecWithIf

观察程序的运行结果，并尝试用其他的正整数来执行。在类名MinSecWithIf后面键入的数字被称做命令行参数。在这个程序中，该命令行参数是总秒数。试着不使用命令行参数来运行这个程序，并观察运行结果。

打开MinSecWithIf.java源代码，与MinSec.java源代码相比较。 在MinSecWithIf.java中，命令行输入是由语句:

int totalSeconds = Integer.parseInt(args[0]) 实现的；在MinSec.java中，输入是通过JOptionPane 对话框，而不是命令行参数实现的。

程序清单2-5：MinSecWithIf.java

// MinSecWithIf.java

// 将总秒数转换为相应的分钟数和剩余秒数

public class MinSecWithIf {

public static void main( String[] args ) { if ( args.length == 0 ) { // 声明程序将做什么 System.out.println(

\此程序将转换 \\n\ \一个总秒数为 \\n\

\相应的分钟和剩余秒数 .\\n\ \总秒数应当作为 \\n\ \命令行参数输入 .\\n\ System.exit(0); } // if

5

// 读取总秒数

int totalSeconds = Integer.parseInt(args[0]);

// 计算分钟和剩余秒数

int minutes = totalSeconds / 60; int seconds = totalSeconds % 60;

// 显示结果

System.out.println(

totalSeconds + \秒等于 \ minutes + \分钟加上 \ seconds + \秒.\ } // method main } // class MinSecWithIf

对于这种形式的IF语句，格式为：

if (expression) { statement(s) }

该语句必须以关键字“if”开始。之后，括号中为布尔表达式。该布尔表达式必须计算出一个true或者false值。在本实验中，我们检查用户命令行参数的输入。当没有命令行参数输入时，表达式args.length == 0的运算结果为true，程序执行花括号中的语句(我们把花括号之间的语句部分称为块block)，从而打印出一些提示信息，然后程序退出；当有命令行参数输入时，布尔表达式的值为false，程序忽略块中的语句，直接执行块后面的语句。

实验2.4.3: (W)练习使用if语句

在Lab02文件夹里，新建一个FeetInches.java文件。这个程序将总英寸转化成英尺和英寸（1英尺＝12英寸）。和MinSec.java类似，程序FeetInches.java使用一个输入对话框来提示输入，结果的输出则使用消息对话框。

编写的程序请使用恰当的变量名，注释和输出。强烈建议读者一句一句自己编写代码,而不仅仅是复制、粘贴和修改变量名以及注释。通过这种方式，可以对Java 程序的基础有一个全面的熟悉，并增强在今后各种JAVA考试中的信心。

注意缩排！JAVA编程规范要求每一个缩排要留４个空格，不是一个。用空格键(Space Key)，而不是制表键（Tab Key），因为制表键所表示的空格数会因文件编辑器的不同而不同。为了减轻缩排的麻烦，我们通常会在输入一个开括号后立即输入闭括号，然后输入括号里面的语句；而不是等完成括号里面的语句输入后再输入闭括号。

任何使用对话框的程序都包括语句：

System.exit(0)；

没有这条语句，包含对话框的程序执行到末尾时不会自动结束。在这种情况下要重新获得DOS窗口的控制，使用［Ctrl］-C键(按住[Ctrl]键，然后在按住[Ctrl]键的同时按下C键)。

6

实验2.4.4: (D)更多if语句

编译、运行程序BusDialog.java 和 Bus.java，一定要理解程序是如何实现的。这两个程序分别使用了对话框和命令行参数，它们都用于计算运送给定数目的乘客所需的车辆数。程序首先计算初步的数目（总人数除以每辆汽车的座位数），然后检查余数是否为０，也就是是否有剩余的乘客。如果是，除了初始估计外，还多需要一辆车。

程序清单2-6：BusDialog.java

// BusDialog.java

// 计算有固定座位数的车在给定乘客数的情况下所需的辆数

import javax.swing.JOptionPane;

public class BusDialog {

public static void main( String args[] ) { // 声明此程序的作用：

JOptionPane.showMessageDialog( null,

\计算有固定座位数的车\\n\ \在给定乘客数的情况下,\\n\ \所需的辆数.\

// 从用户处得到输入数据 int totalPeople = Integer.parseInt(

JOptionPane.showInputDialog( \键入总人数 (整数)\ int seatsPerBus = Integer.parseInt(

JOptionPane.showInputDialog(

\键入每辆车的座位数 (整数)\

// 计算所需车辆数

int bussesNeeded = totalPeople / seatsPerBus; if ( totalPeople % seatsPerBus > 0 ) bussesNeeded = bussesNeeded + 1;

// 显示结果

JOptionPane.showMessageDialog( null,

bussesNeeded + \辆座位为 \ seatsPerBus + \的车 \\n\ \可以运送 \ \个人\

7

System.exit( 0 ); // 终止程序 } // method main } // class Busses

程序清单2-7：Bus.java

// Bus.java

//计算有固定座位数的车在给定命令行参数个乘客数的情况下所需的辆数

public class Bus {

public static void main( String args[] ) { if ( args.length < 2 ) { //声明此程序的作用： System.out.println(

\计算有固定座位数的车\\n\ \在给定乘客数的情况下,\\n\ \所需的辆数.\ ); System.out.println(

\运行此程序请键入 \\n\ \作为命令行参数的 \\n\ \总人数和每辆车座位数 \

System.exit(0); } // if args.length

//从用户处得到输入数据

int totalPeople = Integer.parseInt(args[0]); int seatsPerBus = Integer.parseInt(args[1]);

// 计算所需的车辆数

int bussesNeeded = totalPeople / seatsPerBus; if ( totalPeople % seatsPerBus > 0 ) bussesNeeded = bussesNeeded + 1;

// 显示结果

System.out.println(

bussesNeeded + \辆座位为 \ seatsPerBus + \的车可以 \\n\ \运送 \ \的人 。\

System.exit( 0 ); // 终止程序 } // method main } // class Bus

8

实验2.4.5: (W)练习使用if语句

在Lab02文件夹里面，新建一个NearYuan.java的文件，它会以对话框的形式提示用户输入一个数字，这个数字表示分，程序会计算出与分价值最接近的整数元。例如：350分最接近4元，而249分最接近2元。

实验2.4.6: (D)否定条件

编译Compare.java，使用两个命令行参数运行程序：

java Compare 4 7

该程序的条件语句中使用了否定条件（Negation）。一个条件的否定条件总是：（1）正确的，如果原条件是错误的； （2）错误的，如果原条件是正确的。例如，

number1 >= number2

是

number1 < number2

的否定条件。

注意，条件number1 > number2不是上面第二个条件的否定条件， 因为当number1和number2相等时这两个条件都是错误的。类似的，条件number1 >= number2不是条件 number1 <= number2的否定条件，因为当两个数字相等时这两个条件都是正确的。

对于条件number1 == number2，两个等号符号表示简单的“等于”，我们使用双等号符号来检验两个表达式是否相等，而一个等号是给一个变量赋值。

对于条件 number1 != number2，惊叹号后面接一个等号的意思是“不等于”，很明显，这个条件否定了前一个条件（number1 == number2）。

用不同的整数对运行这个程序，这几个整数对包括以下情形：（1）第一个数小于第二个数；（2）第一个数大于第二个数；（3）第一个数等于第二个数。在每种情况中，程序都会显示正确的比较结果。

程序清单2-8：Compare.java

public class Compare {

public static void main( String args[] ) { if ( args.length < 2 ) {

System.out.print(\此程序将显示两个 \

System.out.println(\作为命令行参数输入的 \ System.out.print(\整数的比较结果 \ System.out.println(\运行此程序键入 :\ System.out.println(\ System.out.print(\使用整数值来替换 \ System.out.println(\和 int2.\

System.exit(0); } // if

9

int number1, // 第一个比较的数 number2; //第二个比较的数 String result; // 存储输出的字符串

// 将String 型转换为int型

number1 = Integer.parseInt( args[0] ); number2 = Integer.parseInt( args[1] );

// 初始化输出为空字符串 result = \

// 进行比较

if ( number1 == number2 )

result = number1 + \

if ( number1 != number2 )

result = number1 + \

if ( number1 < number2 )

result = result + \

if ( number1 >= number2 )

result = result + \

if ( number1 > number2 )

result = result + \

if ( number1 <= number2 )

result = result + \

// 显示结果

System.out.println(\比较结果:\\n\

} // method main } // class Compare

2.4.7: (D)if/else语句

编译、运行OddEven.java并测试不同的命令行参数（奇数和偶数）。 程序清单2-9：OddEven.java // OddEven.java

实验

10

// 测试数字是为奇数还是偶数

public class OddEven {

public static void main(String args[]) { if ( args.length == 0 ) {

System.out.print(\此程序将判断一正整数 \ System.out.println(\是奇数还是偶数 .\ System.out.print(\键入作为命令行参数 \ System.out.println(\的数字 .\ System.exit(0); } // if

int number = Integer.parseInt(args[0]);

if ( number % 2 == 0 ) // 如果数字为偶数 System.out.println(number + \为偶数 .\ else

System.out.println(number + \为奇数 .\ } // method main } // class OddEven

对于这种形式的条件语句，格式为：

if (expression) { statements1 } else { statements2 }

该条件语句的布尔表达式为true时执行语句statements1，布尔表达式为false时执行语句statements2。不同于if语句，else语句不包含条件。通常，在Java程序中，else语句与前面离它最近的if语句相匹配。如OddEven.java程序中：

if ( number % 2 == 0 ) // 如果数字为偶数

System.out.println(number + \为偶数 .\ else

System.out.println(number + \为奇数 .\ }

这个程序用一个数字是否可以被2整除来判断该数的奇偶性。被2除后，余数为0的数为偶数；余数为1的数则为奇数。程序中使用了if/else结构，根据if后面括号里的条件的真值来选择两种可能的行为。如果条件（number%2 == 0）是正确的, 即该数被2除后，余数为0，则条件后的陈述语句被执行；否则, else后面的陈述语句被执行。

把 statements1 和 statements2 括在花括号 ({}) 内通常是一个好习惯，这样更清楚，并可以避免无意中造成错误。这里对于if 和else的陈述语句可以不需要大括号，因为当条件正确时只有一条执行语句，而当条件错误时也只有另一条执行语句。假如在一种情况下要执行多于一条的语句，则需要用花括号括起来组成语句块（block）。

11

实验2.4.8: (W)练习if/else语句

为Compare.java 保存一个副本，命名为MyCompare.java。在后一个文件里，相应地修改类名和注释。然后修改MyCompare.java，使用3个if/else结构代替6个if结构来实现和Compare.java一样的效果。

编译MyCompare.java，用几组不同的数字对进行测试，这些数字对包括以下情形：（1） 第一个数小于第二个数；（2）第一个数大于第二个数；（3）第一个数等于第二个数。在每种情况中，程序都要显示正确的比较结果。

实验2.4.9: (P)编写程序HourMinSec.java

程序要求使用命令行参数来读取一个正整数，这个整数表示总秒数，编写程序输出与总秒数相等的时-分-秒。如果程序无命令行参数输入，DOS窗口将显示一个用户友好的提示信息。[提示：用整数除法和模运算，1小时=3600秒。]

实验2.4.10: (P)编写程序DigitParts.java

程序要求使用命令行参数来读取一个三位数，然后把这个三位数分离成单个的数字，最后把这些数字用空格分离的形式显示出来。例如，数字123 会被显示成 1 2 3。[提示：用整数除法和模运算来分离数位上的数字。] 运行结果示例如图2.1

图2.1 实验2.4.10运行结果示例

实验2.4.11: (P)编写程序DigitParts2.java

为DigitParts.java 保存一个副本，命名为DigitParts2.java。在后一个文件里，相应地修改类名和注释。修改DigitParts2.java，当用户的输入不是三位数时（如45，4258），程序会显示用户友好的错误提示信息。当然，如果用户没有正确输入命令行参数，这个程序也应该显示用户友好的的错误提示信息。

实验2.4.12: (W)JAVA中符号“+”的使用

编译并运行Plus.java，然后用记事本打开它，这个程序在DOS窗口输出：

68 366 7852

程序清单2-10：Plus.java

12

// Plus.java

// 演示加法和字符串连接

public class Plus {

public static void main(String[] args) {

System.out.println(23 + 45 + \ } // method main } // class Plus

JAVA语言中，加号“+”可以用做加法运算（当它出现在两个数字之间），也可以用做字符串的连接（当它出现在两个字符串之间，或者在一个字符串和一个数字之间。在这种情况下，数字会被自动转换成字符串然后和另一个字符串连接）。

Plus.java程序中System.out.println语句里的四个加号按照从左到右的顺序被依次定义。最左端的加号是加法运算,因为它出现在两个整数之间；第二个加号是字符串连接运算,因为它出现在一个数学表达式 23 + 45 和字符串 “ 366 ”之间；第三个加号是字符串连接运算,因为它出现在字符表达式23 + 45 + “ 366 ” 也就是“68 366”和正整数78之间。最右边的加号是字符串连接运算,因为在它左边所有的表达式在第四个加号未定义之前已经运算并生成了字符串“68 366 78” 。最终生成的字符串为“68 366 7852 “。

和代数运算一样, 在表达式中加括号可以改变运算的顺序。 为Plus.java 保存一个副本，命名为MyPlus.java，在源代码中只插入两个括号,使程序输出成为:

68 366 130

除了加入两个括号之外，代码不要做任何其他的修改。

实验2.4.13: (I)浮点数的比较

1. 编译和运行Comp3Flo.java程序，使用三个浮点数类型的命令行参数，这个程序会找出这三个数

中最大的那个数。

程序清单2-11：Comp3Flo.java

// Comp3Flo.java

public class Comp3Flo {

public static void main( String args[] ) { if ( args.length < 3 ) {

System.out.print(\此程序将找出\

System.out.println(\个作为命令行参数输入\ System.out.println(\的浮点数中的最大值.\ System.out.println(\运行此程序键入： \

System.out.println(\ java Comp3Flo num1 num2 num3\ System.out.print(\用数字值替代\

13

System.out.println(\和num3.\

System.exit(0); } // if

float number1 = new Float(args[0]).floatValue(); float number2 = new Float(args[1]).floatValue(); float number3 = new Float(args[2]).floatValue();

float largest;

if ( number1 > number2 ) largest = number1; else

largest = number2;

if ( number3 > largest ) largest = number3;

System.out.println(\数字\ + \ + \和\

+ \的最大数为 \

} // method main } // class Comp3Flo

如果输入没有小数点的命令行参数,这些参数会被自动的转换成浮点数，然后用小数点的形式显示出来。例如,

C:\\Lab02>java Comp3Flo 6 1 4.2 数字 6.0, 1.0, 和 4.2 的最大数为 6.0.

用不同的输入测试这个程序。测试3个不同数字的6种不同组合:

(1) 最小的数，中间的数，最大的数 (2) 最小的数，最大的数，中间的数 (3) 中间的数，最小的数，最大的数 (4) 中间的数，最大的数，最小的数 (5) 最大的数，最小的数，中间的数 (6) 最大的数，中间的数，最小的数

即使三个数字中有两个或两个以上的数字相等时，程序也可以正确地找出最大的数字。仔细阅读这个程序，理解程序中每一行代码的意义。

找出三个数字中最大数的关键代码如下：

float largest;

14

if ( number1 > number2 )

largest = number1; else

largest = number2;

if ( number3 > largest )

largest = number3;

第一行代码只声明（declare）了变量largest，并没有给largest变量赋初始值。largest变量的初始值是由if/else结构中条件number1 > number2 决定的。如果number1大于number2，执行初始赋值语句 largest = number1, 变量largest的初始值等于number1；反之，变量largest的初始值等于number2。

2. 为Comp3Flo.java 保存一个副本，命名为MyComp3Flo.java。

修改MyComp3Flo.java源码的类名和注释，编译程序，确保程序正确运行。

修改MyComp3Flo.java源码。在变量largest声明前加上注释//，在if/else结构中声明变量并同时对其赋初值。修改后的代码段如下：

// float largest;

if ( number1 > number2 )

float largest = number1; else

float largest = number2; 试着编译修改后的程序。 显然，编译不会通过。这是由于变量largest在赋初值前只能声明一次。

3. 修改MyComp3Flo.java源码，使之能正确编译。

程序编译通过后，进一步修改源码。用一对if结构代替if/else结构，修改后的代码段如下：

float largest;

if ( number1 > number2 )

largest = number1;

if ( number1 <= number2 )

largest = number2; 重新编译程序，将得到的错误提示信息写在下面: Comp3Flo.java:29: 可能尚未初始化变量 largest if ( number3 > largest ) ^

1 错误

编译错误的原因在于编译器（Compiler）无法识别条件number1 > number2 是条件 number1 <=number2的否定条件。因此，编译器认为可能在某种情况下，这两个布尔表达式都为false。当变量largest 在

if ( number3 > largest ) 语句中使用时，两个初始赋值语句可能都没有执行，变量largest可能尚未初始化。

15

4. 目前对变量初始化问题的讨论只局限于方法里的局部变量。

在完成的实验中，main方法里定义的变量都是局部变量。对于这种类型的变量，必须明确地进行初始化。如果在没有初始化之前就试图使用它，程序就无法编译。如果初始化的语句在if块中，必须要让变量在第一次使用前能够得到赋值。也就是说，把初始化语句放在只有if块的条件判断语句中编译不能通过，因为执行的时候可能不符合if后面的判断条件，如此一来初始化语句就不会被执行了，从而违反了局部变量使用前必须初始化的规定。

但如果使用if/else结构并且在每个分支中都有初始化语句，程序就可以通过编译，因为无论如何，总有至少一条初始化语句会被执行，不会发生使用前未被初始化的情况。

实验2.4.14: (P)编写程序Comp4Flo.java

程序使用四个浮点数为命令行参数，并找出这四个数中的最大数和最小数。程序的执行和输出如下：

C;\\Lab02>java Comp4Flo 4 3 1 2 在数字 4.0, 3.0, 1.0, 和 2.0中, 最大值为 4.0, 最小值为 1.0. 如果用户输入的参数少于四个，程序将输出用户友好的错误提示信息。

由于4个不同数字的排列组合方式有24种可能。为了便于程序的测试，使用批处理文件Comp4Flo.bat。

扩展名为.bat的文件是批处理文件，它是无格式的文本文件，包含一条或多条命令。在DOS命令提示窗口中键入批处理文件的名称，系统就会按照该文件中各个命令出现的顺序来逐个运行它们。使用批处理文件（也被称为批处理程序或脚本），可以简化日常或重复性任务。

Comp4Flo.bat批处理文件位于Lab02目录下，在DOS命令提示窗口中，执行： C:\\Lab02>Comp4Flo

程序清单2-12：Comp4Flo.bat java Comp4Flo 1 2 3 4 java Comp4Flo 1 2 4 3 java Comp4Flo 1 3 2 4 pause

java Comp4Flo 1 3 4 2 java Comp4Flo 1 4 2 3 java Comp4Flo 1 4 3 2 pause

java Comp4Flo 2 1 3 4 java Comp4Flo 2 1 4 3 java Comp4Flo 2 3 1 4 pause

java Comp4Flo 2 3 4 1 java Comp4Flo 2 4 1 3 java Comp4Flo 2 4 3 1 pause

java Comp4Flo 3 1 2 4 java Comp4Flo 3 1 4 2

16

java Comp4Flo 3 2 1 4 pause

java Comp4Flo 3 2 4 1 java Comp4Flo 3 4 1 2 java Comp4Flo 3 4 2 1 pause

java Comp4Flo 4 1 2 3 java Comp4Flo 4 1 3 2 java Comp4Flo 4 2 1 3 pause

java Comp4Flo 4 2 3 1 java Comp4Flo 4 3 1 2 java Comp4Flo 4 3 2 1 pause

java Comp4Flo 3.3 3.3 6.6 6.6 java Comp4Flo 3.3 6.6 3.3 6.6 java Comp4Flo 3.3 6.6 6.6 3.3 pause

java Comp4Flo 6.6 3.3 3.3 6.6 java Comp4Flo 6.6 3.3 6.6 3.3 java Comp4Flo 6.6 6.6 3.3 3.3

实验2.4.15: (D)简单介绍DecimalFormat的用法

编译、运行程序DecimalFormatDemo.java，查看源代码。DecimalFormat用于格式化十进制数字。具体的使用步骤：

(1) 创建对象DecimalFormat，关键代码如下：

DecimalFormat df2 = new DecimalFormat(\DecimalFormat df3 = new DecimalFormat(\

(2) 使用DecimalFormat对象，关键代码如下：

System.out.println(\ + \ + \

System.out.println(\ + \ + \

x 和 y 分别是float 和double 类型的变量。目前我们不必理解对象DecimalFormat工作的细节,只需要知道如何使用就可以了。

程序清单2-13：DecimalFormatDemo.java import java.text.DecimalFormat;

public class DecimalFormatDemo {

17

public static void main(String[] args) {

DecimalFormat df2 = new DecimalFormat(\ DecimalFormat df3 = new DecimalFormat(\

float x = 2.0f / 3; double y = 2.0 / 3;

System.out.println();

System.out.println(\类型 两位 三位\ + \ 全部位\ System.out.println();

System.out.println(\ \

+ \ \ + \ \ + x); System.out.println(\ \ + \ \ + \ \ + y); } // method main

} // class DecimalFormatDemo

实验2.4.16: (D)while循环语句

编译、运行SumNumber.java程序。输出从1 到命令行参数之间的所有整数之和。例如，键入命令行参数5，程序将会输出1 + 2 + 3 + 4 + 5 的和也就是15。

程序清单2-14：SumNumber.java

// SumNumber.java

// 求1到N的和，N作为命令行参数输入

public class SumNumber {

public static void main(String args[]) { if ( args.length == 0 ) {

System.out.print(\此程序将打印出1到\ System.out.println(\之间的所有数之和，\ System.out.print(\是一个为命令行参数\ System.out.println(\的正整数,\ System.exit(0); } // if

int n = Integer.parseInt(args[0]); int sum = 0; int count = 0;

18

while ( count < n ) { count = count + 1; sum = sum + count; } // while

System.out.println(\从1到\

+ n + \的和是： \ } // method main } // class SumNumber

为了实现程序的要求必须把数字进行累加。在JAVA这样的高级编程语言中，重复是用循环实现的。在记事本中打开SumNumber.java，注意以下几行语句：

int n = Integer.parseInt(args[0]); int sum = 0; int count = 0;

while ( count < n ) {

count = count + 1; sum = sum + count; } // while

一个while 循环包括关键字while,后面圆括号里的布尔表达式(被称作条件),以及一条或多条陈述语句。其格式为：

while (expression) { statement(s) }

只要条件为ture，陈述语句就被反复执行。执行的陈述语句被称作循环体, 如果循环体只有一个语句，则while的{ }可以省略不写。

假如条件开始就是false,那么循环体内的语句永远不会执行。

SumNumber.java程序循环体中的语句：

count = count + 1; 给变量count上次的值加1，计算出循环体被执行的次数。当count的值达到n时，count < n条件不成立,表达式为false,循环终止。

为了得到从1到n累加的和，程序每一次循环都把当前的 count 值加到变量 sum 表示的累计和中,累计和在循环开始时被初始化为 0。执行累加的语句如下:

sum = sum + count;

一定要理解if语句 和while循环语句的不同。if 和 while都是后面圆括号里的条件为true时执行相关的陈述语句。if 结构里面的语句执行一次，而while循环体中的语句被重复执行直到该循环的条件为false时终止。

使用while循环语句要注意的五个方面：

19

(1) while 后面要包括一个条件，这个条件是一个布尔表达式，其值或真或假。这个条件通常用

于检查一个或多个变量的值。

(2) while 条件中的变量一定要在while 循环开始前被赋值。这叫做初始化变量。初始化可以在

变量声明时进行，也可以在一个独立的陈述语句中进行。 (3) while 条件中变量的值一定要在while 循环体里的某处改变，使得循环条件最终变成false;

否则，会产生无限循环(infinite loop)，程序无法终止。

(4) 当循环体里包含多条语句时，必须用{ }来表示循环体的起始和结束；如果循环体只有一条

语句，{ }可以省略。

(5) 无论是否使用{ }，循环体需要缩排。缩排对程序的可读性非常重要，但不会影响程序的实

际运行。

实验2.4.17: (D)更多while循环例子

编译并运行PowerColumns.java （不需要输入命令行参数）。源代码见程序清单2-15。

程序清单2-15：PowerColumns.java

// PowerColumns.java

// 显示在规定范围内两列2的幂指数 // 演示while循环

public class PowerColumns {

public static void main(String args[]) {

System.out.println(\的幂指数 \ System.out.println(\

System.out.println(\指数 幂值\ System.out.println(\ -----\\n\

int exponent = 0; int power = 1;

while ( power < 100000 ) {

System.out.println(\ \ \ exponent = exponent + 1; power = power * 2; } // while } // method main } // class PowerColumns

程序在每次循环中用2乘以变量power来实现2的指数运算。变量power 首先被初始化为1，当第一次循环结束时它的值变为2。

这里while循环的条件是：

power < 100000

20

仔细检查程序并核实while循环是否符合上个实验中提到的五项要求。

实验2.4.18: (W)求输入浮点数的平均值

1. 编译、运行PrintCommandLine.java，输入任意个数的数字为命令行参数。不论你输入了哪一种

类型的多少个数字，程序会把输入的数字重新显示一遍。源代码见程序清单2-16。

程序清单2-16：PrintCommandLine.java

// PrintCommandLine.java

// 通过输出命令行参数来演示循环

public class PrintCommandLine {

public static void main(String[] args) { if ( args.length == 0 ) {

System.out.println(\此程序将重复命令行参数。\ System.exit(0); } // if

System.out.print(\键入的是： \

int index = 0;

while ( index < args.length ) {

System.out.print(\ index = index + 1; } // while

System.out.println(); // 结束行 . } // method main

} // class PrintCommandLine

args是一组命令行参数，args[0]、args[1]…args[n-1]分别表示第1，第2 … 第n个命令行参数,等等。方括号里面的数字称为下标。下标可以是非负整数，也可以使用变量。当然，这个作为下标的变量的值必须是非负整数。

PrintCommandLine.java程序中使用变量index为下标，每次循环下标变量值递增1，使得每一次循环都能访问一个命令行参数。

2. 注意while循环中语句的先后顺序，将原来的代码：

System.out.print(\index = index + 1;

改变为：

index = index + 1;

System.out.print(\

21

重新编译和使用命令行参数运行程序，修改后的程序可以通过编译，但是运行会出现错误。将MS-DOS窗口显示的错误信息写下来：

键入的是: 2Exception in thread “main” java.lang.ArrayIndexOutOfBoundsExceptio n: 2

at PrintCommandLine.main(printCommandLine.java:16)

执行第1次循环，变量index的值自增后为1，args[index]即args[1]实际为第2个命令行参数（第1个命令行参数没有访问到）；最后一次循环，访问的args[index]实际为第index+1个命令行参数,而这样的参数并不存在，显示的错误信息提示数组下标越界了。这种类型的编程错误在循环语句中很常见，也被称为off-by-1错误。

3. 在Lab02文件夹里面，编写一个命令行应用程序AverageN.java。

程序计算一列数字的平均值，这列数字以命令行参数的形式输入。例如，用户输入下列语句：

java AverageN 1 2 3 4 程序应该输出数字1， 2， 3， 4的平均值，也就是2.5。程序应该能处理输入的任意多个命令行参数。假如没有命令行参数输入，MS-DOS窗口将显示一个用户友好的提示信息。

使用浮点数除法计算平均值，平均值要精确到小数点后一位。[提示：使用DecimalFormat格式化数字]。例如，用以下语句运行：

java AverageN 1 1 2

输出应该是：

The average is 1.3.

避免在程序中出现无限循环，MS-DOS下使用 [Ctrl]-C 键（按住Ctrl键不放，同时按下C 键） 可以强行终止程序。

实验2.4.19: (P)编写程序Interest.java

计算银行本金连同利息之和达到本金的2倍时要多少年。程序可以接受两个命令行参数，这两个参数分别是的double和float类型，第一个数字表示银行本金，第二个数字表示年利率。假设使用复利（复利就是“利生利”、把每年的利息加上本金又作为下一年的本金），同时假设没有取款和存款的情况发生。假如用户没有恰当输入命令行参数，程序应该显示用户友好的提示信息。

实验2.4.20: (D)嵌套的if/else语句

if/else语句中，if或else的语句块中还可以嵌套if/else语句。这提高了编程的灵活，同时也容易使程序变得非常混乱。

缩排的使用对编写这样的代码非常重要。if/else结构越大越复杂，错误的缩进格式越有可能导致错误的判断。对于复杂的if/else语句，即使采用了正确的缩进格式，程序的逻辑看起来可能也不是很明显。如果一组if/else语句看起来有些复杂，在编写程序时，应总是使用{ }括号，使代码更清晰。

编译、运行PlugIfElseDemo.java程序。用不同的参数进行测试，这些数字包括0、-1、1000和1001。PlugIfElseDemo.java中的嵌套if/else结构:

if ( number <= 1000 )

22

if ( number >= 0 )

System.out.println(number + \是界于0到1000之间。 \

else

System.out.println(number + \小于0。 \

else

System.out.println(number + \大于1000。\

这里没有用{ }括号，编译器会自动地把每个else与它前面最近的那个if配对。 下面这种if/else语句嵌套可以产生同样的输出： if ( number > 1000 ) System.out.println(number + \大于1000。\else

if ( number < 0 )

System.out.println(number + \小于0。\else

System.out.println(number + \是界于0到1000之间。\

后面的这个例子中，第一个else的程序块包括另一个if/else结构。在这种情况下，if/else结构通常按下面的缩排形式书写：

if ( number > 1000 )

System.out.println(number + \大于1000。\else if ( number < 0 )

System.out.println(number + \小于0。\else

System.out.println(number + \是界于0到1000之间。\

程序清单2-17：PlugIfElseDemo1.java

// PlugIfElseDemo1.java

// Demonstrates nested if/else with // indentation to show the nesting.

public class PlugIfElseDemo1 {

public static void main(String[] args) { if ( args.length == 0 ) {

System.out.print(\此程序判断一个\

System.out.println(\作为命令行参数输入\ System.out.print(\的浮点数是否界于\ System.out.println(\到1000之间.\ System.exit(0); } // if

float number = new Float(args[0]).floatValue();

if ( number <= 1000 ) if ( number >= 0 )

System.out.println(number + \是界于0到1000之间。\

23

else

System.out.println(number + \小于0。\ else

System.out.println(number + \大于1000。\ } // method main

} // class PlugIfElseDemo1

实验2.4.21: (W)编写程序Age.java

输入的程序命令行参数表示一个人年龄的数字。假如这个输入不少于65，程序会输出：你到了退休的年龄了。假如这个输入不少于18却小于65， 程序会输出：你具有投票的权利但还没有到退休的年龄。假如输入是大于等于0但小于18，程序会输出：你还没有到投票的年龄。假如这个输入小于0，程序会输出：怎么？你还没有被生下来？

假如没有命令提示行的输入，程序会输出一个用户友好的提示信息。

实验2.4.22: (D)数据类型char

1. 编译运行程序PlugIfElseDemo2.java和PlugIfElseDemo3.java。

PlugIfElseDemo2.java程序的缩排更精确地反映了程序的实际判断过程，编程中则更普遍使用后一个程序中的缩排格式。

PlugIfElseDemo2.java和PlugIfElseDemo3.java程序中都使用了变量类型char，它是一个原始数据类型。声明一个char类型的变量：

char grade; char类型的变量用于存储字符，它的值是用单引号括起的，如下： grade = 'A';

与双引号括起的字符串不同。字符串（String）是一个包含一串字符的对象。因此，表达式‘A’和“A”并不表示同样的事物。‘A'是一个字符类型的字母A，而“A”是一个字符串对象。

程序清单2-18：PlugIfElseDemo2.java

// PlugIfElseDemo2.java

// 用缩排形式来演示嵌入式if/else语句

public class PlugIfElseDemo2 {

public static void main(String[] args) { if ( args.length == 0 ) {

System.out.print(\此程序判断作为\ System.out.println(\命令行参数输入的\ System.out.print(\百分制分数的\

System.out.println(\相应的字母级别。\ System.exit(0); } // if

int score = Integer.parseInt(args[0]);

24

char grade;

if ( score >= 90 ) grade = 'A'; else

if ( score >= 80 ) grade = 'B'; else

if ( score >= 70 ) grade = 'C'; else

if ( score >= 60 ) grade = 'D';

else // if ( score < 60 ) grade = 'F';

System.out.println(\分数为\的等级为\ } // method main

} // class PlugIfElseDemo2 程序清单2-19：PlugIfElseDemo3.java

// PlugIfElseDemo3.java

// Demonstrates nested if/else with indentation // standard for a multiway branch.

public class PlugIfElseDemo3 {

public static void main(String[] args) { if ( args.length == 0 ) {

System.out.print(\此程序判断作为\ System.out.println(\命令行参数输入的\ System.out.print(\百分制分数的\

System.out.println(\相应的字母级别。\ System.exit(0); } // if

int score = Integer.parseInt(args[0]); char grade;

if ( score >= 90 ) grade = 'A';

else if ( score >= 80 ) grade = 'B';

else if ( score >= 70 ) grade = 'C';

25

else if ( score >= 60 ) grade = 'D';

else // if ( score < 60 ) grade = 'F';

System.out.println(\分数为\的等级为\ } // method main

} // class PlugIfElseDemo3

2. Java编程语言有八种原始数据类型（Primitive Data Type）。原始类型可分为四种：

(1) 逻辑类 boolean (2) 文本类 char

(3) 整数类 byte、short、int、long (4) 浮点类 double、float

逻辑类boolean：数据类型有两种文字值：true和false。

文本类char：代表一个16-bit无符号的（不分正负的）Unicode字符

整数类byte, short, int, long： 采用三种进制(十进制、八进制和16进制),见下面的示例：

2 十进制数2

077 首位的0表示这是一个八进制的数值 0xBAAC 首位的0x表示这是一个16进制的数值

Java编程语言中的整数类型都是带符号的数字。整数数据类型的取值范围见表2.1。

表2.1 整数数据类型

字节数 8 bits 16 bits 32 bits 64 bits

数据类型 byte short int long 7 153163取值范围 -2 ... 2-1 -2 ... 2-1 -2 ... 2-1 -2 ... 2-1 6331157 浮点类float和double: 浮点数据类型的取值范围见表2.2。浮点文字除非明确声明为float，否则默认为double。

表2.2 浮点数据类型

字节数 32 bits 64 bits 数据类型 float double 取值范围 1.7E-308~1.7E+308 3.4E-038~3.4E+038 实验2.4.23: (I)嵌套if/else结构和变量的初始化

注意程序PlugIfElseDemo3.java中最后一个else的注释语句：

else // if ( score < 60 )

当执行到最后这个else时，程序已经穷举了变量score大于或者等于60的所有情况。因此，else执行时，我们知道变量score 的值肯定小于60。为PlugIfElseDemo3.java保存一个副本，命名为PlugIfElseDemo4.java。 然后删除最后else后的双斜杠： else if ( score < 60 )

26

编译程序，会得到什么错误信息？

PlugIfElseDemo4.java:29: 可能尚未初始化变量 grade

System.out.println(“分数为” + score + “ 的等级为” + grade + “.”); ^ 1 错误

由于最后的else已经和前一个if配对，最后一个if没有配对else。结果编译器认为有可能发生某种情况使得变量grade在下面的语句使用前没有赋初值。

System.out.println(\分数为\的等级为\编译器无法认识到程序已经罗列了所有的可能性。为了避免这种类型的编译错误，在嵌套if/else结构中初始化一个变量时要保证每个if都有与之配对的else。

实验2.4.24: (D)嵌套控制结构和变量的作用域

if/else结构不仅可以嵌套在另一个if/else结构中，也可以嵌套在while循环中。

OddEvenWithPlugIfElse.java程序（见程序清单2-20）使用了这种while循环嵌套if/else结构。

程序清单2-20：OddEvenWithPlugIfElse.java // OddEvenWithPlugIfElse.java

public class OddEvenWithPlugIfElse {

public static void main(String[] args) { if ( args.length == 0 ) {

System.out.print(\此程序计算输入的\ System.out.println(\一列命令行参数中的\ System.out.println(\奇数和偶数的个数。\ System.exit(0); } // if

int oddCount = 0; int evenCount = 0; int loopCount = 0;

while ( loopCount < args.length ) {

int number = Integer.parseInt(args[loopCount]); if ( number % 2 == 0 ) {

System.out.println(number + \是偶数。\ evenCount = evenCount + 1; } // if else {

System.out.println(number + \是奇数。\ oddCount = oddCount + 1;

27

} // else

loopCount = loopCount + 1; // 循环自加 } // while

System.out.println(\输入了 \

\个奇数和 \ \个偶数。\

} // method main

} // class OddEvenWithPlugIfElse

注意变量number是在循环体里声明的,而变量oddCount、evenCount和loopCount是在while循环前声明的。循环体中声明的变量只能在循环体中被使用,而在while循环前声明的变量在循环体内和循环体外都可以使用。

一般来说，一个代码块是用一对{ }括号括起来的任意数量的简单Java语句。块定义了变量的作用范围，也就是说，块中声明的变量只能在该块中使用。变量作用域是变量的可被访问范围，具体地说就是从变量第一次被声明的位置开始到声明这个变量的代码块的封闭（右）括号为止。

系统会在内存中为块中声明的变量分配一个区域。一旦程序执行退出代码块，在这个代码块中声明的任何变量就超出了作用域，对应的内存区域会被系统取消分配，对程序而言这些变量不可访问。

OddEvenWithPlugIfElse.java程序的while循环代码块中声明了变量number，变量number的作用域就是该循环体。while循环代码块一结束，变量number就超出了作用域，如果试图在后面的程序中访问number，编译器将产生下面的错误消息：

图2.2 变量作用域外访问变量引起的程序编译错误

实验2.4.25: (P)写一个命令行的应用程序GPA.java

GPA.java程序用于计算GPA(平均学分绩点)，程序的一个输出示例如下: java GPA

java GPA grade1 credit1 grade2 credit2 ......calculates the GPA.

java GPA 100 3 89 4 75 2 Your GPA is 3.16

用户输入的第一个参数是第一门课程的百分制考试成绩，第二个参数是第一门课程的学分，第三个参数是第二门课程的成绩??

28

百分制与学分绩点的对应关系如下：

百分制成绩 100-95 94-90 89-85 84-80 79-75 74-70 69-65 64-60 59及其以下 成绩绩点 4.0 3.5 3.0 2.6 2.2 1.8 1.4 1.0 0

平均学分绩点 = (成绩绩点1×课程学分1 + 成绩绩点2×课程学分2 + ??) / 总学分 提示：编写一个多重分支的if/else结构，并把这个结构嵌套在while循环中。GPA的值取小数点后两位。

29

本文来源：https://www.bwwdw.com/article/nvj6.html