实验一：环境的搭建与Java基础

一、实验内容

实验目的：

了解 Java 的发展历程，掌握 Java 开发环境的搭建和 Java 程序的开发过程。
了解 Java 语法，掌握三种流程控制结构。

1. 上网查资料，了解 Java 的由来和发展历程。

Java 是由詹姆斯・高斯林（James Gosling）带领团队，于 1995 年在 Sun 公司推出的一种跨平台高级编程语言。2009 年 Oracle 公司收购 Sun，从此由 Oracle 负责 Java 的维护与更新。

2. MS-DOS 常用命令的使用练习。掌握如下命令的使用：dir、cd、javac、java、set 等。

命令	作用
dir	查看当前目录下的文件和文件夹
cd 文件夹名	进入指定目录
cd..	返回上一级目录
javac 文件名.java	编译 Java 源文件，生成 .class 字节码文件
java 类名	运行编译后的 Java 程序
set	查看 / 配置系统环境变量

（1）勾选文件扩展名，在文档（Documents）目录下新建文本文档，重命名为 HellloWorld.java

（2）用记事本打开，写入代码并保存

（3）Win + R，输入 cmd 打开命令行窗口，完成上述命令的练习

java 和 javac 命令需要安装好 JDK 后才能使用。

3. 下载、安装 JDK，并完成环境的搭建。

（1）下载 JDK

打开（Oracle 官网），下载需要的版本（目前最新的长期支持版（LTS）是 JDK 25，初学者推荐安装 JDK 1.8）。

（2）安装 JDK

更改安装路径，改为 C 盘以外的盘
傻瓜方式安装，全程一直点击 Next

安装完成后，打开命令行窗口（如果是旧版本的 JDK 则需进入其安装路径的 bin 目录）分别输入 java -version 和 javac -version 命令验证安装

（3）配置 JAVA_HOME

Path 环境变量打开路径：此电脑 → 属性 → 高级系统设置 → 高级 → 环境变量

目前较新的 JDK 安装时会自动配置 javac、java 程序的路径到 Path 环境变量中去，因此可以直接在不同盘符下使用 javac、java 命令。但是它自动配置的功能并不完整，所以建议删除自动配置项，然后手动配置。

（4）配置 Path

在系统变量 Path 中添加：%JAVA_HOME%\bin

（5）校验配置

打开命令行窗口，在任意盘符下输入 java -version 命令，有版本号输出则配置正确。

继续往下之前建议先阅读下面这篇教程中 05-IDEA 的内容来完成 IDEA 的安装

站内链接

从零开始学Java（一）

/posts/m4wq9cq6

4. 分别开发一个 Java 应用程序和一个 Java 小应用，实现输出语句“xxxx大学欢迎您！”。

// 知识点：Java 类的定义、main 方法、控制台输出
public class Welcome {
    // main 方法是 Java 程序固定入口，JVM 自动调用执行。格式固定不可修改！
    public static void main(String[] args) {
        // 控制台打印输出语句，println 会自动换行
        // 字符串内容必须写在英文双引号内
        System.out.println("xxxx大学欢迎您！");
    }
}

运行结果：

xxxx大学欢迎您！

Applet（Java小应用程序）已经彻底过时、被废弃、不推荐学也不推荐用。如果要运行，请下载旧版本的 JDK

// 导入 Graphics 画笔类，用于绘制文字和图形
// 导入 Applet 基类，小程序必须继承该类

import java.awt.Graphics;
import java.applet.Applet;

// 定义 Applet 小程序，继承 Applet 父类
public class WelcomeApplet extends Applet {
    // 定义字符串变量，存储显示文本
    String str;

    // 初始化方法：小程序启动时自动执行 1 次，用于变量赋值
    public void init() {
        str = "xxxx大学欢迎您！";
    }

    // 绘图方法：系统自动调用，g 是系统提供的画笔对象
    public void paint(Graphics g) {
        // 绘制文字：参数顺序 = 文本、x 坐标、y 坐标
        // 坐标规则：x 向右增大，y 向下增大
        g.drawString(str, 50, 50);
    }
}

5. 运行教材第一章中所有的代码。

案例 1-1：输出字符串“Hello World!”。

public class HelloWorld {
    // public 公共权限  static 静态无需对象  void 无返回值
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

运行结果：

Hello World!

案例 1-2：编写一 Java Applet，显示字符串“Hello World!”，并用浏览器浏览网页。

Applet（Java小应用程序）已经彻底过时、被废弃、不推荐学也不推荐用。如果要运行，请下载旧版本的 JDK

import java.awt.Graphics;
import java.applet.Applet;

public class HelloWorldApplet extends Applet {
    String str;

    public void init() {
        // 为文本变量赋值
        str = "Hello World!";
    }

    public void paint(Graphics g) {
        g.drawString(str, 50, 50);
    }
}

6. 运行教材第二章中案例 2-1 到案例 2-5。

案例 2-1：输出各种类型的基本信息。

// 演示 Java 8 大基本数据类型的属性
public class PrimitiveTypeTest {
    public static void main(String[] args) {
        // byte：整数类型，占用内存最小
        System.out.println("基本类型: byte 二进制位数: " + Byte.SIZE);
        System.out.println("包装类: java.lang.Byte");
        System.out.println("最小值: Byte.MIN_VALUE=" + Byte.MIN_VALUE);
        System.out.println("最大值: Byte.MAX_VALUE=" + Byte.MAX_VALUE);
        System.out.println();

        // short：短整数类型
        System.out.println("基本类型: short 二进制位数: " + Short.SIZE);
        System.out.println("包装类: java.lang.Short");
        System.out.println("最小值: Short.MIN_VALUE=" + Short.MIN_VALUE);
        System.out.println("最大值: Short.MAX_VALUE=" + Short.MAX_VALUE);
        System.out.println();

        // int：最常用的整数类型，默认整数类型
        System.out.println("基本类型: int 二进制位数: " + Integer.SIZE);
        System.out.println("包装类: java.lang.Integer");
        System.out.println("最小值: Integer.MIN_VALUE=" + Integer.MIN_VALUE);
        System.out.println("最大值: Integer.MAX_VALUE=" + Integer.MAX_VALUE);
        System.out.println();

        // long：长整数类型，存储超大数值，赋值需加 L
        System.out.println("基本类型: long 二进制位数: " + Long.SIZE);
        System.out.println("包装类: java.lang.Long");
        System.out.println("最小值: Long.MIN_VALUE=" + Long.MIN_VALUE);
        System.out.println("最大值: Long.MAX_VALUE=" + Long.MAX_VALUE);
        System.out.println();

        // float：单精度浮点型，存储小数，赋值需加 F
        System.out.println("基本类型: float 二进制位数: " + Float.SIZE);
        System.out.println("包装类: java.lang.Float");
        System.out.println("最小值: Float.MIN_VALUE=" + Float.MIN_VALUE);
        System.out.println("最大值: Float.MAX_VALUE=" + Float.MAX_VALUE);
        System.out.println();

        // double：最常用的小数类型，默认浮点类型
        System.out.println("基本类型: double 二进制位数: " + Double.SIZE);
        System.out.println("包装类: java.lang.Double");
        System.out.println("最小值: Double.MIN_VALUE=" + Double.MIN_VALUE);
        System.out.println("最大值: Double.MAX_VALUE=" + Double.MAX_VALUE);
        System.out.println();

        // char：字符类型，采用 Unicode 编码，无符号
        // 强制转int才能显示数字范围
        System.out.println("基本类型: char 二进制位数: " + Character.SIZE);
        System.out.println("包装类: java.lang.Character");
        System.out.println("最小值: Character.MIN_VALUE=" + (int) Character.MIN_VALUE);
        System.out.println("最大值: Character.MAX_VALUE=" + (int) Character.MAX_VALUE);
        System.out.println();

        // boolean：布尔类型，仅 true/false，用于逻辑判断
        System.out.println("基本类型: boolean 二进制位数: 1 (逻辑位)");
        System.out.println("包装类: java.lang.Boolean");
        System.out.println("取值: true / false");
    }
}

运行结果：

基本类型: byte 二进制位数: 8
包装类: java.lang.Byte
最小值: Byte.MIN_VALUE=-128
最大值: Byte.MAX_VALUE=127

基本类型: short 二进制位数: 16
包装类: java.lang.Short
最小值: Short.MIN_VALUE=-32768
最大值: Short.MAX_VALUE=32767

基本类型: int 二进制位数: 32
包装类: java.lang.Integer
最小值: Integer.MIN_VALUE=-2147483648
最大值: Integer.MAX_VALUE=2147483647

基本类型: long 二进制位数: 64
包装类: java.lang.Long
最小值: Long.MIN_VALUE=-9223372036854775808
最大值: Long.MAX_VALUE=9223372036854775807

基本类型: float 二进制位数: 32
包装类: java.lang.Float
最小值: Float.MIN_VALUE=1.4E-45
最大值: Float.MAX_VALUE=3.4028235E38

基本类型: double 二进制位数: 64
包装类: java.lang.Double
最小值: Double.MIN_VALUE=4.9E-324
最大值: Double.MAX_VALUE=1.7976931348623157E308

基本类型: char 二进制位数: 16
包装类: java.lang.Character
最小值: Character.MIN_VALUE=0
最大值: Character.MAX_VALUE=65535

基本类型: boolean 二进制位数: 1 (逻辑位)
包装类: java.lang.Boolean
取值: true / false

案例 2-2：比较两个数的大小，并按从大到小的次序输出。

public class CompareTwo {
    public static void main(String[] args) {
        // 定义 double 浮点型变量并赋值
        double d1 = 23.4;
        double d2 = 35.1;

        // >= 关系运算符：判断是否 大于等于，结果只能是 true/false
        if (d2 >= d1) {
            // 条件为 true 时执行
            System.out.println(d2 + " >= " + d1);
        } else {
            // 条件为 false 时执行
            System.out.println(d1 + " >= " + d2);
        }
    }
}

运行结果：

35.1 >= 23.4

案例 2-3：判断某一年是否为闰年。

普通闰年：能被 4 整除且不能被 100 整除
世纪闰年：能被 400 整除
- 能被 400 整除的数字，一定能被 100 整除；但能被 100 整除，不一定能被 400 整除。
- 只有整百年（year % 100 == 0）才需要额外校验 400，非整百年不用。

public class LeapYear {
    public static void main(String[] args) {
        // 方法 1：逻辑表达式最简写法
        // % 是取余运算符，用于判断整除
        int year = 1989;
        if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
            System.out.println(year + " is a leap year.");
        } else {
            System.out.println(year + " is not a leap year.");
        }

        // 方法 2：else-if 多分支写法（推荐使用）
        year = 2000;
        boolean leap; // 布尔变量，存储闰年判断结果

        // 不能被 4 整除 → 平年
        if (year % 4 != 0) {
            leap = false;
        }
        // 能被 4 整除，不能被 100 整除 → 闰年
        else if (year % 100 != 0) {
            leap = true;
        }
        // 能被 100 整除，不能被 400 整除 → 平年
        else if (year % 400 != 0) {
            leap = false;
        }
        // 能被 400 整除 → 闰年
        else {
            leap = true;
        }

        // 布尔变量直接作为判断条件，等价于 leap == true
        if (leap) {
            System.out.println(year + " is a leap year.");
        } else {
            System.out.println(year + " is not a leap year.");
        }

        // 方法 3：嵌套 if 写法
        year = 2050;
        // 外层判断：能否被 4 整除
        if (year % 4 == 0) {
            // 中层判断：能否被 100 整除
            if (year % 100 == 0) {
                // 内层判断：能否被 400 整除
                if (year % 400 == 0) {
                    leap = true;
                } else {
                    leap = false;
                }
            } else {
                leap = true;
            }
        } else {
            leap = false;
        }

        if (leap) {
            System.out.println(year + " is a leap year.");
        } else {
            System.out.println(year + " is not a leap year.");
        }
    }
}

运行结果：

1989 is not a leap year.
2000 is a leap year.
2050 is not a leap year.

案例 2-4：根据考试成绩的等级打印出百分制分数段。

public class GradeLevel {
    public static void main(String[] args) {
        // 场景 1：标准 switch 用法，每个 case 带 break，匹配即停止
        System.out.println("** first situation **");
        char grade = 'C';
        // switch 用于匹配固定值，比 if-else 更简洁
        switch (grade) {
            case 'A':
                System.out.println(grade + " is 85~100");
                // break：跳出 switch，必须写，否则会穿透
                break;
            case 'B':
                System.out.println(grade + " is 70~84");
                break;
            case 'C':
                System.out.println(grade + " is 60~69");
                break;
            case 'D':
                System.out.println(grade + " is <60");
                break;
            // default：所有 case 不匹配时执行
            default:
                System.out.println("input error");
        }

        // 场景 2：无 break，case 穿透现象，从匹配处一直执行到结尾
        System.out.println("\n** second situation **");
        grade = 'A';
        switch (grade) {
            case 'A':
                System.out.println(grade + " is 85~100");
            case 'B':
                System.out.println(grade + " is 70~84");
            case 'C':
                System.out.println(grade + " is 60~69");
            case 'D':
                System.out.println(grade + " is <60");
            default:
                System.out.println("input error");
        }

        // 场景 3：多 case 共用同一逻辑，多个条件执行相同代码
        System.out.println("\n** third situation **");
        grade = 'B';
        switch (grade) {
            // A/B/C 不写 break，共用一段代码
            case 'A':
            case 'B':
            case 'C':
                System.out.println(grade + " is >=60");
                break;
            case 'D':
                System.out.println(grade + " is <60");
                break;
            default:
                System.out.println("input error");
        }
    }
}

运行结果：

** first situation **
C is 60~69

** second situation **
A is 85~100
A is 70~84
A is 60~69
A is <60
input error

** third situation **
B is >=60

案例 2-5：求 100~200 间的所有素数。

素数是指大于 1 且除了 1 和自身外不能被其他整数整除的数。

public class PrimeNumber {
    public static void main(String[] args) {
        System.out.println(" ** prime numbers between 100 and 200 **");

        int n = 0; // 计数器，控制每行输出 10 个质数

        // 外层循环标签：outer，用于跳出内层循环
        // 遍历 101~199 的奇数，偶数不可能是质数，i+=2 优化效率
        outer:
        for (int i = 101; i < 200; i += 2) {
            // 质数判断优化：只需判断到平方根，15² = 225 > 200，足够使用
            int k = 15;

            // 内层循环：试除判断是否为质数
            for (int j = 2; j <= k; j++) {
                // i 能被 j 整除，说明不是质数
                if (i % j == 0) {
                    // 带标签 continue：跳转到 outer 外层循环，判断下一个数
                    continue outer;
                }
            }

            // 执行到此处，说明当前 i 是质数
            System.out.print(" " + i);
            n++; // 计数加1

            // 不满 10 个，不换行，继续打印
            if (n < 10) {
                // 普通 continue：跳过本次剩余代码
                continue;
            }

            // 满 10 个数字，换行并重置计数器
            System.out.println();
            n = 0;
        }
        System.out.println();
    }
}

运行结果：

 ** prime numbers between 100 and 200 **
 101 103 107 109 113 127 131 137 139 149
 151 157 163 167 173 179 181 191 193 197
 199

7. 设计程序，求 1 到 100 的和。

public class Sum100 {
    public static void main(String[] args) {
        // 定义累加变量，初始值必须为 0
        int sum = 0;

        // for循环：i 从 1 循环到 100，完成累加
        for (int i = 1; i <= 100; i++) {
            // 累加运算：sum = sum + i 的简写形式
            sum += i;
        }

        // 输出最终计算结果
        System.out.println("1 到 100 的和为：" + sum);
    }
}

运行结果：

1 到 100 的和为：5050

8. 打印所有的水仙花数。

水仙花数是指其个位、十位、百位三个数的立方和等于该数本身。

public class NarcissisticNumber {
    public static void main(String[] args) {
        System.out.println("所有的水仙花数：");

        // 遍历所有三位数 100~999
        for (int i = 100; i <= 999; i++) {
            // 取个位：对 10 取余
            int ge = i % 10;
            // 取十位：先除以 10，再对 10 取余
            int shi = i / 10 % 10;
            // 取百位：整数除以 100
            int bai = i / 100;

            // 判断条件：个位³ + 十位³ + 百位³ == 自身
            if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {
                // 输出符合条件的水仙花数
                System.out.println(i);
            }
        }
    }
}

运行结果：

所有的水仙花数：
153
370
371
407

9. 利用 for 循环，计算 1 + 2 + 3 + 4 + … + 100 的总和。

（与上面实验内容的第 7 题重复！！！省略）

10. 利用 do-while 循环，计算 1! + 2! + 3! + … + 100! 的总和。

n! = (n-1)! * n

public class FactorialSum {
    public static void main(String[] args) {
        // 存储阶乘总和，double 支持超大数值
        double sum = 0;
        // 存储当前阶乘结果，阶乘初始值必须为 1
        double factorial = 1;
        // 循环计数变量，从 1 开始到 100
        int i = 1;

        // do-while 循环：先执行代码，再判断条件
        do {
            // 计算阶乘：factorial = factorial * i
            factorial *= i;
            // 累加到总和
            sum += factorial;
            // 计数 +1
            i++;
        } while (i <= 100);

        // 输出最终结果
        System.out.println("1!+2!+3!+…+100! = " + sum);
    }
}

运行结果：

1!+2!+3!+…+100! = 9.42786239765826E155

二、课后习题

第一章：概述

第一章一、填空题：

Java 源程序文件的后缀是 .java。
Java 源程序经编译后生成字节码文件，其后缀是 .class。
Java 程序有 Java 应用程序和 Java 小应用程序（Applet）两类。
方法的定义由方法头和方法体两部分组成。
Java 中的字符使用 Unicode 编码。
在 Java 语言中，将源代码翻译成字节码时产生的错误称为编译错误，而将程序在运行中产生的错误称为运行错误。
Java 是目前最广泛的面向对象编程语言之一。
Java 具有简单、面向对象、稳定、与平台无关、解释型、多线程、动态等特点。
JDK 开发 Java 程序需三个步骤，分别为编写 java 源代码、编译 java 源程序、运行 java 源程序。
编写 Java 程序，可以使用一个文本编辑器来编写源文件。
把编写好的 Java 源文件保存起来，原文件的扩展名必须是 .java。
用 JDK 编译 Java 源程序，使用的命令是 javac，编译源文件得到字节码文件。
Java 源程序编译后生成的字节码文件扩展名为 .class。
Java 程序分为两类，即 Java 应用程序（Application）和 Java 小应用程序（Applet）。
用 JDK 工具，显示 Applet 程序运行结果的命令是 c:>appletviewer index.html。
一个 Java 源程序是由若干个类组成。
Java 应用程序中有多个类时，java 命令后的类名必须是包含了 public static void main 方法的那个类的名字。
在一个 Java 应用程序中 main 方法必须被说明为 public static void main(String[] args)。
Java 源文件中有多个类，但只能有一个类是 public 类。

第一章二、判断题：

Java 是高级语言。 ✅
Java 是面向对象的程序设计语言。 ✅
Java 是编译型的计算机语言。 ❌（Java 是半编译半解释型：先编译成字节码，再由 JVM 解释执行）
一个 Java 源程序中可以有多个公共类。 ❌（最多只有一个）
一个 Java 源程序中可以有多个类。 ✅
一个 Java Applet 源程序的主类能有多个父类。 ❌（只能有一个父类，Java 不支持类的多继承）
Java 小程序（Applet）的主类的父类必须是类 Applet。 ✅

第一章三、问答题：

Java 语言的程序设计包含哪 3 个步骤？

答案：

编写 Java 源程序；编译 Java 源文件；运行 Java 程序。

为什么说 Java 的运行与计算机硬件平台无关？

答案：

Java 源代码编译后生成跨平台的字节码文件，由 Java 虚拟机（JVM）执行。不同平台都有对应的 JVM，字节码编译一次便可在任意装有 JVM 的设备上运行。

Java 有什么特点？

答案：

Java 具备简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、半编译半解释执行、高性能、多线程、动态性等特点。

试述 Java 开发环境的建立过程。

答案：

从官方网站下载并安装 JDK；配置系统环境变量 JAVA_HOME 和 Path；打开命令提示符，输入 javac -version 和 java -version 命令，能正常显示版本号即配置成功。

什么是 Java API？它提供的核心包的主要功能是什么？

答案：

Java API（Java Application Programming Interface）是 Java 提供的标准类库，它封装了大量预定义的类、接口和方法，为开发人员提供了常用的基础功能，避免重复造轮子。

包名	主要功能
`java.lang`	基础核心类（如 Object、String、包装类、线程类等），默认自动导入
`java.util`	实用工具类（集合框架、日期时间、随机数、哈希表等）
`java.io`	输入 / 输出操作（文件读写、数据流、序列化等）
`java.net`	网络编程（Socket 通信、URL 访问等）
`java.sql`	数据库操作（JDBC 相关类，连接和操作数据库）
`java.awt/javax.swing`	图形用户界面（GUI）开发

如何编写和运行 Java 应用程序？

答案：

使用文本编辑器编写 .java 源文件，文件名与 public 主类名保持一致，主类必须包含 main 方法；执行 javac 文件名.java 命令编译，生成字节码文件；执行 java 主类名命令，通过 JVM 运行程序。

为什么要为程序添加注释，在 Java 程序中如何为程序添加注释？

答案：

注释不会被编译执行，可提升代码可读性，方便代码维护、调试与协作。

单行注释    // 内容
多行注释    /* 内容 */
文档注释    /** 内容 */

Java 工具集中的 javac、java、appletviewer 各有什么作用？

答案：

javac 是编译器，将 .java 源文件编译为 .class 字节码文件；java 用于启动 JVM 并运行字节码文件；appletviewer 是查看器，用来测试运行 HTML 中的 Applet 小程序。

如何建立和运行 Java Applet 程序？

答案：

编写继承自 Applet 类的 .java 源文件；使用 javac 命令编译生成字节码文件；编写 HTML 文件并嵌入字节码文件；执行 appletviewer 文件名 .html 命令运行程序。

Java 小应用程序（Applet）的主类的类头应如何写？小程序在什么环境下运行？

答案：

类头写法：public class 自定义类名 extends Applet，需要导入包 import java.applet.Applet;；
运行环境：Applet 无法独立运行，需要嵌入 HTML 页面，在浏览器（安装 Java 插件）或者 JDK 自带的 appletviewer 工具中运行。

第二章：Java 语言程序设计基础

第二章一、填空题：

用来标识类名、变量名、方法名、类型名、数组名、文件名的有效字符序列称为标识符。
Java 语言规定标识符由字母、下划线、美元符号和数字组成，并且第一个字符不能是数字。
关键字就是 Java 语言中已经被赋予特定意义的一些单词，不可以把这类词作为名字来用。
使用关键字 boolean 来定义逻辑变量。使用关键字 char 来定义字符变量。
Java 中 byte 型数组在内存中的存储形式是顺序存储。
Java 中，实型变量的类型有 float 和 double 两种。
对于 int 型变量，内存分配 4 个字节。对于 byte 型变量，内存分配 1 个字节。对于 long 型变量，内存分配 8 个字节。对于 short 型变量，内存分配 2 个字节。对于 float 型变量，内存分配 4 个字节。对于 double 型变量，内存分配 8 个字节。
Java 中关系运算符的运算结果是 boolean 型。
Java 中逻辑运算符的操作元必须是 boolean 型数据。
Java 语言的控制语句有 3 种类型，即条件语句、循环语句、和转移语句。
Java 中有两种类型的控制语句即 if 和 switch。
在同一个 switch 语句中，case 后的常量表达式必须互不相同。
do-while 循环和 while 循环的区别是 while 语句先判断条件表达式，后执行循环体语句；do-while 语句先无条件的执行循环体，然后再判断循环条件是否成立。
在循环体中，如果想结束本次循环可以用 continue 语句。
在循环体中，如果想跳出循环，结束整个循环可以用 break 语句。

第二章二、选择题：

能正确表示 Java 语言中的一个整型常量的是（B）。
（A） 12.（浮点数）
（B） -20（正确）
（C） 1 000（不能有空格）
（D） 4 5 6（不能有空格）
以下选项中，合法的赋值语句是（B）。
（A） a == 1;（比较运算符，不是赋值）
（B） ++i;（自增赋值，正确）
（C） a = a + 1 = 5;（左值必须是变量）
（D） y = int (i);（强制转换语法错误，应为 (int)i）
若所用变量都已正确定义，以下选项中，非法的表达式是（C）。
（A） a != 4 || b == 1（合法）
（B） 'a' % 3（合法，字符转 ASCII 运算，char 属于整型家族（整数类型），可以和 byte/short/int/long 做算术运算）
（C） 'a' = 1 / 2（赋值运算符左侧不能是常量）
（D） 'A' + 32（合法，char 本质是 Unicode 整数，运算时自动提升为 int）
若有定义 int a = 2;，则执行完语句 a += a -= a * a; 后，a 的值是（A）。

（复合赋值运算的计算是从右到左：a += a -= 2 * 2 → a += 2 - 4 → a += -2 → a = 2 - 2 = 0）

Java 语言是（D）。

（Java 是半编译半解释，这里教材表述为面向对象的解释型高级编程语言）

下列的变量定义中，错误的是（D）。
（A） int i;（合法）
（B） int i = Integer.MAX_VALUE;（是 Integer 包装类常量，表示 int 整数能存储的最大正数。合法）
（C） static int i = 100;（合法）
（D） int 123_S;（变量名不能以数字开头）
以下的变量定义语句中，合法的是（C）。
（A） float $_*5 = 3.4F;（变量名不能有 *）
（B） byte b1 = 15678;（超出 byte 范围 - 128~127）
（C） double a = Double.MAX_VALUE;（是 Double 包装类常量，表示 double 浮点数能存的最大正数。合法）
（D） int _abc_ = 3721L;（类型不匹配，long 不能直接赋值给 int）
以下字符常量中不合法的是（C）。
（A） '|'（合法）
（B） '\''（转义单引号字符，合法）
（C） "\n"（双引号表示字符串，不是字符常量）
（D） '我'（Java 支持 Unicode 字符）
若以下变量均已正确定义并赋值，下面符合 Java 语言语法的语句是（A）。
（A）b = a != 7;（合法，关系表达式结果赋值给变量）
（B）a = 7 + b + c = 9;（不合法，赋值号左边必须是变量）
（C）i = 12.3 * % 4;（不合法，表达式语法错误）
（D）a = a + 7 = c + b;（不合法，赋值号左边不能是表达式）
下列程序段执行后 t5 的结果是（B）。

int t1 = 9, t2 = 11, t3 = 8;
int t4, t5;
t4 = t1 > t2 ? t1 : t2 + t1;
t5 = t4 > t3 ? t4 : t3;

分析：t4 = 11 + 9 = 20；t5 = 20。

设 a，b，c，d 均为 int 型的变量，并已赋值，下列表达式的结果属于非逻辑值的是（C）。
（A）a != b & c % d < a（逻辑表达式，结果为 boolean）
（B）a++ == a + b + c + d（关系表达式，结果为 boolean）
（C）++a * b-- + d（算术表达式，结果为 int 型数值）
（D）a + b >= c + d（关系表达式，结果为 boolean）

第二章三、输出结果题：

以下程序段的输出结果为：______。

public static void main(String[] args) {
    int nNum1 = 6;
    int nNum2 = 8;
    System.out.println();
    // nNum1 不自加短路原则
    System.out.println(((nNum1 < nNum2) && (--nNum1) > nNum2));
    System.out.println("nNum1 is " + nNum1);
    System.out.println(((nNum1 < nNum2) && (--nNum1) > nNum2));
    System.out.println("nNum1 is " + nNum1);
}

答案：

第一次：nNum1 < nNum2 为 true，执行 --nNum1，nNum1 变为 5，5 > 8 为 false，输出 false 和 nNum1 is 5
第二次：nNum1 < nNum2 为 true，执行 --nNum1，nNum1 变为 4，4 > 8 为 false，输出 false 和 nNum1 is 4

运行结果：


false
nNum is 5
false
nNum is 4

阅读下面的程序，程序保存为 Test.java。

public class Test {
    public static void main(String[] args) {
        System.out.println(args[2]);
    }
}

以上程序经编译后用 java Test 1 2 3 运行得到的输出结果是什么？

答案：

命令行参数 args 数组下标从 0 开始，args[0] = "1"、args[1] = "2"、args[2] = "3"，程序输出 args[2]，结果为 3

以下程序的输出结果为：______。

int x = 0, y = 4, z = 5;
if (x > 2) {
    if (y < 5) {
        System.out.println("Message one");
    } else {
        System.out.println("Message two");
    }
} else if (z > 5) {
    System.out.println("Message three");
} else {
    System.out.println("Message four");
}

答案：

程序先判断 x > 2，由于 x = 0 不成立，跳过 if 块；接着判断 else if (z > 5)，由于 z = 5 不成立，跳过 else if 块；最终执行 else 分支，输出 Message four

运行结果：

Message four

以下程序段的输出结果为：______。

public class MyFirst {
    public static void main(String args[]) {
        int x = 1, y, total = 0;
        while (x <= 20) {
            y = x * x;
            System.out.println("y = " + y);
            total = total + y;
            ++x;
        }
        System.out.println("Total is " + total);
    }
}

答案：

程序通过 while 循环，计算并输出 1 到 20 每个数的平方值，同时将所有平方值累加存入 total。根据平方和公式，1² + 2² + … + 20² 的结果为 2870

运行结果：

y = 1
y = 4
y = 9
y = 16
y = 25
y = 36
y = 49
y = 64
y = 81
y = 100
y = 121
y = 144
y = 169
y = 196
y = 225
y = 256
y = 289
y = 324
y = 361
y = 400
Total is 2870

第二章四、问答题：

什么是变量？什么是常量？

答案：

变量：程序运行过程中值可以改变的量，用于存储临时数据，必须先声明后使用，有明确的数据类型。
常量：程序运行过程中值固定不变的量，分为字面常量和符号常量（如用 final 修饰的变量），一经定义不可修改。

什么叫表达式？Java 语言中共有几种表达式？

答案：

表达式：由常量、变量、运算符、方法调用等组成，用于计算并返回一个值的式子。
Java 中常见的表达式类型有：算术表达式、关系表达式、逻辑表达式、赋值表达式、条件表达式、位运算表达式等。

下面哪些标识符不合法？为什么？

HelloWorld、2Thankyou、_First、-Month、893Hello
non-problem、HotJava、implements、$_MyFirst

答案：

2Thankyou：不能以数字开头；-Month：不能以减号开头，且标识符不能包含减号；893Hello：不能以数字开头；non-problem：标识符中不能包含减号；implements：是 Java 关键字，不能用作标识符。
合法的标识符：HelloWorld、_First、HotJava、$_MyFirst（标识符可以字母、下划线、美元符号开头，后续可以是字母、数字、下划线、美元符号）。

while 与 do-while 语句的区别是什么？

答案：

while 语句：先判断条件表达式，条件为真时才执行循环体，循环体可能一次都不执行
do-while 语句：先无条件执行一次循环体，再判断条件表达式，条件为真时继续循环，循环体至少执行一次。

第二章五、编程题：

设计程序求 1~100 的和。

（与上面实验内容的第 7 题重复！！！省略）

请指出下面程序的错误。

swith(n) {
    case 1:
    System.out.println("First");
    case 2:
    System.out.println("Second");
    case 3:
    System.out.println("Third");
}

答案：

关键字拼写错误：swith 应为 switch；每个 case 分支后缺少 break 语句，会发生 “case 穿透” 现象，匹配到某个 case 后会一直执行后续所有 case 的代码；缺少 default 分支（可选但建议添加，用于处理所有 case 都不匹配的情况）。

水仙花数是指其个位、十位、百位三个数的立方和等于这个数本身，求出所有水仙花数。

（与上面实验内容的第 8 题重复！！！省略）

试利用 for 循环，计算 1 + 2 + 3 + 4 + … + 100 的值。

（与上面实验内容的第 9 题重复！！！省略）

利用 do-while 循环，计算 1! + 2! + 3! + … + 100! 的值。

（与上面实验内容的第 10 题重复！！！省略）

使用循环嵌套，编写一个输出如下图形的程序：

*
*  *
*  *  *
*  *  *  *
*  *  *  *  *

答案：

public class PrintStar {
    public static void main(String[] args) {
        // 外层循环控制行数，共 5 行
        for (int i = 1; i <= 5; i++) {
            // 内层循环控制每行输出的 * 数量，第 i 行输出 i 个 *
            for (int j = 1; j <= i; j++) {
                System.out.print("* ");
            }
            // 一行结束后换行
            System.out.println();
        }
    }
}

一、实验内容

1. 上网查资料，了解 Java 的由来和发展历程。

2. MS-DOS 常用命令的使用练习。掌握如下命令的使用：dir、cd、javac、java、set 等。

3. 下载、安装 JDK，并完成环境的搭建。

4. 分别开发一个 Java 应用程序和一个 Java 小应用，实现输出语句“xxxx大学欢迎您！”。

5. 运行教材第一章中所有的代码。

6. 运行教材第二章中案例 2-1 到案例 2-5。

7. 设计程序，求 1 到 100 的和。

8. 打印所有的水仙花数。

9. 利用 for 循环，计算 1 + 2 + 3 + 4 + … + 100 的总和。

10. 利用 do-while 循环，计算 1! + 2! + 3! + … + 100! 的总和。

二、课后习题

第一章：概述

第一章 一、填空题：

第一章 二、判断题：

第一章 三、问答题：

第二章：Java 语言程序设计基础

第二章 一、填空题：

第二章 二、选择题：

第二章 三、输出结果题：

第二章 四、问答题：

第二章 五、编程题：

评论

第一章一、填空题：

第一章二、判断题：

第一章三、问答题：

第二章一、填空题：

第二章二、选择题：

第二章三、输出结果题：

第二章四、问答题：

第二章五、编程题：