由于市面上不同版本的教材（如耿祥义、李海涛，或蔡敏等作者编写的）章节顺序和习题内容可能略有差异，我无法提供与您手中教材一字不差的答案，我会根据这门课程的核心知识点，提供一套高质量、通用性强、附带详细解析的典型习题答案。
（图片来源网络，侵删）
这套答案可以作为您完成作业、复习备考的重要参考，关键在于理解代码背后的思想,而不是简单地复制。
重要提示
- 理解优先：请务必先自己思考，尝试编写代码，然后再参考本答案，代码可以有多种写法，只要逻辑正确、实现功能即可。
- 版本差异：以下代码基于 Java 8/11/17 等主流版本编写,兼容性良好。
- 代码风格：遵循了Java的命名规范（类名大驼峰，方法/变量名小驼峰）和良好注释习惯。
- 扩展性：部分答案给出了基础版和进阶版,您可以根据自己的学习水平进行参考。
第一章：Java语言基础
典型习题 1：编写一个Java程序，打印 "Hello, World!"
答案：
// 文件名: HelloWorld.java
/**
* 第一个Java程序，在控制台打印 "Hello, World!"
*/
public class HelloWorld {
/**
* 程序的入口方法
* @param args 命令行参数
*/
public static void main(String[] args) {
// 使用System.out.println()方法打印字符串
System.out.println("Hello, World!");
}
}
解析：
public class HelloWorld：定义一个名为HelloWorld的公共类，类名必须与文件名（HelloWorld.java）完全一致。public static void main(String[] args)：这是Java应用程序的入口点。public：表示该方法可以被任何其他类访问。static：表示该方法属于类，而不是类的某个实例，因此可以直接通过类名调用,无需创建对象。void：表示该方法没有返回值。main：是JVM（Java虚拟机）寻找并执行的标准方法名。String[] args：这是一个字符串数组,用于接收命令行传入的参数。
System.out.println(...)：这是Java标准输出库中的一个方法,用于在控制台打印一行文本并自动换行。
第二章：类与对象
典型习题 2：定义一个“学生”类，包含姓名、年龄和学号属性，并有一个自我介绍的方法。
答案：
（图片来源网络，侵删）
// 文件名: Student.java
/**
* 学生类，用于表示一个学生对象
*/
public class Student {
// 成员变量（属性）
private String name; // 姓名
private int age; // 年龄
private String studentId; // 学号
// 构造方法，用于创建对象时初始化属性
public Student(String name, int age, String studentId) {
this.name = name;
this.age = age;
this.studentId = studentId;
}
// selfIntroduction方法，用于自我介绍
public void selfIntroduction() {
System.out.println("大家好，我叫 " + this.name + "，今年 " + this.age + " 岁，学号是 " + this.studentId + "。");
}
// Getter 和 Setter 方法（封装性的体现）
// 用于获取和修改私有属性
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
// 可以在这里添加数据校验逻辑
if (age > 0) {
this.age = age;
} else {
System.out.println("年龄必须大于0！");
}
}
public String getStudentId() {
return studentId;
}
public void setStudentId(String studentId) {
this.studentId = studentId;
}
}
解析：
- 封装：将属性（
name,age,studentId）设置为private（私有），外部无法直接访问，只能通过公共的getter和setter方法进行访问和修改,这保护了数据的内部状态。 - 构造方法：
public Student(...)是一个构造方法，当使用new Student(...)创建对象时，该方法会被调用，用于初始化对象的属性。this.name表示当前对象的name属性，用来区分方法参数name。 - 方法：
selfIntroduction()是一个实例方法，它访问了对象的属性,并打印出信息。 - Getter/Setter：这是JavaBean的标准实践,提供了对私有属性的受控访问。
典型习题 3：创建 Student 类的对象，并调用其方法。
答案：
// 文件名: TestStudent.java
/**
* 测试Student类的程序
*/
public class TestStudent {
public static void main(String[] args) {
// 1. 使用new关键字和构造方法创建Student类的对象
Student student1 = new Student("张三", 20, "2025001");
// 2. 调用对象的selfIntroduction方法
student1.selfIntroduction(); // 输出: 大家好，我叫 张三，今年 20 岁，学号是 2025001。
// 3. 使用setter方法修改学生信息
student1.setAge(21);
System.out.println("一年后，" + student1.getName() + " 的年龄是: " + student1.getAge()); // 输出: 一年后，张三 的年龄是: 21
// 4. 创建第二个学生对象
Student student2 = new Student("李四", 19, "2025002");
student2.selfIntroduction(); // 输出: 大家好，我叫 李四，今年 19 岁，学号是 2025002。
}
}
解析：
Student student1 = new Student(...);：这是创建对象的标准语法。Student student1：声明一个Student类型的引用变量student1。new Student(...)：在内存中创建一个新的Student对象,并调用其构造方法进行初始化。- 将新创建的对象的内存地址赋给
student1变量。
student1.selfIntroduction();：通过 操作符调用student1对象的方法。
第三章：继承与多态
典型习题 4：定义一个“动物”基类和“狗”/“猫”子类，实现多态。
答案：
（图片来源网络，侵删）
// 文件名: Animal.java
// 基类：动物
class Animal {
private String name;
public Animal(String name) {
this.name = name;
}
public String getName() {
return name;
}
// 父类的方法，子类可以重写
public void makeSound() {
System.out.println(this.name + " 发出声音");
}
}
// 文件名: Dog.java
// 子类：狗
class Dog extends Animal {
public Dog(String name) {
super(name); // 调用父类的构造方法
}
// 重写父类的方法
@Override
public void makeSound() {
System.out.println(this.getName() + " 汪汪叫");
}
}
// 文件名: Cat.java
// 子类：猫
class Cat extends Animal {
public Cat(String name) {
super(name); // 调用父类的构造方法
}
// 重写父类的方法
@Override
public void makeSound() {
System.out.println(this.getName() + " 喵喵叫");
}
}
// 文件名: TestPolymorphism.java
// 测试多态的程序
public class TestPolymorphism {
public static void main(String[] args) {
// 创建父类引用，指向子类对象
Animal animal1 = new Dog("旺财");
Animal animal2 = new Cat("咪咪");
// 调用方法，会根据实际的对象类型（Dog或Cat）来执行相应的方法
// 这就是多态：同一个接口（makeSound），不同的实现
animal1.makeSound(); // 输出: 旺财 汪汪叫
animal2.makeSound(); // 输出: 咪咪 喵喵叫
// 使用一个方法来处理所有动物
processAnimal(animal1);
processAnimal(animal2);
}
/**
* 一个方法可以接受任何Animal类型的子类对象
* @param animal 动物对象
*/
public static void processAnimal(Animal animal) {
System.out.print("正在处理动物: ");
animal.makeSound();
}
}
解析：
- 继承：
class Dog extends Animal表示Dog类继承自Animal类，Dog类获得了Animal类的所有非私有属性和方法。 - super：
super(name)用于在子类构造方法中调用父类的构造方法,必须放在子类构造方法的第一行。 - 方法重写：
@Override是一个注解，告诉编译器我们正在重写父类的方法。Dog和Cat类都提供了makeSound()方法的自己的实现。 - 多态：
Animal animal1 = new Dog(...);是多态的核心，父类类型的引用animal1可以指向子类Dog的对象，当调用animal1.makeSound()时，JVM会根据animal1实际指向的对象类型（Dog）来调用Dog类的makeSound()方法，而不是Animal类的,这使得代码更加灵活和可扩展。
第四章：抽象类与接口
典型习题 5：定义一个“飞行器”接口，并创建“飞机”和“鸟”类实现它。
答案：
// 文件名: Flyable.java
// 接口：飞行器
interface Flyable {
// 接口中所有的方法默认是 public abstract 的，可以省略关键字
void fly();
// Java 8+ 接口可以有默认实现的方法
default void takeOff() {
System.out.println("准备起飞...");
}
}
// 文件名: Airplane.java
// 实现类：飞机
class Airplane implements Flyable {
private String model;
public Airplane(String model) {
this.model = model;
}
@Override
public void fly() {
System.out.println(this.model + " 正在高速飞行，依靠引擎动力。");
}
// 可以选择不重写默认方法，或者重写它
@Override
public void takeOff() {
System.out.println(this.model + " 在跑道上加速起飞！");
}
}
// 文件名: Bird.java
// 实现类：鸟
class Bird implements Flyable {
private String species;
public Bird(String species) {
this.species = species;
}
@Override
public void fly() {
System.out.println(this.species + " 正在扇动翅膀飞行，依靠生物本能。");
}
// 鸟类可以有自己的特有方法
public void buildNest() {
System.out.println(this.species + " 正在筑巢。");
}
}
// 文件名: TestInterface.java
// 测试接口的程序
public class TestInterface {
public static void main(String[] args) {
Flyable airplane = new Airplane("波音747");
Flyable bird = new Bird("麻雀");
// 通过接口引用调用方法
airplane.takeOff(); // 输出: 波音747 在跑道上加速起飞！
airplane.fly(); // 输出: 波音747 正在高速飞行，依靠引擎动力。
bird.takeOff(); // 输出: 准备起飞... (使用了接口的默认方法)
bird.fly(); // 输出: 麻雀 正在扇动翅膀飞行，依靠生物本能。
// 鸟类特有的方法不能通过Flyable接口调用
// bird.buildNest(); // 编译错误！
// 必须将其转换为Bird类型才能调用
if (bird instanceof Bird) {
Bird myBird = (Bird) bird;
myBird.buildNest(); // 输出: 麻雀 正在筑巢。
}
}
}
解析：
- 接口：
interface Flyable定义了一个契约，任何实现Flyable接口的类都必须提供fly()方法的实现。 - 实现：
class Airplane implements Flyable表示Airplane类承诺实现Flyable接口的所有方法。 - 默认方法：
default void takeOff()是Java 8引入的特性，允许在接口中提供方法的默认实现,实现类可以选择是否重写它。 - instanceof 和类型转换：
bird instanceof Bird用于检查bird引用指向的对象是否是Bird类的实例，如果是，才能安全地将其转换为Bird类型，从而调用Bird类特有的buildNest()方法。
第五章：异常处理
典型习题 6：编写一个程序，读取用户输入的两个整数，计算并输出它们的商，要求处理除数为0和输入非整数的情况。
答案：
// 文件名: ExceptionHandlingDemo.java
import java.util.InputMismatchException;
import java.util.Scanner;
public class ExceptionHandlingDemo {
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();
// 计算商，可能会抛出ArithmeticException
int result = divide(num1, num2);
System.out.println("结果是: " + result);
} catch (InputMismatchException e) {
// 捕获输入不匹配的异常（比如输入了字母）
System.out.println("输入错误：请输入有效的整数！");
} catch (ArithmeticException e) {
// 捕获算术异常（比如除数为0）
System.out.println("算术错误：" + e.getMessage());
} finally {
// 无论是否发生异常，finally块中的代码都会被执行
System.out.println("程序执行完毕。");
scanner.close(); // 关闭Scanner，释放资源
}
}
/**
* 计算两个整数的商
* @param a 被除数
* @param b 除数
* @return 商
* @throws ArithmeticException 如果除数为0
*/
public static int divide(int a, int b) throws ArithmeticException {
if (b == 0) {
// 显式地抛出一个算术异常
throw new ArithmeticException("除数不能为0");
}
return a / b;
}
}
解析：
try-catch-finally：这是异常处理的标准结构。try：将可能抛出异常的代码块包裹起来。catch：捕获特定类型的异常，并执行相应的处理逻辑，可以有多个catch块。finally：无论try块中是否发生异常，finally块中的代码都一定会被执行，通常用于释放资源（如关闭文件、网络连接等）。
InputMismatchException：当Scanner.nextInt()读取到的输入不是一个整数时,会抛出此异常。ArithmeticException：当整数除法中除数为0时,JVM会自动抛出此异常。throw：throw new ArithmeticException(...)是手动抛出一个异常。throws：在方法签名中使用throws，表示该方法不处理异常,而是将异常抛给它的调用者处理。
总结与建议
这份答案涵盖了面向对象和Java程序设计的核心概念，学习编程最好的方式就是动手实践。
- 敲一遍代码：不要只看不练，亲手将代码敲入IDE（如IntelliJ IDEA或Eclipse）并运行,观察结果。
- 修改和扩展：尝试修改这些例子，比如给
Student类增加一个score属性，或者给Animal类增加一个eat()方法。 - 阅读官方文档：遇到不确定的类或方法（如
System.out.println），可以去Oracle的官方Java文档中查找,这是最权威的资料。 - 调试：学习使用IDE的调试功能，单步执行代码，观察变量的变化,这能帮助你更深刻地理解程序的执行流程。
希望这份详尽的答案和解析能对您的学习有所帮助！祝您学习顺利！
