期末速通 -Java程序设计基础 -理论

夜泉_ly2025-12-26 10:32

博客主页：【夜泉_ly】

本文专栏：【<>暂无】

欢迎点赞👍收藏⭐关注❤️

    • [第1章 Java 概述](#第1章 Java 概述)
      • [一、1.1 了解 Java](#一、1.1 了解 Java)
      • [二、1.2 Java 应用及运行方式](#二、1.2 Java 应用及运行方式)
        • [1. Application 与 Applet](#1. Application 与 Applet)
        • [2. Java 程序基本结构（重点）](#2. Java 程序基本结构（重点）)
        • [3. Java 程序运行流程](#3. Java 程序运行流程)
        • [4. 补充](#4. 补充)
      • [三、1.3 JDK（重点）](#三、1.3 JDK（重点）)
        • [1. JVM / JRE / JDK 区别](#1. JVM / JRE / JDK 区别)
        • [2. JDK 主要目录](#2. JDK 主要目录)
        • [3. 编译与运行命令](#3. 编译与运行命令)
      • [四、1.4 MyEclipse（理解）](#四、1.4 MyEclipse（理解）)
      • [五、1.5 IntelliJ IDEA（理解）](#五、1.5 IntelliJ IDEA（理解）)
      • 六、考试速记
    • [第2章 基本数据类型与数组（重点）](#第2章 基本数据类型与数组（重点）)
      • [一、2.1 标识符与关键字](#一、2.1 标识符与关键字)
        • [1. 标识符](#1. 标识符)
        • [2. 关键字](#2. 关键字)
      • [二、2.2 基本数据类型（必考）](#二、2.2 基本数据类型（必考）)
      • [三、2.3 类型级别与类型转换（高频）](#三、2.3 类型级别与类型转换（高频）)
        • [1. 精度从低到高](#1. 精度从低到高)
        • [2. 自动类型转换](#2. 自动类型转换)
        • [3. 强制类型转换](#3. 强制类型转换)
      • [四、2.4 输入与输出（理解 + 会用）](#四、2.4 输入与输出（理解 + 会用）)
        • [1. 输入（Scanner）](#1. 输入（Scanner）)
        • [2. 输出](#2. 输出)
        • [3. 格式化输出（了解）](#3. 格式化输出（了解）)
      • [五、2.5 数组（必考）](#五、2.5 数组（必考）)
        • [1. 数组声明](#1. 数组声明)
        • [2. 分配空间](#2. 分配空间)
        • [3. 数组元素访问](#3. 数组元素访问)
        • [4. length 属性](#4. length 属性)
        • [5. 数组初始化](#5. 数组初始化)
        • [6. 数组引用（易考）](#6. 数组引用（易考）)
      • [六、2.6 应用举例（了解）](#六、2.6 应用举例（了解）)
      • 七、考试速记
    • [第3章 运算符、表达式与语句](#第3章 运算符、表达式与语句)
      • [一、3.1 运算符与表达式（高频）](#一、3.1 运算符与表达式（高频）)
        • [1. 算术运算符](#1. 算术运算符)
        • [2. 自增、自减运算符](#2. 自增、自减运算符)
        • [3. 混合运算的精度规则](#3. 混合运算的精度规则)
        • [4. 关系运算符](#4. 关系运算符)
        • [5. 逻辑运算符](#5. 逻辑运算符)
        • [6. 赋值运算符](#6. 赋值运算符)
        • [7. 位运算符（了解）](#7. 位运算符（了解）)
        • [8. instanceof 运算符](#8. instanceof 运算符)
        • [9. 运算符总结（常考理解）](#9. 运算符总结（常考理解）)
      • [二、3.2 语句概述（选择题）](#二、3.2 语句概述（选择题）)
      • [三、3.3 if 条件分支语句（必考）](#三、3.3 if 条件分支语句（必考）)
        • [1. if 语句](#1. if 语句)
      • [2. if - else 语句](#2. if - else 语句)
      • [3. if - else if - else 语句](#3. if - else if - else 语句)
      • [四、3.4 switch 开关语句（高频）](#四、3.4 switch 开关语句（高频）)
      • [五、3.5 循环语句（必考）](#五、3.5 循环语句（必考）)
      • [1. for 循环](#1. for 循环)
      • [2. while 循环](#2. while 循环)
      • [3. do - while 循环](#3. do - while 循环)
      • [六、3.6 break 和 continue（常考）](#六、3.6 break 和 continue（常考）)
      • [七、3.7 for 语句与数组（必考）](#七、3.7 for 语句与数组（必考）)
        • [增强 for（for-each）](#增强 for（for-each）)
      • 八、考试速记
    • [第4章 类与对象（重点）](#第4章 类与对象（重点）)
      • [一、4.1 面向对象概述（理解）](#一、4.1 面向对象概述（理解）)
      • [二、4.2 类（必考）](#二、4.2 类（必考）)
        • [1. 类的定义](#1. 类的定义)
        • [2. 成员变量](#2. 成员变量)
        • [3. 方法](#3. 方法)
        • [4. 成员变量 vs 局部变量（高频）](#4. 成员变量 vs 局部变量（高频）)
        • [5. this 关键字（必考）](#5. this 关键字（必考）)
      • [三、4.3 构造方法与对象创建（必考）](#三、4.3 构造方法与对象创建（必考）)
        • [1. 构造方法](#1. 构造方法)
        • [2. 创建对象（两步）](#2. 创建对象（两步）)
        • [3. 对象引用（高频）](#3. 对象引用（高频）)
      • [四、4.4 类与程序结构（理解）](#四、4.4 类与程序结构（理解）)
      • [五、4.5 参数传值（高频）](#五、4.5 参数传值（高频）)
        • [1. 传值机制](#1. 传值机制)
        • [2. 基本类型参数](#2. 基本类型参数)
        • [3. 引用类型参数（易混）](#3. 引用类型参数（易混）)
      • [六、4.6 对象的组合（理解）](#六、4.6 对象的组合（理解）)
      • [七、4.7 实例成员与类成员（必考）](#七、4.7 实例成员与类成员（必考）)
        • [1. 实例变量 vs 类变量](#1. 实例变量 vs 类变量)
        • [2. 实例方法 vs 类方法](#2. 实例方法 vs 类方法)
      • [八、4.8 方法重载（必考）](#八、4.8 方法重载（必考）)
      • [九、4.9 this 关键字（再次强调）](#九、4.9 this 关键字（再次强调）)
      • [十、4.10 包（中频）](#十、4.10 包（中频）)
        • [1. package 语句](#1. package 语句)
        • [2. 目录结构](#2. 目录结构)
      • [十一、4.11 import 语句](#十一、4.11 import 语句)
      • [十二、4.12 访问权限（重点表）](#十二、4.12 访问权限（重点表）)
      • [十三、4.14 对象数组（了解基本内容）](#十三、4.14 对象数组（了解基本内容）)
      • 十四、考试速记
    • [第5章 子类与继承（重点）](#第5章 子类与继承（重点）)
      • [一、5.1 子类与父类](#一、5.1 子类与父类)
        • [1. 子类和父类的关系](#1. 子类和父类的关系)
        • [2. 声明子类](#2. 声明子类)
        • [3. 类的树形结构](#3. 类的树形结构)
      • [二、5.2 子类的继承性](#二、5.2 子类的继承性)
        • [1. 继承父类的成员](#1. 继承父类的成员)
        • [2. 在同一包中的继承性](#2. 在同一包中的继承性)
        • [3. 在不同包中的继承性](#3. 在不同包中的继承性)
      • [三、5.3 子类与对象](#三、5.3 子类与对象)
        • [1. 子类对象的特点](#1. 子类对象的特点)
        • [2. `instanceof` 运算符](#2. instanceof 运算符)
      • [四、5.4 成员变量的隐藏和方法重写](#四、5.4 成员变量的隐藏和方法重写)
        • [1. 成员变量的隐藏](#1. 成员变量的隐藏)
        • [2. 方法重写](#2. 方法重写)
      • [五、5.5 `super` 关键字](#五、5.5 super 关键字)
        • [1. 使用 `super` 调用父类的方法和成员变量](#1. 使用 super 调用父类的方法和成员变量)
        • [2. 使用 `super` 调用父类构造方法](#2. 使用 super 调用父类构造方法)
      • [六、5.6 `final` 关键字](#六、5.6 final 关键字)
        • [1. `final` 修饰类](#1. final 修饰类)
        • [2. `final` 修饰方法](#2. final 修饰方法)
        • [3. 常量](#3. 常量)
      • [七、5.7 对象的上转型](#七、5.7 对象的上转型)
      • [八、5.8 继承与多态](#八、5.8 继承与多态)
      • [九、5.9 `abstract` 类与 `abstract` 方法](#九、5.9 abstract 类与 abstract 方法)
        • [1. `abstract` 类](#1. abstract 类)
        • [2. `abstract` 方法](#2. abstract 方法)
      • [十、5.10 面向抽象编程](#十、5.10 面向抽象编程)
      • [十一、5.11 开-闭原则](#十一、5.11 开-闭原则)
      • 十二、考试速记
    • [第6章 接口与实现（重点）](#第6章 接口与实现（重点）)
      • [一、6.1 接口](#一、6.1 接口)
        • [1. 接口声明与体](#1. 接口声明与体)
        • [2. 接口方法的类型](#2. 接口方法的类型)
      • [二、6.2 实现接口](#二、6.2 实现接口)
        • [1. 类实现接口](#1. 类实现接口)
        • [2. 必须重写接口中的所有方法](#2. 必须重写接口中的所有方法)
      • [三、6.3 接口的UML图](#三、6.3 接口的UML图)
      • [四、6.4 接口回调](#四、6.4 接口回调)
      • [五、6.5 函数接口与Lambda表达式](#五、6.5 函数接口与Lambda表达式)
        • [1. 单方法接口](#1. 单方法接口)
        • [2. Lambda表达式作为回调接口方法](#2. Lambda表达式作为回调接口方法)
      • [六、6.6 理解接口](#六、6.6 理解接口)
      • [七、6.7 接口与多态](#七、6.7 接口与多态)
      • [八、6.8 接口参数](#八、6.8 接口参数)
      • [九、6.9 abstract类与接口的比较](#九、6.9 abstract类与接口的比较)
      • [十、6.10 面向接口编程](#十、6.10 面向接口编程)
      • 十一、考试速记
    • [第7章 内部类与异常类（重点）](#第7章 内部类与异常类（重点）)
      • [一、7.1 内部类](#一、7.1 内部类)
        • [1. 内部类的定义](#1. 内部类的定义)
        • [2. 内部类的应用](#2. 内部类的应用)
      • [二、7.2 匿名类](#二、7.2 匿名类)
        • [1. 子类的匿名类](#1. 子类的匿名类)
        • [2. 接口的匿名类](#2. 接口的匿名类)
      • [三、7.3 异常类](#三、7.3 异常类)
        • [1. 异常的概念](#1. 异常的概念)
        • [2. 异常的类型](#2. 异常的类型)
        • [3. 异常的分类和处理](#3. 异常的分类和处理)
      • [四、7.4 异常处理](#四、7.4 异常处理)
        • [1. 使用 `throw` 抛出异常](#1. 使用 throw 抛出异常)
        • [2. `try-catch` 语句](#2. try-catch 语句)
        • [3. 自定义异常](#3. 自定义异常)
      • [五、7.5 断言](#五、7.5 断言)
        • [1. 断言的作用](#1. 断言的作用)
        • [2. 断言的使用](#2. 断言的使用)
      • 六、考试速记
    • [第8章 常用实用类（重点）](#第8章 常用实用类（重点）)
      • [一、8.1 Object类](#一、8.1 Object类)
        • [1. Object类概述](#1. Object类概述)
        • [2. 常用方法](#2. 常用方法)
      • [二、8.2 String类](#二、8.2 String类)
        • [1. String类的特点](#1. String类的特点)
        • [2. 常用方法](#2. 常用方法)
        • [3. 字符串拼接](#3. 字符串拼接)
      • [三、8.3 StringBuffer和StringBuilder类](#三、8.3 StringBuffer和StringBuilder类)
        • [1. StringBuffer与StringBuilder的区别](#1. StringBuffer与StringBuilder的区别)
        • [2. 常用方法](#2. 常用方法)
      • [四、8.4 Date和Calendar类](#四、8.4 Date和Calendar类)
        • [1. Date类](#1. Date类)
        • [2. Calendar类](#2. Calendar类)
        • [3. 新日期时间API（Java 8及以后）](#3. 新日期时间API（Java 8及以后）)
      • [五、8.5 Math类](#五、8.5 Math类)
        • [1. Math类概述](#1. Math类概述)
      • [六、8.6 Wrapper类](#六、8.6 Wrapper类)
        • [1. 基本类型与包装类](#1. 基本类型与包装类)
        • [2. 常用方法](#2. 常用方法)
      • [七、8.7 Collections类](#七、8.7 Collections类)
        • [1. Collections类概述](#1. Collections类概述)
        • [2. 常用方法](#2. 常用方法)
      • [八、8.8 Arrays类](#八、8.8 Arrays类)
        • [1. Arrays类概述](#1. Arrays类概述)
        • [2. 常用方法](#2. 常用方法)
      • 九、考试速记
    • [第10章 输入流与输出流（重点）](#第10章 输入流与输出流（重点）)
      • [一、10.1 输入流和输出流概述](#一、10.1 输入流和输出流概述)
        • [1. 流的分类](#1. 流的分类)
        • [2. 字节流与字符流](#2. 字节流与字符流)
      • [二、10.2 字节流](#二、10.2 字节流)
        • [1. 输入流](#1. 输入流)
        • [2. 输出流](#2. 输出流)
        • [3. 缓冲流](#3. 缓冲流)
      • [三、10.3 字符流](#三、10.3 字符流)
        • [1. 输入流](#1. 输入流)
        • [2. 输出流](#2. 输出流)
        • [3. 缓冲流](#3. 缓冲流)
      • [四、10.4 转换流](#四、10.4 转换流)
        • [1. 转换字节流和字符流](#1. 转换字节流和字符流)
      • [五、10.5 数据流](#五、10.5 数据流)
        • [1. **DataInputStream** 和 **DataOutputStream**](#1. DataInputStream 和 DataOutputStream)
      • [六、10.6 对象流](#六、10.6 对象流)
        • [1. **ObjectInputStream** 和 **ObjectOutputStream**](#1. ObjectInputStream 和 ObjectOutputStream)
      • [七、10.7 文件操作](#七、10.7 文件操作)
      • [八、10.8 流的关闭](#八、10.8 流的关闭)
      • 九、考试速记
    • [第12章 Java 多线程机制](#第12章 Java 多线程机制)
      • [一、12.1 线程的基本概念](#一、12.1 线程的基本概念)
        • [1. 线程的定义](#1. 线程的定义)
        • [2. 线程的创建](#2. 线程的创建)
        • [3. 线程生命周期](#3. 线程生命周期)
      • [二、12.2 Thread 类与 Runnable 接口](#二、12.2 Thread 类与 Runnable 接口)
        • [1. 使用 `Thread` 类创建线程](#1. 使用 Thread 类创建线程)
        • [2. 使用 `Runnable` 接口创建线程](#2. 使用 Runnable 接口创建线程)
      • [三、12.3 线程的同步](#三、12.3 线程的同步)
        • [1. 为什么需要同步](#1. 为什么需要同步)
        • [2. 同步方法与同步块](#2. 同步方法与同步块)
        • [3. 锁的竞争](#3. 锁的竞争)
      • [四、12.4 线程间通信](#四、12.4 线程间通信)
        • [1. `wait()` 和 `notify()`](#1. wait() 和 notify())
        • [2. 使用 `notifyAll()` 唤醒所有等待线程](#2. 使用 notifyAll() 唤醒所有等待线程)
      • [五、12.5 线程池](#五、12.5 线程池)
        • [1. 线程池的概念](#1. 线程池的概念)
        • [2. 使用 `ExecutorService` 管理线程池](#2. 使用 ExecutorService 管理线程池)
        • [3. 线程池的优势](#3. 线程池的优势)
      • [六、12.6 并发问题与死锁](#六、12.6 并发问题与死锁)
        • [1. 并发问题](#1. 并发问题)
        • [2. 死锁](#2. 死锁)
        • [3. 避免死锁](#3. 避免死锁)
      • [七、12.7 线程的优先级与调度](#七、12.7 线程的优先级与调度)
        • [1. 线程优先级](#1. 线程优先级)
        • [2. 调度策略](#2. 调度策略)
      • [八、12.8 总结与应用](#八、12.8 总结与应用)
      • 九、考试速记
    • [第15章 泛型与集合框架（重点）](#第15章 泛型与集合框架（重点）)
      • [一、15.1 泛型概述](#一、15.1 泛型概述)
        • [1. 泛型的基本概念](#1. 泛型的基本概念)
        • [2. 泛型的优点](#2. 泛型的优点)
      • [二、15.2 泛型的使用](#二、15.2 泛型的使用)
        • [1. 泛型类](#1. 泛型类)
        • [2. 泛型方法](#2. 泛型方法)
        • [3. 类型通配符](#3. 类型通配符)
      • [三、15.3 集合框架概述](#三、15.3 集合框架概述)
        • [1. 集合框架简介](#1. 集合框架简介)
        • [2. 集合框架的设计](#2. 集合框架的设计)
      • [四、15.4 常用集合类](#四、15.4 常用集合类)
        • [1. `List` 接口](#1. List 接口)
        • [2. `Set` 接口](#2. Set 接口)
        • [3. `Queue` 接口](#3. Queue 接口)
        • [4. `Map` 接口](#4. Map 接口)
      • [五、15.5 集合类的操作](#五、15.5 集合类的操作)
        • [1. 常用方法](#1. 常用方法)
        • [2. 遍历集合](#2. 遍历集合)
      • [六、15.6 集合与泛型结合使用](#六、15.6 集合与泛型结合使用)
        • [1. 使用泛型增强集合的类型安全](#1. 使用泛型增强集合的类型安全)
        • [2. 泛型与通配符](#2. 泛型与通配符)
      • 七、考试速记

第1章 Java 概述

一、1.1 了解 Java

1. Java 的诞生与发展
  • 前身：Green Project
  • Java 2 平台：Java SE / Java EE / Java ME

LTS 版本：

  • JDK 8（2014）
  • JDK 11（2018）
  • JDK 17（2021）
  • JDK 21（2023）
  • JDK 25（2025）
2. Java 三大平台
  • Java SE：标准版，基础
  • Java EE：企业级开发
  • Java ME：嵌入式 / 移动平台
3. Java 的特点（重点）
（1）平台无关性

  • 口号：Write once, run anywhere

  • 原理：

    • Java 源程序 → 字节码（.class）
    • JVM 负责执行字节码

  • 对比：

    • C/C++：机器码（依赖平台）
    • Java：字节码（不依赖平台）
（2）完全面向对象与简单性

  • 放弃：指针、goto、宏定义、全局变量、多重继承

  • 采用：

    • 单继承 + 接口
    • 自动垃圾回收
    • 异常处理机制
（3）其他特点
  • 可靠性
  • 安全性
  • 多线程
  • 支持网络与分布式应用

二、1.2 Java 应用及运行方式

1. Application 与 Applet

  • Application

    • 独立运行
    • 有 main 方法

  • Applet

    • 嵌入网页运行
    • 无 main 方法（已淘汰）
2. Java 程序基本结构（重点）
java 复制代码 
public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}
  • main 方法是程序入口
  • 一个 .java 文件可包含多个类
  • 只能有一个 public 类
  • public 类名必须与文件名一致
3. Java 程序运行流程
复制代码 
.java → javac 编译 → .class → JVM 执行
4. 补充

多个文件都有 main 方法：完全没问题

一次运行，只会执行你"指定"的那个 main 方法

JVM 不会自动选，必须你来选

三、1.3 JDK（重点）

1. JVM / JRE / JDK 区别
  • JVM：执行字节码
  • JRE：JVM + 核心类库
  • JDK：JRE + 开发工具

开发用 JDK，运行用 JRE

2. JDK 主要目录
  • bin：开发工具（javac、java）
  • jre：运行环境
  • lib：类库
  • demo / sample：示例
  • include：C 头文件
  • src.zip：Java 核心 API 源码
3. 编译与运行命令
bash 复制代码 
javac Hello.java
java Hello
  • 运行时不写 .class

四、1.4 MyEclipse（理解）

  • Java 集成开发环境

  • 功能：编辑、编译、运行、调试

  • 概念：

    • 工作区（Workspace）
    • 项目（Project）
调试基础
  • 错误类型：语法错、语义错、逻辑错
  • 调试方式：断点、单步执行、查看变量

五、1.5 IntelliJ IDEA（理解）

  • Java 集成开发环境

  • 功能同 MyEclipse

  • 重点：

    • 会创建项目
    • 会运行 Application 程序

六、考试速记

  • Java 特点：平台无关性、面向对象
  • Java 核心：JVM + 字节码
  • 三大平台：SE / EE / ME
  • 程序入口：main 方法
  • 运行流程：javac → java
  • JDK > JRE > JVM

第2章 基本数据类型与数组（重点）

一、2.1 标识符与关键字

1. 标识符

  • 用于命名：类名、变量名、方法名、数组名、文件名

  • 组成：字母、数字、下划线 _、美元符号 $

  • 规则

    • 不能以数字开头
    • 不能是关键字
    • 不能是 true、false、null
    • 长度不限

  • Java 使用 Unicode 字符集（最多 65536 个字符）

2. 关键字
  • Java 中具有固定含义的单词
  • 不能作为标识符使用

二、2.2 基本数据类型（必考）

1. 八种基本数据类型
  • boolean
  • byte
  • short
  • int
  • long
  • float
  • double
  • char
2. 分类
  • 逻辑型：boolean
  • 整数型：byte、short、int、long
  • 字符型：char
  • 浮点型：float、double
3. 各类型要点（常考）
（1）boolean
  • 取值：true / false
（2）整数类型
类型 字节 说明
byte 1 范围小
short 2 中
int 4 默认整数
long 8 常量需加 L
  • long 常量：123L
（3）char
  • 用 单引号
  • 占 2 字节
  • 表示 Unicode 字符
  • 提供转义字符：\n \t \\ \' \"
  • char ↔ int 可相互转换（Unicode 编码）
（4）浮点类型
类型 字节 说明
float 4 常量必须加 f/F
double 8 默认浮点类型
  • float 常量：3.14f
  • double 常量：3.14 或 3.14d

三、2.3 类型级别与类型转换（高频）

1. 精度从低到高
复制代码 
byte → short → char → int → long → float → double
2. 自动类型转换
  • 低级 → 高级（自动）
java 复制代码 
float x = 100;
3. 强制类型转换
  • 高级 → 低级（必须强转）
  • 格式：
java 复制代码 
(类型名) 值
java 复制代码 
int n = (int)34.89;

⚠️ 可能丢失精度

四、2.4 输入与输出（理解 + 会用）

1. 输入（Scanner）
java 复制代码 
Scanner reader = new Scanner(System.in);

常用方法：

  • nextInt()
  • nextDouble()
  • nextFloat()
  • nextBoolean()

📌 输入时会阻塞，等待回车

2. 输出
  • System.out.print()：不换行
  • System.out.println()：换行
  • 字符串拼接：+
java 复制代码 
System.out.println("sum="+sum);
3. 格式化输出（了解）
java 复制代码 
System.out.printf("%d %f %s", a, b, c);
  • %d int
  • %f 浮点
  • %c char
  • %s 字符串

五、2.5 数组（必考）

1. 数组声明
java 复制代码 
int a[];
int[] a;

二维数组：

java 复制代码 
int a[][];
int[][] a;
2. 分配空间
java 复制代码 
a = new int[5];
  • 数组是 引用类型
  • 存储的是首元素地址
3. 数组元素访问
java 复制代码 
a[0]
  • 索引从 0 开始
  • 越界：ArrayIndexOutOfBoundsException
4. length 属性
  • 一维数组：a.length → 元素个数
  • 二维数组：a.length → 行数
5. 数组初始化
java 复制代码 
int a[] = {1,2,3,4};

  • 系统会赋默认值

    • int → 0
    • float → 0.0
    • char → '\u0000'
6. 数组引用（易考）
  • 多个数组变量可指向同一数组
  • 修改一个，其他都会变

六、2.6 应用举例（了解）

折半查找（思想）
  • 前提：数组有序
  • 每次比较中间元素
  • 时间效率高

七、考试速记

  • 8 种基本类型
  • int 默认整数，double 默认浮点
  • float 常量必须加 f
  • char 占 2 字节
  • 自动转换：低 → 高
  • 强制转换：高 → 低
  • 数组下标从 0 开始
  • length 是属性不是方法

第3章 运算符、表达式与语句

一、3.1 运算符与表达式（高频）

1. 算术运算符

  • + - * / %

  • 二目运算符

  • 运算对象：整数或浮点数

  • 优先级：

    • * / % 高于 + -
2. 自增、自减运算符
  • ++ --
  • 单目运算符
  • 操作对象：变量
形式 含义
++x 先自增，再使用
x++ 先使用，再自增
3. 混合运算的精度规则

精度从低到高：

复制代码 
byte → short → char → int → long → float → double

计算规则

  • 有 double → 按 double 计算
  • 否则有 float → 按 float
  • 否则有 long → 按 long
  • 否则 → 按 int
4. 关系运算符
  • > < >= <= == !=
  • 结果类型：boolean

⚠️ 注意：== ≠ =

5. 逻辑运算符

  • &&（逻辑与）

  • ||（逻辑或）

  • !（逻辑非）

  • 操作数：boolean

  • 常用于连接关系表达式

6. 赋值运算符
  • =
  • 左边必须是变量
  • 结合方向：右 → 左
  • 优先级低
7. 位运算符（了解）
  • & 按位与
  • | 按位或
  • ~ 按位非
  • ^ 按位异或

📌 操作数与结果都是 整型

8. instanceof 运算符
  • 用于判断对象类型
  • 结果为 boolean
java 复制代码 
obj instanceof 类名
9. 运算符总结（常考理解）
  • 表达式 = 运算符 + 操作数
  • 优先级决定计算顺序
  • 实际编程/考试建议多用括号

二、3.2 语句概述（选择题）

Java 语句分为 6 类：

  1. 方法调用语句
  2. 表达式语句
  3. 复合语句 { }
  4. 空语句 ;
  5. 控制语句
  6. package / import 语句

三、3.3 if 条件分支语句（必考）

1. if 语句
java 复制代码 
if (表达式) {
    语句;
}

2. if - else 语句

java 复制代码 
if (表达式) {
    语句;
} else {
    语句;
}

3. if - else if - else 语句

java 复制代码 
if (条件1) {
}
else if (条件2) {
}
...
else {
}

📌 从上到下判断，满足一个即结束

四、3.4 switch 开关语句（高频）

java 复制代码 
switch(表达式) {
    case 常量:
        语句;
        break;
    ...
    default:
        语句;
}

要点

  • 单条件多分支
  • case 后只能是 常量
  • break 可省略（但容易贯穿执行）
  • default 可省略

五、3.5 循环语句（必考）

1. for 循环

java 复制代码 
for(初始化; 条件; 更新) {
    循环体;
}

执行顺序：

  1. 初始化
  2. 判断条件
  3. 执行循环体
  4. 更新变量
  5. 重复判断

2. while 循环

java 复制代码 
while(条件) {
    循环体;
}
  • 先判断，再执行
  • 条件为 false，一次都不执行

3. do - while 循环

java 复制代码 
do {
    循环体;
} while(条件);
  • 至少执行一次

六、3.6 break 和 continue（常考）

  • break

    • 结束整个循环

  • continue

    • 结束本次循环，进入下一次

📌 只能用于 循环或 switch 中

七、3.7 for 语句与数组（必考）

增强 for（for-each）
java 复制代码 
for(元素类型 变量 : 数组名) {
    语句;
}

特点

  • 依次取数组每个元素
  • 不能修改数组长度
  • 常用于遍历

八、考试速记

  • * / % 高于 + -
  • ++x 先加后用，x++ 先用后加
  • 比较用 ==，赋值用 =
  • if 从上到下判断
  • switch 记得 break
  • for / while / do-while 区别
  • break 结束循环
  • continue 跳过本次
  • 增强 for 用来遍历数组

第4章 类与对象（重点）

一、4.1 面向对象概述（理解）

面向对象三大特性
  • 封装
  • 继承
  • 多态

二、4.2 类（必考）

1. 类的定义
java 复制代码 
class 类名 {
    成员变量;
    成员方法;
}
  • 类是创建对象的模板
  • 类名是合法标识符（首字母大写，见名知意）
2. 成员变量

  • 定义在类体中

  • 类型：

    • 基本类型
    • 引用类型（对象、数组等）

  • 特点

    • 在整个类中有效
    • 有默认值

  • 编程风格：

    • 一行一个变量
    • 名称清晰
3. 方法
方法结构
java 复制代码 
返回类型 方法名(参数列表) {
    方法体;
}
  • 有返回值 → 指定类型
  • 无返回值 → void
  • 参数、方法内变量 → 局部变量
局部变量特点（必考）
  • 只在方法内有效
  • 没有默认值
  • 使用前必须赋值
4. 成员变量 vs 局部变量（高频）
对比点 成员变量 局部变量
定义位置 类中 方法中
默认值 有 无
作用范围 整个类 方法/代码块
5. this 关键字（必考）

  • 表示 当前对象

  • 用途：

    • 区分成员变量和局部变量

      java 复制代码 
      this.成员变量

  • 不能用于 static 方法

三、4.3 构造方法与对象创建（必考）

1. 构造方法
  • 名字 = 类名
  • 没有返回类型
  • 可以重载
  • 如果未定义 → 系统提供默认无参构造
2. 创建对象（两步）
java 复制代码 
类名 对象名;         // 声明
对象名 = new 类名(); // 创建
  • new：分配内存
  • 每个对象有独立的成员变量
3. 对象引用（高频）
  • 对象变量存的是 引用
  • 两个对象引用相同 → 指向同一实体
java 复制代码 
p1 = p2;

四、4.4 类与程序结构（理解）

  • Java 程序由多个类组成
  • 必须有一个 主类
  • 程序从 main 方法开始执行

五、4.5 参数传值（高频）

1. 传值机制
  • Java 只有传值
  • 传的是"值的拷贝"
2. 基本类型参数
  • 修改方法内参数
  • 不影响原变量
3. 引用类型参数（易混）
  • 传递的是 引用的拷贝
  • 修改对象内容 → 会影响原对象

六、4.6 对象的组合（理解）

  • 一个类的成员变量是另一个类的对象
  • 体现 复用
  • "有一个"的关系

七、4.7 实例成员与类成员（必考）

1. 实例变量 vs 类变量
  • static 修饰 → 类变量
  • 不加 static → 实例变量
对比 实例变量 类变量
属于 对象 类
是否共享 否 是
访问方式 对象名 类名
2. 实例方法 vs 类方法
  • 实例方法：对象调用
  • 类方法（static）：类名调用
  • 类方法不能访问实例变量

八、4.8 方法重载（必考）

方法重载条件

  • 方法名相同

  • 参数列表不同：

    • 个数不同
    • 类型不同

  • 返回类型无关

九、4.9 this 关键字（再次强调）

  • 构造方法中：代表正在创建的对象
  • 实例方法中：代表当前调用方法的对象
  • static 方法中：不能使用 this

十、4.10 包（中频）

1. package 语句
java 复制代码 
package 包名;
  • 必须是源文件第一句
2. 目录结构
  • 包名 = 目录结构
text 复制代码 
tom.jiafei → tom/jiafei

十一、4.11 import 语句

java 复制代码 
import 包名.类名;
import 包名.*;
  • 用于引入其他包中的类

十二、4.12 访问权限（重点表）

修饰符 同类 同包 子类 其他
public ✔ ✔ ✔ ✔
protected ✔ ✔ ✔ ✖
默认 ✔ ✔ ✖ ✖
private ✔ ✖ ✖ ✖

十三、4.14 对象数组（了解基本内容）

java 复制代码 
Student[] stu = new Student[10];

⚠️ 注意

  • 只是创建数组
  • 每个元素仍需 new
java 复制代码 
stu[0] = new Student();

十四、考试速记

  • 类 = 模板，对象 = 实例
  • 成员变量有默认值，局部变量没有
  • 构造方法：无返回类型
  • Java 参数传值（只有值传递）
  • static 属于类，不属于对象
  • 方法重载看参数，不看返回值
  • 对象数组要逐个 new

第5章 子类与继承（重点）

一、5.1 子类与父类

1. 子类和父类的关系
  • 子类通过继承父类，获得父类的属性和行为。
  • 继承是"父类 → 子类"的过程，子类可以有新的属性和方法。
2. 声明子类

  • 使用 extends 关键字：

    java 复制代码 
    class Student extends People {
    // 代码
}
3. 类的树形结构
  • 类按继承关系形成树形结构，根节点是 Object 类。

二、5.2 子类的继承性

1. 继承父类的成员
  • 子类继承父类的非 private 成员变量和方法。
2. 在同一包中的继承性
  • 如果父类和子类在同一个包中，子类继承父类的 protected 和 public 成员。
3. 在不同包中的继承性
  • 如果父类和子类在不同包中，子类可以继承父类的 protected 和 public 成员。

三、5.3 子类与对象

1. 子类对象的特点
  • 子类的构造方法不仅分配子类成员变量内存空间，还会分配父类的成员变量内存空间。
2. instanceof 运算符

  • 用于判断对象是否是某个类或其子类的实例。

    java 复制代码 
    obj instanceof 类名

四、5.4 成员变量的隐藏和方法重写

1. 成员变量的隐藏
  • 如果子类有与父类同名的成员变量，子类会隐藏父类的成员变量。
2. 方法重写

  • 子类重写父类的方法时，方法签名必须相同。目的是改变父类的行为。

    • 注意：重写时不能降低方法的访问权限。

五、5.5 super 关键字

1. 使用 super 调用父类的方法和成员变量
  • 用于访问父类被子类隐藏的成员或方法。
2. 使用 super 调用父类构造方法

  • 子类构造方法需要显式调用父类构造方法，格式：

    java 复制代码 
    super();

六、5.6 final 关键字

1. final 修饰类
  • 被 final 修饰的类不能被继承。
2. final 修饰方法
  • 被 final 修饰的父类方法不能被子类重写。
3. 常量
  • 使用 final 修饰的变量是常量，值不可改变。

七、5.7 对象的上转型

  • 上转型：子类对象可以赋值给父类类型的变量，父类变量只能访问父类的成员，不能访问子类新增的成员。

八、5.8 继承与多态

  • 多态：父类方法被子类重写后，可以根据对象的实际类型调用子类的版本。

九、5.9 abstract 类与 abstract 方法

1. abstract 类
  • abstract 类不能实例化，可以有抽象方法。
2. abstract 方法
  • 抽象方法在父类中声明，在子类中实现。

十、5.10 面向抽象编程

  • 在设计程序时，使用抽象类来定义重要方法，由子类去实现细节。

十一、5.11 开-闭原则

  • 系统应该对扩展开放，对修改关闭。即在不修改现有代码的情况下，可以增加新功能。

十二、考试速记

  • 子类与父类： extends 关键字
  • 成员继承： 继承非 private 成员
  • super 关键字： 访问父类成员和构造方法
  • final 关键字： 修饰类、方法、变量
  • 上转型： 子类对象赋给父类引用
  • 多态： 子类重写父类方法，运行时动态调用
  • abstract 类与方法： 声明方法，子类实现
  • 开-闭原则： 系统对扩展开放，对修改关闭

第6章 接口与实现（重点）

一、6.1 接口

1. 接口声明与体

  • 声明 ：使用 interface 关键字

    java 复制代码 
    interface 接口名 { }

  • 接口体：包括常量和抽象方法

    • 默认常量：final 修饰
    • 默认方法：void add()等
2. 接口方法的类型
  • default 方法（JDK8及之后）：可以提供方法的默认实现
  • static 方法：接口内的静态方法
  • private 方法（JDK9及之后）：接口中的私有方法

二、6.2 实现接口

1. 类实现接口

  • 使用 implements 关键字实现一个或多个接口

    java 复制代码 
    class 子类名 implements 接口名1, 接口名2 { }
2. 必须重写接口中的所有方法

三、6.3 接口的UML图

  • 使用长方形描述接口，分为三层：

    1. 接口名
    2. 常量层
    3. 方法层

四、6.4 接口回调

  • 接口回调：通过接口引用调用实现类的重写方法

    java 复制代码 
    接口类型 obj = new 实现类();
obj.接口方法();

五、6.5 函数接口与Lambda表达式

1. 单方法接口

  • JDK8引入的Lambda表达式用于简化接口方法的实现。

    java 复制代码 
    (参数列表) -> { 方法体 }
2. Lambda表达式作为回调接口方法

六、6.6 理解接口

  • 接口允许定义相同方法名称但不同实现的类，不强迫它们拥有相同的父类。

    • 例子：所有电器产品实现同一接口的 on 方法，但功能行为不同。

七、6.7 接口与多态

  • 接口变量可以回调实现该接口的类的重写方法，形成多态。

八、6.8 接口参数

  • 如果方法参数为接口类型，可以传递任何实现该接口的类的实例引用。

九、6.9 abstract类与接口的比较

  • abstract类 与接口的区别：

    1. abstract类可以有常量和变量，接口只能有常量。
    2. abstract类可以有非抽象方法，接口不可以（JDK8之前）。

十、6.10 面向接口编程

  • 面向接口编程是设计系统时强调接口而非具体类，从而增强系统的可扩展性和灵活性。

十一、考试速记

  • 接口声明 ：使用 interface 关键字
  • 接口实现 ：使用 implements 关键字
  • Lambda：简化接口方法实现，接口只有一个方法时使用
  • 接口与多态：通过接口回调实现不同类方法的调用
  • 面向接口编程：提高程序的可扩展性

第7章 内部类与异常类（重点）

一、7.1 内部类

1. 内部类的定义
  • 在一个类中声明另一个类，称作内部类，包含内部类的类成为外部类。
  • 内部类用于描述特定功能，不希望外部直接使用时，可以作为外部类的内部类。
2. 内部类的应用
  • 在内部类中，可以访问外部类的所有成员，包括私有成员。
  • 内部类可以被视为外部类的一个组成部分。

二、7.2 匿名类

1. 子类的匿名类
  • 匿名类是没有类名的类，可以直接创建子类对象而不需要显式定义子类。
  • 用 new 关键字直接创建匿名类对象，类体去掉类声明部分。
2. 接口的匿名类
  • 匿名类也可以用于接口的实现，类似于子类的匿名类。

三、7.3 异常类

1. 异常的概念

  • 异常是程序运行时可能发生的错误，异常处理改变程序的控制流，允许程序对错误进行处理。

  • 常用方法：

    java 复制代码 
    public String getMessage();
public void printStackTrace();
public String toString();
2. 异常的类型
  • Error：系统内部错误，通常不处理。
  • Exception：程序错误，通常需要捕获和处理。
3. 异常的分类和处理
  • 运行时异常（RuntimeException）：通常是编程错误，如除0、空指针。
  • 必须处理的异常：例如 IOException，需要明确捕获或传递。

四、7.4 异常处理

1. 使用 throw 抛出异常
  • 所有方法使用 throw 抛出异常。
2. try-catch 语句
  • 用于处理异常，将可能发生异常的操作放入 try 块，捕获异常放入 catch 块。
java 复制代码 
try {
    // 可能发生异常的代码
} catch (Exception e) {
    // 异常处理代码
}
3. 自定义异常
  • 可以通过继承 Exception 类创建自定义异常。

五、7.5 断言

1. 断言的作用
  • 用于调试阶段，发现致命错误，运行时可以关闭。
  • 断言格式：
java 复制代码 
assert booleanExpression;
assert booleanExpression : message;
2. 断言的使用
  • 通过断言可以快速定位错误，帮助调试。

六、考试速记

  • 内部类：类中声明另一个类，包含外部类的成员。
  • 匿名类：无类名的子类或接口实现。
  • 异常类 ：Error（内部错误）、Exception（程序错误）。
  • 异常处理 ：使用 try-catch 捕获异常，throw 抛出异常。
  • 断言 ：用于调试，格式 assert booleanExpression。

第8章 常用实用类（重点）

一、8.1 Object类

1. Object类概述
  • 所有类的根类，所有类都直接或间接继承Object类。
  • 提供了基本的操作方法，如 toString()、equals() 和 hashCode() 等。
2. 常用方法
  • toString()：返回对象的字符串表示。
  • equals(Object obj)：比较两个对象的内容是否相等。
  • hashCode()：返回对象的哈希值。

二、8.2 String类

1. String类的特点
  • String是不可变的（immutable），一旦创建就不能修改。
  • 可以通过 + 号进行字符串拼接。
2. 常用方法
  • length()：返回字符串的长度。
  • substring(int beginIndex, int endIndex)：截取字符串。
  • indexOf(String str)：查找子字符串的位置。
  • equals(String anotherString)：比较两个字符串内容是否相等。
3. 字符串拼接
  • 使用 + 拼接字符串，不建议频繁使用，会创建多个中间对象，性能差。
  • 推荐使用 StringBuilder 或 StringBuffer 进行拼接。

三、8.3 StringBuffer和StringBuilder类

1. StringBuffer与StringBuilder的区别
  • StringBuffer：线程安全，但性能较低。
  • StringBuilder：非线程安全，性能较高。
2. 常用方法
  • append()：追加字符串。
  • insert()：在指定位置插入字符串。
  • delete()：删除指定位置的字符。
  • reverse()：反转字符串。

四、8.4 Date和Calendar类

1. Date类

  • 用于表示日期和时间，已被 LocalDate 和 LocalDateTime 等新类取代，但仍可用于老旧代码。

  • 常用方法：

    • getTime()：返回自1970年1月1日以来的毫秒数。
    • toString()：返回日期和时间的字符串表示。
2. Calendar类

  • 用于操作日期和时间。

  • 常用方法：

    • get(int field)：获取指定字段的值。
    • set(int field, int value)：设置指定字段的值。
3. 新日期时间API（Java 8及以后）
  • 使用 LocalDate、LocalTime 和 LocalDateTime 类来处理日期和时间，替代了 Date 和 Calendar 类。

五、8.5 Math类

1. Math类概述

  • 提供了常用的数学运算方法。

  • 常用方法：

    • abs()：返回绝对值。
    • pow(double a, double b)：返回a的b次方。
    • sqrt(double a)：返回a的平方根。
    • random()：返回一个0到1之间的随机数。

六、8.6 Wrapper类

1. 基本类型与包装类
  • 每个基本数据类型都有对应的包装类，如 Integer、Double、Character 等。
  • 包装类提供了基本类型的对象表示，并提供了相关的操作方法。
2. 常用方法
  • parseInt(String s)：将字符串转换为整数。
  • valueOf(String s)：将字符串转换为对应的包装类对象。

七、8.7 Collections类

1. Collections类概述
  • 提供了一些静态方法来操作集合，如排序、查找、反转等。
2. 常用方法
  • sort(List<T> list)：对列表进行排序。
  • reverse(List<?> list)：反转列表。
  • shuffle(List<?> list)：打乱列表顺序。

八、8.8 Arrays类

1. Arrays类概述
  • 提供了一些静态方法来操作数组，如排序、查找等。
2. 常用方法
  • sort(int[] a)：对数组进行排序。
  • binarySearch(int[] a, int key)：在排序数组中查找元素。
  • equals(int[] a, int[] b)：比较两个数组是否相等。

九、考试速记

  • String类 ：不可变，使用+拼接时性能较差，推荐使用StringBuilder。
  • StringBuffer/StringBuilder ：用于高效拼接字符串，StringBuffer线程安全。
  • Date与Calendar ：处理日期和时间，LocalDate等为Java 8的新API。
  • Math类 ：常用数学方法，如sqrt()、random()等。
  • Wrapper类：基本类型的对象表示。
  • Collections类：集合的静态方法，如排序和反转。
  • Arrays类：数组的静态方法，如排序和查找。

第10章 输入流与输出流（重点）

一、10.1 输入流和输出流概述

1. 流的分类
  • 输入流：用于从外部设备读取数据到程序中。
  • 输出流：用于将数据从程序写入外部设备。
2. 字节流与字符流
  • 字节流 ：处理所有类型的I/O操作，使用 InputStream 和 OutputStream。
  • 字符流 ：专门用于处理文本数据，使用 Reader 和 Writer。

二、10.2 字节流

1. 输入流

  • FileInputStream：用于从文件中读取字节数据。

    java 复制代码 
    FileInputStream fis = new FileInputStream("input.txt");
2. 输出流

  • FileOutputStream：用于将字节数据写入文件。

    java 复制代码 
    FileOutputStream fos = new FileOutputStream("output.txt");
3. 缓冲流
  • BufferedInputStream 和 BufferedOutputStream：对字节流进行缓冲，提高读写效率。

三、10.3 字符流

1. 输入流

  • FileReader：用于从文件中读取字符数据。

    java 复制代码 
    FileReader fr = new FileReader("input.txt");
2. 输出流

  • FileWriter：用于将字符数据写入文件。

    java 复制代码 
    FileWriter fw = new FileWriter("output.txt");
3. 缓冲流
  • BufferedReader 和 BufferedWriter：对字符流进行缓冲，提高读写效率。

四、10.4 转换流

1. 转换字节流和字符流
  • InputStreamReader：将字节流转换为字符流。
  • OutputStreamWriter：将字符流转换为字节流。

五、10.5 数据流

1. DataInputStream 和 DataOutputStream

  • 用于读写 Java 原生数据类型。

    java 复制代码 
    DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));

六、10.6 对象流

1. ObjectInputStream 和 ObjectOutputStream

  • 用于读取和写入对象。

    java 复制代码 
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.dat"));
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.dat"));

七、10.7 文件操作

  • RandomAccessFile：可以进行文件的随机访问，可以读取或写入文件的任意位置。

八、10.8 流的关闭

  • 使用 close() 方法关闭流，确保所有数据都已正确写入并释放资源。

九、考试速记

  • 输入流与输出流：字节流与字符流
  • 字节流 ：InputStream / OutputStream
  • 字符流 ：Reader / Writer
  • 转换流 ：InputStreamReader / OutputStreamWriter
  • 缓冲流 ：BufferedInputStream / BufferedReader
  • 数据流 ：DataInputStream / DataOutputStream
  • 对象流 ：ObjectInputStream / ObjectOutputStream
  • 文件操作 ：RandomAccessFile
  • 关闭流 ：close() 方法

第12章 Java 多线程机制

一、12.1 线程的基本概念

1. 线程的定义
  • 线程是程序执行中的最小单位，一个程序可以包含多个线程。
  • 每个线程都由一个执行路径和程序计数器来标识。
2. 线程的创建
  • 线程可以通过实现 Runnable 接口或者继承 Thread 类来创建。
3. 线程生命周期
  • 新建：线程对象被创建，但还未启动。
  • 就绪：线程准备好并等待 CPU 分配时间。
  • 运行：线程获取 CPU 时间并执行任务。
  • 阻塞：线程因某些条件暂时停止执行，待恢复。
  • 死亡：线程任务执行完毕。

二、12.2 Thread 类与 Runnable 接口

1. 使用 Thread 类创建线程
  • 继承 Thread 类并重写 run() 方法。
  • 调用 start() 方法启动线程。
java 复制代码 
class MyThread extends Thread {
    public void run() {
        System.out.println("Thread running");
    }
}

MyThread t = new MyThread();
t.start();
2. 使用 Runnable 接口创建线程
  • 实现 Runnable 接口并重写 run() 方法。
  • 使用 Thread 对象来启动该线程。
java 复制代码 
class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Thread running");
    }
}

Thread t = new Thread(new MyRunnable());
t.start();

三、12.3 线程的同步

1. 为什么需要同步
  • 当多个线程访问共享资源时，可能会出现数据不一致的情况，导致程序错误。
2. 同步方法与同步块
  • 同步方法 ：通过 synchronized 关键字修饰方法，保证同一时刻只有一个线程能执行该方法。
java 复制代码 
synchronized void method() {
    // code
}
  • 同步代码块 ：将需要同步的代码段放入 synchronized 代码块中。
java 复制代码 
synchronized (this) {
    // code
}
3. 锁的竞争
  • 当多个线程争夺同一资源时，会发生锁竞争，可能导致线程阻塞。

四、12.4 线程间通信

1. wait() 和 notify()
  • wait() ：使当前线程进入等待状态，直到其他线程调用该对象的 notify() 或 notifyAll() 方法。
  • notify()：唤醒正在等待的线程。
java 复制代码 
synchronized (this) {
    wait();
    // code
}
2. 使用 notifyAll() 唤醒所有等待线程
  • notifyAll() 唤醒所有等待该对象的线程。

五、12.5 线程池

1. 线程池的概念
  • 线程池通过 Executor 框架来管理线程池中的多个线程，避免了频繁的线程创建与销毁。
2. 使用 ExecutorService 管理线程池
java 复制代码 
ExecutorService executor = Executors.newFixedThreadPool(10);
executor.submit(new RunnableTask());
  • submit() 方法用于提交任务。
3. 线程池的优势
  • 降低了线程创建与销毁的开销。
  • 控制线程数，避免系统资源耗尽。

六、12.6 并发问题与死锁

1. 并发问题
  • 当多个线程同时访问共享资源时，可能会发生竞态条件或数据不一致问题。
2. 死锁
  • 两个或更多的线程互相等待对方释放资源，造成程序无法继续执行。
3. 避免死锁
  • 避免多个线程获取多个锁。
  • 使用定时锁（tryLock）来避免死锁。

七、12.7 线程的优先级与调度

1. 线程优先级
  • 线程优先级用 Thread 类的 setPriority() 方法设置，决定线程的执行顺序。
2. 调度策略
  • Java 的线程调度是抢占式调度，操作系统决定哪个线程运行。

八、12.8 总结与应用

  • Java 提供了强大的线程机制，允许开发者通过多线程来优化程序的性能。
  • 使用多线程时，需要特别注意线程安全问题，合理使用同步机制。

九、考试速记

  • 线程的创建 ：继承 Thread 类或实现 Runnable 接口。
  • 线程同步 ：使用 synchronized 关键字。
  • 线程通信 ：使用 wait() 和 notify()。
  • 线程池 ：使用 ExecutorService 管理线程池。
  • 死锁：避免多线程竞争同一资源。

第15章 泛型与集合框架（重点）

一、15.1 泛型概述

1. 泛型的基本概念
  • 泛型是 Java 中的一种机制，允许在类、接口和方法中使用类型参数化。这样可以在编译时检查类型错误，增强代码的可读性和可维护性。
  • 泛型使得集合类更加通用，且能够提供类型安全。
2. 泛型的优点
  • 类型安全：编译时可以检查类型错误，避免了类型强制转换的风险。
  • 代码复用：泛型类可以处理多种类型的数据。

二、15.2 泛型的使用

1. 泛型类

  • 泛型类是在类定义时通过使用类型参数来定义的。例如，创建一个泛型类 Box，它能存储任何类型的对象：

    java 复制代码 
    class Box<T> {
    private T item;
    public void setItem(T item) {
        this.item = item;
    }
    public T getItem() {
        return item;
    }
}
2. 泛型方法

  • 泛型方法是在方法中使用类型参数，而不必指定类型。例如：

    java 复制代码 
    public static <T> void printArray(T[] array) {
    for (T element : array) {
        System.out.println(element);
    }
}
3. 类型通配符
  • 泛型中可以使用 ? 来表示未知类型，例如：List<?> 表示类型未知的列表。

三、15.3 集合框架概述

1. 集合框架简介
  • 集合框架是 Java 提供的一种用于存储和操作数据对象的结构，包含了多个接口和实现类。
  • 常见的接口包括：List、Set、Queue、Map，它们有不同的实现类。
2. 集合框架的设计
  • 集合框架通过统一的接口和抽象类的设计，增强了代码的灵活性和可扩展性。

四、15.4 常用集合类

1. List 接口

  • List 是一个有序的集合，可以包含重复的元素。常用实现类有 ArrayList、LinkedList。

    • ArrayList：基于动态数组实现，适合随机访问。
    • LinkedList：基于双向链表实现，适合频繁插入和删除。
2. Set 接口

  • Set 是一个不允许重复元素的集合，常用实现类有 HashSet、LinkedHashSet 和 TreeSet。

    • HashSet：基于哈希表实现，元素无顺序。
    • LinkedHashSet：基于链表实现，元素按插入顺序排序。
    • TreeSet：基于红黑树实现，元素自动排序。
3. Queue 接口
  • Queue 是一个先进先出的集合，常用实现类有 PriorityQueue、LinkedList。
4. Map 接口

  • Map 是一个键值对集合，不允许重复的键，常用实现类有 HashMap、TreeMap、LinkedHashMap。

    • HashMap：基于哈希表实现，键值对无顺序。
    • TreeMap：基于红黑树实现，键值对按键排序。
    • LinkedHashMap：基于链表实现，键值对按插入顺序排序。

五、15.5 集合类的操作

1. 常用方法
  • 添加元素 ：add()、put()。
  • 删除元素 ：remove()、clear()。
  • 检查元素 ：contains()、containsKey()、containsValue()。
  • 获取元素 ：get()、getKey()。
  • 迭代 ：iterator()、forEach()。
2. 遍历集合

  • 使用增强型 for 循环遍历集合。

  • 使用迭代器（Iterator）遍历集合。

    java 复制代码 
    Iterator<T> it = list.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

六、15.6 集合与泛型结合使用

1. 使用泛型增强集合的类型安全

  • 泛型与集合框架结合使用，能够在编译时检查类型，避免运行时的类型转换错误。

    java 复制代码 
    List<String> list = new ArrayList<>();
list.add("Hello");
list.add("World");
2. 泛型与通配符

  • 使用通配符 ? 来表示不确定的类型。

    java 复制代码 
    List<?> list = new ArrayList<String>();

七、考试速记

  • 泛型：提高代码的复用性和类型安全性。
  • 集合框架 ：包含 List、Set、Queue、Map 等接口及其实现类。
  • 常用集合 ：ArrayList、HashSet、HashMap。
  • 遍历集合：使用增强型 for 循环或迭代器。
  • 泛型与集合：结合使用，增强类型安全。

希望本篇文章对你有所帮助！并激发你进一步探索编程的兴趣！

本人仅是个C语言初学者，如果你有任何疑问或建议，欢迎随时留言讨论！让我们一起学习，共同进步！

相关推荐
这是程序猿2 小时前
基于java的SpringBoot框架汽车销售系统
java·spring boot·spring·汽车·汽车销售网站
SunnyDays10112 小时前
Java 高效 TXT 转 Word 指南：单文件、批量及格式美化操作
java·txt转word·文本文件转word·文本转word
m0_611349312 小时前
什么是副作用（Side Effects）
开发语言·前端·javascript
不急不躁1232 小时前
Android16 跳过GMS测试项
android·java
oioihoii2 小时前
C++多线程中join与detach机制深度解析
java·jvm·c++
雨中飘荡的记忆2 小时前
深入理解 Guava EventBus：让你的系统解耦更优雅
java·后端
uup2 小时前
方法参数的 “值传递骗局”：修改引用参数为何不改变原对象？
java
TAEHENGV2 小时前
外观设置模块 Cordova 与 OpenHarmony 混合开发实战
java·运维·服务器
妮妮分享2 小时前
维智地图如何集成
开发语言·ios·swift
热门推荐
01GitHub 镜像站点02从快手“12·22”直播攻击事件看：一次教科书式的业务层饱和攻击033D 圣诞树网页代码04UV安装并设置国内源05Linux下V2Ray安装配置指南06Gemini3 生成的基于手势控制3D粒子圣诞树07在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）08解决 WSL Ubuntu 中 /etc/resolv.conf 自动重置问题09开源分享 | 超浪漫 3D 圣诞树立体动画（附零基础使用教程）10GLM-4.7 vs MiniMax-M2.1：代码工程理解