这份指导旨在帮助学生将理论知识转化为实际编程能力，每个实验都包含实验目的、实验要求、实验步骤、核心代码示例和实验总结，力求清晰、实用。
（图片来源网络，侵删）
Java语言基础
实验目的
- 熟悉JDK的安装与配置，掌握
PATH和JAVA_HOME环境变量的设置。 - 掌握使用命令行（
cmd）和集成开发环境（如IDEA/Eclipse）编写、编译和运行Java程序的基本流程。 - 掌握Java基本数据类型、运算符、表达式和流程控制语句（
if-else,switch,for,while,do-while）的使用。 - 理解并使用
Scanner类进行基本的键盘输入。
实验要求
- 编写一个程序，实现一个简单的“猜数字”游戏，程序随机生成一个1-100之间的整数，然后让用户输入猜测的数字，程序给出“猜大了”、“猜小了”或“猜对了”的提示,直到用户猜中为止。
- 编写一个程序，打印出所有的“水仙花数”，水仙花数是指一个三位数，其各位数字立方和等于它本身（153 = 1³ + 5³ + 3³）。
实验步骤与核心代码示例
任务1：猜数字游戏
-
创建Java文件：创建一个名为
GuessNumber.java的文件。 -
编写代码：
import java.util.Scanner; // 导入Scanner类，用于接收用户输入 public class GuessNumber { public static void main(String[] args) { // 1. 生成一个1-100的随机数 int targetNumber = (int)(Math.random() * 100) + 1; int guess = 0; int count = 0; // 记录猜测次数 // 2. 创建Scanner对象 Scanner scanner = new Scanner(System.in); System.out.println("----- 猜数字游戏 -----"); System.out.println("我已经想好了一个1到100之间的整数，请你来猜一猜。"); // 3. 使用while循环，直到猜中为止 while (guess != targetNumber) { System.out.print("请输入你猜的数字: "); guess = scanner.nextInt(); // 读取用户输入的整数 count++; if (guess > targetNumber) { System.out.println("猜大了！"); } else if (guess < targetNumber) { System.out.println("猜小了！"); } else { System.out.println("恭喜你，猜对了！"); System.out.println("你一共猜了 " + count + " 次。"); } } // 4. 关闭Scanner，释放资源 scanner.close(); } }
任务2：打印水仙花数
（图片来源网络，侵删）
-
创建Java文件：创建一个名为
NarcissisticNumber.java的文件。 -
编写代码：
public class NarcissisticNumber { public static void main(String[] args) { System.out.println("所有的水仙花数是："); // 遍历所有的三位数 (100 - 999) for (int i = 100; i < 1000; i++) { // 分解出个位、十位、百位 int bai = i / 100; int shi = (i / 10) % 10; int ge = i % 10; // 计算各位数字的立方和 int sum = bai * bai * bai + shi * shi * shi + ge * ge * ge; // 判断是否为水仙花数 if (sum == i) { System.out.print(i + " "); } } System.out.println(); // 换行 } }
实验总结
通过本次实验，我掌握了Java程序从编写到运行的完整流程，重点练习了Math.random()生成随机数、Scanner获取用户输入以及for循环和if-else判断语句的综合运用，理解了如何通过取模（）和整除（）运算来分解一个数的每一位。
面向对象基础（类与对象）
实验目的
- 掌握类的定义，包括成员变量（属性）和成员方法。
- 掌握对象的创建和使用（
new关键字）。 - 理解构造函数的作用、重载及其调用过程。
- 理解
static关键字修饰的成员变量和方法（类变量和类方法）。
实验要求
- 设计一个
Student类，包含属性：name（姓名）、age（年龄）、score（成绩），至少包含一个构造方法用于初始化这些属性，以及一个showInfo()方法用于打印学生信息。 - 在主类中，创建
Student类的对象，并调用其方法,完成信息的展示。 - 在
Student类中，添加一个静态成员变量studentCount，用于统计创建的学生对象总数，每次创建新对象时,该计数器自动加1。
实验步骤与核心代码示例
-
创建
Student.java文件：
（图片来源网络，侵删）public class Student { // 1. 成员变量（实例变量） String name; int age; double score; // 2. 静态成员变量（类变量） static int studentCount = 0; // 3. 构造方法（无参） public Student() { studentCount++; // 每创建一个对象，计数器+1 } // 4. 构造方法（带参，重载） public Student(String name, int age, double score) { this(); // 调用无参构造方法 this.name = name; this.age = age; this.score = score; } // 5. 成员方法 public void showInfo() { System.out.println("学生姓名: " + this.name); System.out.println("学生年龄: " + this.age); System.out.println("学生成绩: " + this.score); System.out.println("--------------------"); } // 6. 静态方法（类方法） public static void showTotalCount() { System.out.println("当前已创建的学生总数为: " + studentCount); } } -
创建主类
TestStudent.java文件：public class TestStudent { public static void main(String[] args) { System.out.println("开始创建学生对象..."); // 创建第一个学生对象 Student s1 = new Student("张三", 18, 90.5); s1.showInfo(); // 创建第二个学生对象 Student s2 = new Student("李四", 19, 85.0); s2.showInfo(); // 创建第三个学生对象（使用无参构造） Student s3 = new Student(); s3.name = "王五"; s3.age = 20; s3.score = 92.5; s3.showInfo(); // 调用静态方法 Student.showTotalCount(); // 或者 s1.showTotalCount(); } }
实验总结
本次实验深入理解了面向对象的封装性，学会了如何定义类来描述现实世界的事物，并通过构造函数高效地初始化对象状态，重点区分了实例变量（每个对象独有）和静态变量（所有对象共享）的区别，以及实例方法（操作对象状态）和静态方法（与类本身相关）的使用场景。
数组与字符串
实验目的
- 掌握一维数组和二维数组的声明、创建、初始化和遍历。
- 掌握字符串
String的常用方法（length(),charAt(),substring(),indexOf(),equals()等）。 - 理解
String、StringBuffer和StringBuilder的区别与使用场景。
实验要求
- 创建一个整型数组，并对其进行排序（如冒泡排序）。
- 从一个字符串中提取出所有的数字字符,并拼接成一个新字符串。
- 使用
StringBuffer或StringBuilder,实现一个字符串的逆序。
实验步骤与核心代码示例
任务1：数组排序（冒泡排序）
public class ArraySort {
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};
System.out.println("排序前的数组:");
printArray(arr);
// 冒泡排序
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
// 交换位置
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
System.out.println("排序后的数组:");
printArray(arr);
}
// 辅助方法：打印数组
public static void printArray(int[] arr) {
for (int num : arr) {
System.out.print(num + " ");
}
System.out.println();
}
}
任务2：从字符串中提取数字
public class ExtractNumbers {
public static void main(String[] args) {
String str = "我的电话是138-1234-5678，邮编是100101。";
String numbers = "";
// 遍历字符串的每一个字符
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
// 判断字符是否是数字
if (c >= '0' && c <= '9') {
numbers += c; // 拼接到新字符串
}
}
System.out.println("原始字符串: " + str);
System.out.println("提取出的数字: " + numbers); // 输出: 13812345678100101
}
}
任务3：字符串逆序（使用StringBuilder）
public class StringReverse {
public static void main(String[] args) {
String original = "Hello, World!";
// 使用StringBuilder
StringBuilder sb = new StringBuilder(original);
String reversed = sb.reverse().toString();
System.out.println("原始字符串: " + original);
System.out.println("逆序后的字符串: " + reversed); // 输出: !dlroW ,olleH
}
}
实验总结
本次实验熟练掌握了数组的操作，特别是排序算法的实现，对String类有了更深入的认识，知道了其不可变性，并学习了如何使用StringBuilder来高效地修改字符串内容，理解了它在性能上优于String直接拼接（）。
继承与多态
实验目的
- 掌握类的继承，使用
extends关键字。 - 理解方法重写和方法重载的区别。
- 掌握
super关键字的使用（调用父类构造方法和成员）。 - 理解抽象类和抽象方法的概念及应用。
- 掌握多态的实现机制（父类引用指向子类对象）。
实验要求
- 设计一个
Animal基类（抽象类），包含一个抽象方法eat()。 - 创建
Dog和Cat两个子类，继承自Animal，并分别实现eat()方法。 - 在主类中，创建一个
Animal类型的数组，将Dog和Cat对象存入数组，然后遍历数组，调用eat()方法,观察多态现象。
实验步骤与核心代码示例
-
创建
Animal.java（抽象类）：// 抽象类 public abstract class Animal { // 成员变量 String name; // 构造方法 public Animal(String name) { this.name = name; } // 抽象方法 public abstract void eat(); } -
创建
Dog.java（子类）：// Dog类继承Animal public class Dog extends Animal { public Dog(String name) { super(name); // 调用父类的构造方法 } // 重写父类的抽象方法 @Override public void eat() { System.out.println(this.name + " 在吃骨头。"); } } -
创建
Cat.java（子类）：// Cat类继承Animal public class Cat extends Animal { public Cat(String name) { super(name); } // 重写父类的抽象方法 @Override public void eat() { System.out.println(this.name + " 在吃鱼。"); } } -
创建主类
TestPolymorphism.java：public class TestPolymorphism { public static void main(String[] args) { // 创建父类数组，存放子类对象（多态） Animal[] animals = new Animal[2]; animals[0] = new Dog("旺财"); animals[1] = new Cat("咪咪"); // 遍历数组，调用eat方法 for (Animal animal : animals) { animal.eat(); // 这里体现了多态，根据实际对象类型调用相应的方法 } } }
实验总结
本次实验是面向对象编程的核心，通过继承，实现了代码的复用，通过抽象类，定义了类的通用行为规范，最重要的收获是理解了多态：同一个接口（方法调用），作用于不同的对象，会产生不同的执行结果,这使得代码具有了更好的扩展性和灵活性。
常用类与异常处理
实验目的
- 掌握
Date、SimpleDateFormat、Calendar等日期时间类的使用。 - 掌握包装类（
Integer,Double等）与基本数据类型的相互转换。 - 理解异常的体系结构，掌握
try-catch-finally语句块的使用。 - 学会自定义异常。
实验要求
- 编写一个程序，获取当前日期和时间，并按照指定格式（如"yyyy-MM-dd HH:mm:ss"）输出。
- 编写一个程序，实现一个简单的整数除法计算器,要求对除数为0和输入非数字的情况进行异常处理。
- 自定义一个异常
AgeOutOfRangeException，当输入的年龄不在合理范围（如0-120）时抛出该异常。
实验步骤与核心代码示例
任务1：日期格式化
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateExample {
public static void main(String[] args) {
// 获取当前日期时间对象
Date now = new Date();
// 创建SimpleDateFormat对象，指定格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
// 格式化日期
String formattedDate = sdf.format(now);
System.out.println("当前系统时间是: " + formattedDate);
}
}
任务2：异常处理（除法计算器）
import java.util.InputMismatchException;
import java.util.Scanner;
public class Calculator {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
try {
System.out.print("请输入第一个整数: ");
int num1 = scanner.nextInt();
System.out.print("请输入第二个整数: ");
int num2 = scanner.nextInt();
int result = num1 / num2;
System.out.println("计算结果是: " + result);
} catch (InputMismatchException e) {
System.out.println("输入错误：请输入有效的整数！");
} catch (ArithmeticException e) {
System.out.println("算术错误：除数不能为0！");
} finally {
System.out.println("程序执行完毕。");
scanner.close();
}
}
}
任务3：自定义异常
// 1. 自定义异常类
class AgeOutOfRangeException extends Exception {
public AgeOutOfRangeException(String message) {
super(message);
}
}
// 2. 在主程序中使用自定义异常
public class CustomExceptionDemo {
public static void checkAge(int age) throws AgeOutOfRangeException {
if (age < 0 || age > 120) {
// 抛出自定义异常
throw new AgeOutOfRangeException("年龄必须在0到120之间！");
}
System.out.println("年龄合法: " + age);
}
public static void main(String[] args) {
try {
checkAge(150); // 测试一个非法年龄
} catch (AgeOutOfRangeException e) {
// 捕获并处理自定义异常
System.out.println("捕获到异常: " + e.getMessage());
}
}
}
实验总结
本次实验让我掌握了Java中处理实际业务场景的关键工具，日期时间类和包装类在日常开发中非常常用，更重要的是，学会了如何优雅地处理程序中可能出现的错误，通过异常机制让程序更加健壮和用户友好,自定义异常则提供了更精确的错误定位和处理能力。
