第一部分：Java基础核心知识点梳理

Java语言基础

• 数据类型:
  • 基本类型: byte, short, int, long, float, double, char, boolean。
  • 引用类型: 类, 接口, 数组, 枚举。
• 变量与常量:
  • 变量: type varName = value;
  • 常量: final TYPE CONSTANT_NAME = value;
• 运算符:
  • 算术: , , , , , ,
  • 关系: >, <, >=, <=, ,
  • 逻辑: && (与), (或), (非), ^ (异或)
  • 赋值: , , , etc.
• 流程控制:
  • if-else, switch-case
  • for, while, do-while
  • break, continue, return

面向对象编程

• 三大特性:
  • 封装: 将数据（属性）和操作数据的方法（行为）捆绑在一起，并隐藏对象的内部细节，通过 private 关键字实现，通过 public 的 getter/setter 方法访问。
  • 继承: 子类继承父类的属性和方法，实现代码复用，使用 extends 关键字,Java是单继承的。
  • 多态: 同一个接口，使用不同的实例而执行不同操作，实现方式：方法重写、接口实现,父类引用指向子类对象是多态的体现。
• 类与对象:
  • 类: 创建对象的模板或蓝图。
  • 对象: 类的实例，通过 new 关键字创建。
• 方法:
  • 定义: [修饰符] 返回值类型 方法名([参数列表]) { 方法体 }
  • 方法重载: 在同一个类中，方法名相同，但参数列表不同（参数个数、类型或顺序不同）。
  • 方法重写: 在子类中，定义一个与父类方法具有相同方法名、相同参数列表和相同返回值类型的方法,以覆盖父类的实现。
• 关键字:
  • this: 指向当前对象的引用。
  • super: 指向当前对象父类的引用。
  • static: 用于修饰成员（变量、方法），表示它们属于类,而不是类的实例。
  • final: 表示“最终的”，不可变的，可以修饰类（不能被继承）、方法（不能被重写）、变量（常量）。
  • abstract: 用于抽象类和抽象方法,不能被实例化。

数组

• 声明与初始化:
  • int[] nums; // 声明
  • nums = new int[10]; // 分配空间
  • int[] nums = {1, 2, 3}; // 声明并初始化
• 使用: 通过索引访问元素，如 nums[0]。
• 多维数组: int[][] matrix = new int[3][4];

常用API

• 字符串:
  • String: 不可变，常用方法: length(), charAt(), substring(), indexOf(), equals(), toUpperCase()。
  • StringBuilder / StringBuffer: 可变，用于高效拼接字符串。append(), toString()。
• 包装类: Integer, Double, Boolean 等,用于基本类型和对象之间的转换。
• 工具类: Math (数学运算), Arrays (数组操作), Collections (集合操作)。

第二部分：典型例题与代码解析

例题1：基础语法与流程控制

编写一个Java程序，找出1到100之间所有能被7整除但不能被5整除的整数,并计算它们的和。

答案解析:

1. 分析: 需要遍历1到100的数字，对每个数字，判断它是否能被7整除（i % 7 == 0）且不能被5整除（i % 5 != 0）。
2. 选择循环结构: for 循环非常适合这种有明确范围的遍历。
3. 逻辑: 在循环体内使用 if 语句进行条件判断。
4. 累加: 定义一个变量 sum，在满足条件时，将当前数字 i 加到 sum 上。

代码示例:

public class FindNumbers {
    public static void main(String[] args) {
        int sum = 0; // 用于存储满足条件的数字之和
        // 使用for循环遍历1到100
        for (int i = 1; i <= 100; i++) {
            // 判断是否能被7整除且不能被5整除
            if (i % 7 == 0 && i % 5 != 0) {
                System.out.println("找到符合条件的数字: " + i);
                sum += i; // 累加到总和中
            }
        }
        // 循环结束后，输出最终结果
        System.out.println("1到100之间能被7整除但不能被5整除的数字之和为: " + sum);
    }
}

例题2：面向对象编程

设计一个 Student 类，包含属性：学号、姓名、年龄,要求：

1. 属性私有化。
2. 提供公共的 getter 和 setter 方法。
3. 提供一个无参构造方法和一个全参构造方法。
4. 重写 toString() 方法,用于打印学生信息。
5. 创建 Student 对象并进行测试。

答案解析:

1. 类设计: 创建一个名为 Student 的类。
2. 属性: 定义三个私有属性 id, name, age。
3. 构造方法: 提供无参构造器（方便创建对象后逐个赋值）和全参构造器（方便快速创建对象）。
4. 封装: 为每个私有属性提供 public 的 getter 和 setter 方法。
5. toString(): 重写 Object 类的 toString() 方法，使其返回一个格式化的字符串,方便打印对象信息。
6. 测试: 在 main 方法中创建 Student 类的实例,调用其方法和属性。

代码示例:

// Student.java
public class Student {
    // 1. 私有属性
    private String id;
    private String name;
    private int age;
    // 3. 无参构造方法
    public Student() {
    }
    // 3. 全参构造方法
    public Student(String id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    // 2. getter 和 setter 方法
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    // 4. 重写 toString() 方法
    @Override
    public String toString() {
        return "Student{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
// TestStudent.java
public class TestStudent {
    public static void main(String[] args) {
        // 使用全参构造方法创建学生对象
        Student student1 = new Student("1001", "张三", 20);
        System.out.println("学生1信息: " + student1); // 自动调用 toString()
        // 使用无参构造方法创建学生对象，并使用 setter 赋值
        Student student2 = new Student();
        student2.setId("1002");
        student2.setName("李四");
        student2.setAge(21);
        // 使用 getter 获取信息并打印
        System.out.println("学生2的姓名是: " + student2.getName());
        System.out.println("学生2信息: " + student2);
    }
}

例题3：数组与算法

有一个整型数组 int[] arr = {5, 2, 9, 1, 5, 6};，要求编写代码将其按从小到大的顺序排序（使用冒泡排序算法）,并打印排序前后的数组。

答案解析:

1. 冒泡排序原理:
   • 比较相邻的元素，如果第一个比第二个大,就交换它们两个。
   • 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这步做完后,最后的元素会是最大的数。
   • 针对所有的元素重复以上的步骤,除了最后一个。
   • 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较为止。
2. 实现:
   • 需要两层循环，外层循环控制排序的轮数（n-1轮），内层循环控制每一轮中比较的次数（随着轮数增加，比较次数减少）。
   • 使用一个临时变量 temp 来完成交换。

代码示例:

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {5, 2, 9, 1, 5, 6};
        // 打印排序前的数组
        System.out.println("排序前的数组:");
        printArray(arr);
        // 冒泡排序
        // 外层循环控制排序轮数
        for (int i = 0; i < arr.length - 1; i++) {
            // 内层循环控制每轮比较次数
            // -i 是因为每轮排序后，最大的元素已经冒泡到最后，无需再比较
            // -1 是为了避免数组越界
            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("\n排序后的数组:");
        printArray(arr);
    }
    // 一个辅助方法，用于打印数组
    public static void printArray(int[] array) {
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]);
            if (i < array.length - 1) {
                System.out.print(", ");
            }
        }
        System.out.println("]");
    }
}

第三部分：进阶知识点（通常在后半部分教程中）

异常处理

• try-catch-finally: try 块中放可能抛出异常的代码，catch 块捕获并处理特定异常，finally 块无论是否发生异常都会执行。
• throws: 在方法签名上使用，声明该方法可能抛出的异常,由调用者处理。

集合框架

• List: 有序、可重复，实现类 ArrayList (数组实现, 查快), LinkedList (链表实现, 增删快)。
• Set: 无序、不可重复，实现类 HashSet (哈希表), TreeSet (二叉树)。
• Map: 键值对存储，键唯一，值可重复，实现类 HashMap (最常用), TreeMap (键排序)。

I/O流

• 字节流: InputStream, OutputStream，处理二进制数据（如图片、视频）。
• 字符流: Reader, Writer，处理文本数据（如.txt文件）。FileReader, FileWriter。
• 缓冲流: BufferedInputStream, BufferedReader 等,可以提高读写效率。

多线程

• 创建线程的两种方式:
  1. 继承 Thread 类并重写 run() 方法。
  2. 实现 Runnable 接口并实现 run() 方法（推荐，避免单继承局限）。
• 同步: 使用 synchronized 关键字或 Lock 接口来解决多线程并发访问共享资源导致的数据不一致问题。

如何找到你教材的具体答案？

1. 教材配套资源: 检查你的教材封面或前言，通常会附带一张光盘或一个网址，上面有习题答案、源代码等。
2. 出版社官网: 登录教材出版社的官方网站，查找该教材的“资源下载”或“教学支持”栏目。
3. 联系授课老师: 这是最直接、最准确的方式。
4. 在线搜索: 尝试搜索“[你的教材全名] 课后答案”或“[你的教材全名] 习题解答”，搜索“雍俊海 Java程序设计教程 答案”。
5. 学习社区: 在CSDN、博客园、GitHub等平台上,有大量学习者分享的笔记和习题解答。

希望这份详细的梳理和示例能帮助你更好地学习Java程序设计！学习编程的关键在于多动手、多思考，将理论知识转化为自己的代码能力,祝你学习顺利！