2.1 JDK#

1. JDK 目录组成：
   • bin JDK 命令程序
   • conf Java 系统配置文件
   • include 本地开发与C语言相关头文件
   • jmods 预编译的 Java 模块
   • legal 协议
   • lib Java 类库
2. JDK 命令程序组成：
   • javac.exe Java 编译器 ( *.java → *.class )
   • java.exe Java 解释器 (*.class , *.java )
   • javadoc.exe 根据程序注释生成帮助文档的实用程序
   • javap.exe Java 反编译器 ( *.class → *.java )
   • jdb.exe Java 调式器
   • jar.exe 生成 .jar 文件
   • jmod.exe 生成 .jmod 文件
3. 环境变量
   • Java_Home JDK Path
   • ClassPath JVM 搜索类文件的路径 : %Java_Home%\lib
   • Path 环境变量: %Java_Home\bin

2.2 JDK 帮助文档下载与安装#

2.3 JDK 的使用#

3.1 数据类型#

1. 分类：基本类型（基本不可再分的类型，在内存存放的是数值本身）、引用类型（由多个基本类型组成，在内存存放的是数据地址。又称复合类型或指针）

2. 基本类型分布：

   • 整数型: byte, short, int, long
   • 浮点型: float, double
   • 布尔型: boolean
   • 字符型: char

   类型	占用字节
   boolean	1
   byte	1
   char	2
   short	2
   int	4
   long	8
   float	4
   doule	8

3.2 关键字与标识符#

1. 标识符可以由：字母、数字（不能作为开头）、下划线和美元符号$组成

3.3 常量#

1. 定义常量: 使用 final 关键字，类常量（在类而不是具体实例中共享）则使用 static final
2. 字面量数值类型(literal): 整型常量( 100 , 长整型: 100L )、浮点型常量( 3.14 , 长浮点型 3.14F )

3.4 变量#

3.5 数据类型的转换#

1. 类别: 自动类型转换、强制类型转换
2. 自动类型转换关系: byte → short → char → int → long → float → double
3. 字符串转换为数据类型: <Type>.parse<Type>(String s) (eg. Byte.parseByte(String s) )

3.6 局部变量的类型推断#

1. 局部变量类型推断: var name = value ，如 var a = 21.0f 将被推断为 float 型

3.7 从键盘上输入数据#

1
BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
2
String str = buf.readLine();  // throws IOException
3
char c = (char)buf.read();

1
Scanner reader = new Scanner(System.in);
2
if(reader.hasNextDouble()){
3
    double num = reader.nextDouble();
4
}
5
String str = reader.nextLine();  // catch white space character: ' ', '\t', '\f', '\r', '\n'
6
String str2 = reader.next(); // auto remove white space character before input valid data, exit only after input valid data

3.8 运算符和表达式#

1. 除零错误: 当且仅当运算数都是整数时。

   1
   5/0    // Error
   2
   5.1/0  // Infinity
   3
   -5.1/0 // -Infinity
   4
   5.1%0  // NaN
   

2. 一元运算符只能用于简单变量（如 ++(x+1) 是错误的）

3. 等于运算符 == : 如果两个操作数都是数值变量，就算类型不同，只要值相等，运算结果就相等 (a == 97)。由于精度问题，不能直接比较浮点数，通常取一个较小的误差值求差判断浮点数之间是否相等

4. 简洁运算符( && ) 可短路；非简洁运算符( & ) 必须完整计算

5. 异或: 异值就是 true, 非异就 false

6. 条件运算符: condition?true_value:false_value

4.1 语句和复合语句#

4.2 顺序结构#

4.3 分支结构#

1. switch 语句

   1
   switch(condition){  // condition support: byte, short, int, char, String, enum
   2
       case value1:
   3
           ...  // do somethings.
   4
           break;
   5
       case value2:
   6
           ...  // do somethings.
   7
           break;
   8
       default:
   9
           ...  // do somethings.
   10
   }
   

4.4 循环语句#

1. while / do while 语句

   1
   while(condition){
   2
       ... // do somethings.
   3
   }
   4
   
   5
   do{
   6
       ... // do somethings.
   7
   }while(condition); // cannot ignore ";"
   

4.5 循环中的跳转语句#

4.6 递归#

1. 定义: 直接调用或间接调用自身的方法。
2. 内存存储: 当方法调用自身时，在栈内存为新的局部变量和参数分配空间，并且使用这些新变量从头开始执行方法的代码。当每次递归调用返回时，将旧的局部变量和参数从栈中移出，并将执行控制恢复到方法内部的调用点。
3. 特点：
   1. 递归方法中要有分支语句引导不同的情况
   2. 递归方法必须要有一个或多个终止条件用来停止递归
   3. 每次递归调用都会简化基础问题，直到变成基础情况为止

5.1 数组#

1. 内存管理：

   1. 栈内存：基本类型的变量和对象的引用变量
   2. 堆内存：由 new 运算符创建的数组和对象
   3. 空引用型常量: null 表示该引用变量不指向任何对象

2. 一维数组的定义:

   1
   type[] name;  // declare a array
   2
   name = new type[count];  // allocate memory for a array
   3
   
   4
   // as same as:
   5
   type[] name = new type[count];
   6
   
   7
   // use var
   8
   var array = new type[count];   // true
   9
   var[] array = new type[count]; // false
   10
   
   11
   // assignment init
   12
   type[] name = {value1, value2, ...};
   

3. java.util.Arrays 常用函数：

   • int binarySearch(Array, value) 在 Array 中搜索 value 并返回索引，不存在返回 -1
   • void sort(Array, <fromIndex>, <toIndex>) 字面意思
   • Type[] copyOf(Array, newLength) 字面意思
   • boolean equals(Array1, Array2) 字面意思

4. foreach 循环

   1
   for(type element: array){
   2
       System.out.println(element);
   3
       ...
   4
     }
   

5. 声明二维数组

   1
   type[][] name;
   2
   name = new type[x][y];  // x↓ y→
   3
   
   4
   // as same as:
   5
   type[][] name = new type[x][y];
   6
   
   7
   // Irregular array
   8
   type[][] name = new type[x][];
   9
   name[0][] = new int[a];
   10
   name[1][] = new int[b];
   11
   ...
   12
   name[n][] = null;
   13
   
   14
   // assignment init
   15
   type[][] name = {
   16
       {value1, value2, ...},
   17
       {valuea, valueb, ...},
   18
       ...
   19
   }
   

5.2 字符串#

1. 声明 String 变量（创建之后不可变）

   1
   String str;
   2
   str = new String("value");
   3
   
   4
   // as same as:
   5
   String str = new String("value");
   6
   
   7
   // as same as:
   8
   String str = "value";
   9
   
   10
   // calc
   11
   str = str + "1"  // not same memory, old was thrown.
   

2. java.lang.String 常用方法：

   • int length()
   • boolean equals(Object)
   • boolean equalsIgnoreCase(String)
   • String substring(beginIndex, <endIndex>)
   • char charAt(index)
   • void getChars(srcBegin, srcEnd, char[] dst, dstBegin) 将字符串索引 srcBegin 到 srcEnd 之间的字符放入到字符数组 dst 的索引 dstBegin 后
   • int indexOf(String/char)
   • int lastIndexOf(String/char)
   • boolean startsWith(String)
   • boolean endsWith(String)
   • int compareTo(String)
   • int compareToIgnoreCase(String)
   • String replace(oldString, newString)
   • boolean matches(regex) 匹配正则表达式
   • String trim() 去除首尾空格
   • String[] split(regex, limit=0) 字面意思。当 limit<=0 时，字符串被尽可能分割，但当 limit=0 时，会自动去除尾部空白字符
   • String toLowerCase()
   • String toUpperCase()

3. 声明 StringBuffer 变量（创建之后可变，可自动增长）

   1
   StringBuffer strBuf = new StringBuffer()
   2
   // equal to
   3
   StringBuffer strBuf = new StringBuffer(16) // length: 16
   4
   
   5
   StringBuffer strBuf = new StringBuffer(String)
   

4. java.lang.StringBuffer 常用方法：

   • int capacity() 获取容量
   • void ensureCapacity(capacity) 设置容量
   • StringBuffer append(strBuf)
   • StringBuffer insert(offset, str)
   • StringBuffer delete(start, end)
   • StringBuffer deleteCharAt(index)
   • StringBuffer reverse()
   • String substring(start, end)

5.3 正则表达式#

1. 元字符

1. java.util.regex.Pattern 常用函数:

   • Pattern compile(regex, <int flags>) 编译表达式， flags 作为匹配模式，其取值是 Pattern 类中定义的常量
   • Matcher matcher(input) 创建 Matcher 对象
   • String pattern() 返回表达式的字符串表示形式，即 compile(regex) 中的 regex
   • String toString() 返回表达式的字符串表示形式
   • String[] split(input, limit=0)
   • String quote(String) 返回只匹配该字符串的表达式

2. java.util.regex.Matcher 常用函数:

   • boolean matches() 是否完全匹配
   • boolean find(<startIndex>) 逐一匹配，可重复调用
   • String group() 返回匹配到的字符串
   • boolean lookingAt() 在前面的字符串进行匹配
   • int start() 返回匹配字符串的首索引
   • int end() 返回匹配字符串的尾索引
   • String replaceAll(String)
   • String replaceFirst(String)

3. 用例

   1
   String email = "i@snowy.moe"
   2
   Pattern pa = Pattern.compile("^\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$")
   3
   Matcher ma = pa.matcher(email)
   4
   System.out.println(ma.matches())  // true
   

6.1 类的基本概念#

1. 类与对象的差别

   项目	类（Class）	对象（Object）
   定义	类是对一类事物的抽象，是对象的模板或蓝图。	对象是类的一个实例，是真实存在的个体。
   作用	描述对象的属性（字段）和行为（方法）。	实际执行操作，代表某一个具体的事物。

6.2 定义类#

1. 类修饰符

   修饰符	含义
   public	可被任意对象访问的公共类
   abstract	抽象类
   final	不能被继承的最终类
   无	只能在当前包中被访问的类

2. 成员变量修饰符

   修饰符	含义
   public	可被任意对象访问的公共变量
   private	只允许自身访问
   protected	只允许自身和子类访问
   无	包内可访问
   final	常量
   static	共享变量
   transient	保留变量，暂无特别作用
   volatile	可多线程同时控制的变量

3. 成员方法修饰符

   修饰符	含义
   public	可被任意对象访问的公共方法
   private	只允许自身访问
   protected	只允许自身和子类访问
   无	包内可访问
   final	最终方法，不可修改
   static	静态方法，无需初始化实例即可调用
   abstract	抽象方法，子类必须实现
   synchronized	同步方法，在多线程中对同步资源加锁
   native	本地方法，方法体是用其他语言在外部编写的

6.3 类的 UML 图#

1. 访问权限表示: + pubic - private ## protected
2. 关系：
   1. 类的关联: A —> B ，表示 A 中的成员变量引用了 B
   2. 类的依赖: A - - > B，表示 A 中的方法操作了 B

6.4 对象的创建和引用#

1. this 显式引用当前对象的成员； super 引用父类对象成员

6.5 参数的传递#

1. 可变长度参数

   1
   public static void display(String str, String...args){
   2
       System.out.println(str);
   3
       for(String arg:args){
   4
           System.out.println(arg);
   5
       }
   6
   }
   7
   
   8
   public static void main(String[] args){
   9
       display("Hello");
   10
       display("Hello", "world");
   11
       display("Hello", "world", "!");
   12
       ...
   13
   }
   

6.6 匿名对象#

7.1 类的私有成员与公共成员#

7.2 方法的重载#

1
(public) (void) setValue(){ // 仅靠参数列表判断重载
2
    this.value = 0;
3
}
4

5
(public) (void) setValue(int value){
6
    this.value = value;
7
}
8

9
// Error:
10
public void setValue(int value1, double value2);
11
public void setValue(double value1, int value2);

*重写父类方法或实现接口中的方法时需要使用 @Override

7.3 构造方法#

1. 特点

   1. 构造方法的方法名与类名相同
   2. 构造方法没有返回值，也不能用 void 作为无返回值类型（其本质是返回自身）
   3. 不能显式调用，而只能使用 new 间接调用
   4. 如果不显式声明构造方法，则编译器会自动生成一个无参构造方法。当声明了一个有参构造方法当没有声明无参构造方法时，编译会不通过。

2. 实例：

   1
   public class Coordinate{
   2
       int x;
   3
       int y;
   4
   
   5
       public Coordinate(){  // 当标识为 private 时无法在外部完成初始化
   6
           this(0, 0);  // place it first when use this.
   7
           // x = 0;
   8
           // y = 0;
   9
       }
   10
   
   11
       public Corrdinate(int x, int y){
   12
           this.x = x;
   13
           this.y = y;
   14
       }
   15
   }
   

7.4 静态成员#

1. 静态变量: 在每个类实例都互相共享的变量
2. 静态方法: 属于类的静态方法而不是某个具体对象，不能使用 super 或 this
3. 主方法的定义: public 确保可在类外调用； static 确保可在不初始化类时调用
4. 静态初始化器: static {...} 在类被加载进内存时使用，只调用一次

7.5 对象的应用#

1. 对象的比较: class1 == class2 表示两个引用变量所指向的实例地址相同； class1.equals(class2) 通过父类 Object.equals 判断是否相同，默认行为为 ==

7.6 基本类型与包装类类型之间的自动转换#

1. 将基本类型封装到包装类:

   1
   Integer iOb = Integer.valueOf(100);
   2
   int value = iOb.intValue();
   3
   
   4
   // auto(un)boxing:
   5
   Integer iOb = 100;
   6
   int value = iOb;
   

7.7 Java 语言的垃圾回收机制#

1. 通过引用计算器判断是否进行垃圾回收。增加一次引用就加1，减少一次就减1，当引用数为0时可以在某时进行垃圾回收。

8.1 类的继承#

1. 子类的创建

   1
   class SubClass extends SuperClass{
   2
       public SubClass(){  // 严格意义上，构造方法是不能被继承的。且父类的无参构造方法会在子类中被默认调用
   3
         // super()  // 自动初始化，除非显式调用了 super
   4
         ...
   5
       }
   6
   }
   

2. 子类的覆盖

   1
   public class Coordinate{
   2
       protected int x;  // public or protected,
   3
       protected int y;  // not private.
   4
   
   5
       ...
   6
   
   7
       public void show(){
   8
           System.out.println(x);
   9
           System.out.println(y);
   10
       }
   11
   }
   12
   
   13
   class MyCoordinate extends Coordinate{
   14
       ...
   15
       @overriding
   16
       public void show(){  // 子类中不能覆盖 final 和 static 方法
   17
         System.out.printf("x=%d, y=%d", x, y);
   18
         // super.show();
   19
       }
   20
   }
   

3. Object 类常用方法:

   • boolean equals(obj) 相当于 == 运算符。在字符串中由于存在一个字符串池，初始化时先去字符串池中寻找是否有值相同字符串，如果有就返回，所以即使初始化的时机不同，只要值相同，就为 true
   • String toString()
   • final Class getClass() 返回对象所属的类
   • Object clone()

4. instanceof

   相当于 Python 中的 isinstance ，用法： value instanceof class

8.2 抽象类#

1. 声明:

   1
   abstract class Obj{  // 无法用 new 初始化
   2
     protected Type value;
   3
     ...
   4
     abstract Type func(...); // 抽象方法没有方法体
   5
   }
   

8.3 接口#

1. 声明:

   1
   [public] interface Obj [extends PObj1, PObj2, ...]{
   2
       [public static final] Type NAME = VALUE;
   3
       ...
   4
       [public abstract] Type func(para, ...);
   5
       ...
   6
       private Type privateFunc(para, ...){
   7
         ...
   8
       }
   9
       ...
   10
       public static Type staticFunc(para, ..){
   11
         ...
   12
       }
   13
       public default Type defaultFunc(para, ...){
   14
         ...
   15
       }
   16
   }
   

2. 实现接口:

   1
   class MyObj implements Obj, Obj2, ...{
   2
     ...
   3
   }
   

3. 解决父接口冲突:

   默认方法（使用 default 并给出具体实现的方法）优先，其次是子接口优先。

   1
   interface A {
   2
       default void greet() {
   3
           System.out.println("Hello from A");
   4
       }
   5
   }
   6
   
   7
   interface B {
   8
       default void greet() {
   9
           System.out.println("Hello from B");
   10
       }
   11
   }
   12
   
   13
   class MyClass implements A, B {
   14
       // ❌ 编译错误：greet() 有冲突，必须手动解决
   15
   
   16
       @Override
   17
       public void greet() {
   18
           // ✅ 显式指定要调用哪个接口的默认方法
   19
           A.super.greet(); // or B.super.greet();
   20
       }
   21
   }
   

4. 接口与抽象类：

   特性/区别	抽象类 (abstract class)	接口 (interface)
   是否可以有方法实现	✅ 可以有方法实现	✅ 从 Java 8 开始可以有 default 和 static 方法
   是否可以有成员变量	✅ 可以有实例变量（包括 private, protected）	⛔ 只能有 public static final 常量（即常量）
   构造函数	✅ 可以有构造函数	⛔ 不能有构造函数
   多继承	⛔ 只能单继承	✅ 支持多接口实现
   访问修饰符	✅ 可以使用 private, protected 等	✅ 接口方法默认是 public
   继承/实现关键字	extends	implements
   使用目的	表示“某一类事物的通用特性”	表示“某种能力或行为”
   默认方法	⛔ 没有（除非是普通方法）	✅ default 方法（Java 8+）
   是否可被实例化	⛔ 不能	⛔ 不能

8.4 枚举#

1. 定义:

   1
   [public] enum Enum{NAME1(VALUE1), NAME2(VALUE2), NAME(VALUE3);}
   

2. 实例:

   1
   public enum Color {
   2
       RED("红色"),
   3
       GREEN("绿色"),
   4
       BLUE("蓝色");
   5
   
   6
       private String description;
   7
   
   8
       private Color(String description) {
   9
           this.description = description;
   10
       }
   11
   
   12
       public String getDescription() {
   13
           return description;
   14
       }
   15
   }
   16
   
   17
   Color c = Color.RED;
   18
   System.out.println(c.getDescription()); // 输出：红色
   

3. 特性:

   1. 枚举是一个类，但它不能再被继承
   2. 枚举常量本质是枚举类型的实例对象，每个枚举值都相当于 public static final 的对象
   3. 枚举可以添加字段、构造方法和方法，但构造方法必须是私有的

4. java.lang.annotation.ElementType （枚举类）常用方法:

   • enumtype[] values() 返回枚举类型的数组
   • enumtype valueOf(name) 返回名称为 name 的枚举成员

5. java.lang.Enum<E> （枚举成员）常用方法:

   • int compareTo(E member) 枚举成员间的比较
   • String name() 返回枚举常量名，即定义时的标识符（不可重写）
   • int ordinal() 返回枚举成员序号
   • boolean equals(Object other) 比较两个枚举引用的对象是否相等
   • String toString() 默认返回常量名，与 name() 相同

8.5 包#

1. 包声明: package com.company.package 。其值与文件夹的次序一致。Java 将在环境变量 ClassPath 中寻找这些包

2. 当缺失包声明时，Java 会默认将其放入到默认包中，容易发生命名空间问题

3. Java 常用包：

   • java.lang 语言包。包含各种类，如 Object 和 String
   • java.io 输入输出流包
   • java.util 实用包
   • java.net 网络功能包
   • java.sql 数据库连接包
   • java.text 文本包

4. Java 常用类：

   • java.util.Date 描述时间和日期
   • java.util.Calendar 描述日期时间，适用于将日期值分解的情况
   • java.util.Random 随机类
   • java.lang.Math 数学类
   • java.text.DecimalFormat 格式化十进制数字类

5. 导入包: import com.company.package;

   或者使用外部包时指定全称: class myDate extends java.util.Date

9.1 异常处理的基本概念#

9.2 异常处理类#

1. 异常类的层次结构

   

   在异常的上层有一个 java.lang.Throwable 对象，派生了 Error 和 Exception 两个类。拥有常用方法：

   • getMessage()
   • toString() return: "ExpectionName: getMessage()"
   • printStackTrace()
   • StackTraceElement[] getStrackTrace()

   其中 Error 为系统保留，代表内部系统错误， Exception 由应用程序使用，可以由以下方法构建：

   1
   public Exception(<String message>)
   

2. 受检异常：

   • 是 Java 中强制编译器检查的异常。
   • 它们都直接或间接继承自 java.lang.Exception，但不包括 RuntimeException 及其子类。
   • 示例包括：
     • IOException
     • SQLException
     • FileNotFoundException
     • ClassNotFoundException
     • etc.

9.3 异常的处理#

1. 捕获异常

   1
   try{
   2
       ...
   3
   }catch(Exception1 | Exception2 e){
   4
       ...
   5
   }finally{
   6
     ...
   7
   }
   

9.4 抛出异常#

1. 抛出异常

   1
   public func() throws Exception1, Exception2, ...{  // 声明函数可能会抛出的异常
   2
       throw new Exception();
   3
   }
   

9.5 多重捕获异常#

9.6 自动关闭资源的 try 语句#

1. try-with-resources 语句：

   1
   public func() throws IoException{
   2
       try(Scanner in = new Scanner(System.in)){   // try() 中的资源会自动释放
   3
           ...                              // 前提是该资源继承于 java.lang.AutoCloseable
   4
       }                                    // AutoCloseable.close()
   5
   }
   

9.7 自定义异常类#

1. 继承 Exception 类

   1
   class MyException extends Exception{
   2
       String message;
   3
   
   4
       MyException(String m){
   5
           message = m;
   6
       }
   7
   
   8
       public String toString(){
   9
           return message;
   10
       }
   11
   }
   

10.1 Java 语言的输入输出#

1. Java 输入输出基本类（抽象类）
   • 输入流
     • 字节流: InputStream
     • 字符流: Reader
   • 输出流
     • 字节流: OutputStream
     • 字符流: Writer

10.2 使用 InputStream 和 OutputStream 类#

1. InputStream 类常用方法:

   • int read() 读入一字节的二进制数据，并与八个全为零的高位字节组合成16位的整形量返回（byte 最大值为 128 而不是 256）。-1 表示当前位置没有数据
   • int read(byte[] b, <int off=0> <int len=1>) 读取 len 长度的字节并放入到 b 列表中，从索引 off 开始存放，返回读取到的字节数
   • int available() 返回剩余可读取到的字节数
   • long skip(long n) 让位置指针向后跳过 n 字节
   • mark(int readlimit) 在当前位置做一个标记，并在读取超过 readlimit 后失效
   • reset() 让位置指针回到标记位置
   • close()

2. OutputStream 类常用方法:

   • write(int b) 将 b 中的低位字节写入输出流
   • write(byte[] b, <int off> <int len>)
   • flush() 强制清空缓存区并执行写操作。写入流是先存放到缓冲区再当一定数量时再写入外设上的。
   • close()

3. FileInputStream 类构造方法: FileInputStream(String name | File file | FileDescriptor fdObj)

4. FileOutputStream 类构造方法: FileOutputStream(String name, <Boolean append> | File file | FileDescriptor fdObj)

5. 顺序输入流 SequenceInputStream ，可将多个数据流合并为单一的输入数据流。

   构造方法:

   SequenceInputStream(InputStream s1, s2 | Enumeration<? extends InputStream> e)

6. 管道输入输出流 PipedInputStream PipedOutputStream ， 可将一个程序或线程的输出连接到另外一个程序或线程作为输入

   构造方法:

   • PipedInputStream(<PipedOutputStream src>, <int pipeSize>)
   • PipedOutputStream(<PipedInputStream snk>)

   常用特殊方法:

   • PipedInputStream.connect(PipedOutputStream src)
   • PipedOutputStream.connect(PipedInputStream snk)

10.3 使用 Reader 和 Writer 类#

1. 过滤输入输出流 FilterInputStream FilterOutputStream ，分别实现了在数据的读、写操作的同时进行数据处理

   构造方法:

   • DataInputStream(InputStream in)
   • DataOutputStream(OutputStream out)

   常用特殊方法:

   • public boolean readBoolean()
   • public byte readByte()
   • public char readChar()
   • public short readShort()
   • public int readInt()
   • public float readFloat()
   • public long readLong()
   • public double readDouble()

   ---

   • public void writeBoolean(boolean v)
   • public void writeByte(int v)
   • public void writeChar(int v)
   • public void writeShort(int v)
   • public void writeInt(int v)
   • public void writeFloat(float v)
   • public void writeLong(long v)
   • public void writeDouble(double v)
   • int size() 返回写入的字节数

2. Reader 类（抽象类）的常用方法

   • public int read() 从输入流中读一个字符
   • public int read(char[], <int off=0>, <int len>)
   • public int read(char[])
   • public long skip(long n)
   • public boolean ready() 判断流是否做好读的准备
   • public void mark(int readAheadLimit)
   • public boolean markSupported() 测试输入流是否支持 mark
   • public void reset()
   • public void close()

3. Writer 类（抽象类）的常用方法

   • public void write(int c)
   • public void write(String str)
   • public void write(char[] cbuf, int off, int len)
   • public void flush()
   • public void close()
   • public Writer append(char c | CharSequence csq, <int start>, <int end>)

11.1 泛型#

1. 实质: 将数据类型参数化，通过为类、接口及方法设置类型参数来定义泛型

2. 命名规范:

   类型参数	含义
   T	Type（类型）
   E	Element（集合元素）
   K	Key（键）
   V	Value（值）
   N	Number（数字）

1
public static <T extends Number> double sum(T[] numbers) {
2
    double total = 0;
3
    for (T num : numbers) {
4
        total += num.doubleValue();
5
    }
6
    return total;
7
}

1
<T extends Comparable & Serializable>

1
public static void printBox(Box<?> box) {
2
    System.out.println(box.getItem());
3
}

1
List<? extends Number> numbers = new ArrayList<Integer>();

1
List<? super Integer> list = new ArrayList<Number>();

11.2 容器类#

1. 定义: 容器类是 Java 以类库形式供用户开发程序时可直接使用的各种数据结构

12.1 内部类与匿名内部类#

1. 内部类：

   1. 定义：定义在类中的类

   2. 示例：

      1
      public class Outer {
      2
          private String msg = "I am Outer Class";
      3
      
      4
          // 成员内部类
      5
          class Inner {
      6
              private String msg = "I am Inner Class";
      7
              void display() {
      8
                  System.out.println(this.msg);
      9
                  System.out.println(Outer.this.msg); // 可以访问外部类的私有变量
      10
              }
      11
          }
      12
      
      13
          public static void main(String[] args) {
      14
              Outer outer = new Outer();
      15
              Outer.Inner inner = outer.new Inner(); // 创建内部类对象，必须依附于外部类的实例
      16
              inner.display();
      17
          }
      18
      }
      

2. 静态内部类：

1
public class Outer {
2
    private static String msg = "Static Inner Class";
3

4
    static class StaticInner {
5
        void display() {
6
            System.out.println(msg); // 只能访问外部类的静态成员
7
        }
8
    }
9

10
    public static void main(String[] args) {
11
        StaticInner inner = new StaticInner(); // 不需要外部类实例
12
        inner.display();
13
    }
14
}

1. 局部内部类：

   1
   public class Outer {
   2
       void outerMethod() {
   3
           String msg = "Local Inner Class";
   4
   
   5
           class LocalInner {
   6
               void display() {
   7
                   System.out.println(msg);
   8
               }
   9
           }
   10
   
   11
           LocalInner localInner = new LocalInner();
   12
           localInner.display();
   13
       }
   14
   
   15
       public static void main(String[] args) {
   16
           Outer outer = new Outer();
   17
           outer.outerMethod();
   18
       }
   19
   }
   

2. 匿名内部类：

   1. 定义：没有名字的内部类，通常用于简化实现接口或抽象类的子类 ，常用于事件监听、线程等场景。

   2. 语法：

      1
      new 父类构造器(参数列表) 或 接口名() {
      2
          // 类体
      3
      }
      

   3. 基于抽象类的匿名内部类：

      1
      abstract class Animal {
      2
          abstract void speak();
      3
      }
      4
      
      5
      public class AnonymousExample {
      6
          public static void main(String[] args) {
      7
              // 匿名内部类继承抽象类
      8
              Animal animal = new Animal() {
      9
                  @Override
      10
                  void speak() {
      11
                      System.out.println("Animal speaks!");
      12
                  }
      13
              };
      14
      
      15
              animal.speak();
      16
          }
      17
      }
      

12.2 函数式接口与 Lambda 表达式#

1. 函数式接口（单抽象方法接口）：

   1. 定义：只包含一个抽象方法的接口，可以使用注解 @FunctionalInterface 来明确声明该接口是一个函数式接口（非强制，但推荐使用）。

   2. 示例：

      1
      @FunctionalInterface
      2
      public interface MyFunctionalInterface {
      3
          void doSomething(); // 唯一的抽象方法
      4
      
      5
          default void defaultMethod() {
      6
              System.out.println("Default method");
      7
          }
      8
      
      9
          static void staticMethod() {
      10
              System.out.println("Static method");
      11
          }
      12
      }
      

2. Lambda 表达式

   1. 定义：Lambda 表达式是一个匿名函数 ，可以把它理解为一段没有类名、方法名的代码块，可以作为参数传递给方法或赋值给变量。它可以简化对函数式接口的实现

   2. 语法：

      1
      (parameters) -> { statements; }
      

   3. 示例：

      1
      interface MathOperation {
      2
          int operate(int a, int b);
      3
      }
      4
      
      5
      public class LambdaExample {
      6
          public static void main(String[] args) {
      7
              MathOperation add = (a, b) -> a + b;
      8
              MathOperation multiply = (a, b) -> a * b;
      9
      
      10
              System.out.println(add.operate(3, 4));      // 输出 7
      11
              System.out.println(multiply.operate(3, 4)); // 输出 12
      12
          }
      13
      }
      

   4. Lambda 表达式结合内置函数式接口使用:

      1. Consumer<T>：消费型接口:

         1
         List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
         2
         
         3
         names.forEach(name -> System.out.println("Name: " + name));
         

         等价于：

         1
         names.forEach(new Consumer<String>() {
         2
             @Override
         3
             public void accept(String name) {
         4
                 System.out.println("Name: " + name);
         5
             }
         6
         });
         

      2. Predicate<T>：判断型接口

         1
         List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
         2
         
         3
         numbers.stream()
         4
                .filter(n -> n % 2 == 0)
         5
                .forEach(System.out::println); // 输出 2 和 4
         

      3. Function<T, R>：转换型接口

         1
         List<String> words = Arrays.asList("apple", "banana", "cherry");
         2
         
         3
         List<Integer> lengths = words.stream()
         4
                                      .map(word -> word.length())
         5
                                      .toList();
         6
         
         7
         System.out.println(lengths); // 输出 [5, 6, 6]
         

3. 方法引用：

   1. 定义：Lambda 表达式还可以进一步简化为方法引用 ，适用于已有方法满足需求的情况。

   2. 语法：

      • 类名::静态方法
      • 对象::实例方法
      • 类名::实例方法

   3. 示例：

      1
      List<String> list = Arrays.asList("a", "b", "c");
      2
      
      3
      // 使用 Lambda
      4
      list.forEach(item -> System.out.println(item));
      5
      
      6
      // 使用方法引用
      7
      list.forEach(System.out::println);
      

第一章 Java 语言概述#

1. 什么是平台无关性、编译与解释并存， Java是如何实现“一次编写，到处运行”？

   平台无关性：程序可以在任何支持Java虚拟机（JVM）的设备上运行，无需修改代码。

   编译与解释并存：Java源代码先被编译成字节码（.class文件），然后由JVM在目标平台上解释执行。

   由于字节码是与平台无关的中间代码，只要设备安装了相应的JVM，就能运行Java程序，从而实现“一次编写，到处运行”。

2. 面向对象的基本特征。

• 封装 ：将数据和行为包装在类中，对外隐藏实现细节，只暴露必要的接口。
• 继承 ：子类可以继承父类的属性和方法，实现代码复用和层次关系表达。
• 多态 ：同一接口可有多种实现方式，通常通过方法重写（运行时多态）体现。
• 抽象 ：提取关键特征，忽略复杂实现，帮助构建更清晰的逻辑模型。

1. 什么是Java虚拟机？什么是字节码，以及字节码的好处？

   Java虚拟机：运行Java程序的虚拟计算机，它负责加载、验证和执行字节码。

   字节码：Java源代码经编译后生成的中间代码（.class文件），不是机器码，而是针对JVM设计的指令集。

   好处：

   • 平台无关性 ：一次编译，可在任何有JVM的设备上运行；
   • 安全性高 ：JVM可对字节码进行安全检查；
   • 执行效率较高 ：相比纯解释型语言，字节码更接近机器码，可通过即时编译优化性能。

第二章 Java语言开发环境#

1. JDK环境的配置

   1. 下载安装JDK ：从Oracle官网或OpenJDK发行版下载适合操作系统的JDK安装包并安装。
   2. 设置环境变量 ：
      • JAVA_HOME ：指向JDK的安装目录，例如 C:\Program Files\Java\jdk-17。
      • PATH ：将 %JAVA_HOME%\bin（Windows）或 \$JAVA_HOME/bin（Linux/macOS）添加到系统路径，以便在命令行中使用 java、javac 等命令。
   3. 验证安装 ：打开终端或命令行，输入 java -version 和 javac -version，查看是否显示正确的版本信息。

2. Path和ClassPath的作用

   • Path ：是操作系统级别的环境变量，用于告诉系统在哪些目录中查找可执行命令（如 java、javac）。配置了 Path 后，可以在任意路径下运行 Java 工具。
   • ClassPath ：是 Java 运行环境用来查找用户定义的类（.class 文件）的路径。它告诉 JVM 在哪里寻找要加载的类文件，可以是当前目录、JAR 包或指定的文件夹。可通过 cp 或 CLASSPATH 环境变量设置。

3. Java应用程序主方法的特点及其作用

   • 方法签名固定 ：必须为 public static void main(String[] args)。
     • public：确保JVM可以访问该方法。
     • static：无需创建对象即可调用。
     • void：主方法没有返回值。
     • String[] args：用于接收运行时传入的参数。
   • 作用 ：
     • 是 Java 程序执行的起点。
     • 可以通过命令行传递参数（如 java MyApp arg1 arg2），供程序使用。

   每个可独立运行的 Java 类都必须包含一个主方法。

第三章 Java语言基础#

1. 基本数据类型有哪些？

   1. 整型 ：
      • byte：1 字节（-128 ~ 127）
      • short：2 字节
      • int：4 字节（默认）
      • long：8 字节（需加 L，如 100L）
   2. 浮点型 ：
      • float：4 字节（需加 F，如 3.14F）
      • double：8 字节（默认）
   3. 字符型 ：
      • char：2 字节（表示 Unicode 字符，如 'A'）
   4. 布尔型 ：
      • boolean：仅能存 true 或 false（大小由 JVM 决定）

2. 什么是引用数据类型？

   引用数据类型 是指在 Java 中，变量存储的是对象（或数组）的引用地址，而不是实际的数据值。

   特点：

   • 引用变量指向堆内存中对象的实际位置。
   • 多个引用变量可以指向同一个对象。
   • 操作引用类型时，实际上是通过引用来操作对象。

3. Java 标识符的命名规则是什么？

   1. 只能包含字母、数字、下划线（_）和美元符号（$） 。
   2. 不能以数字开头 。例如：1name 是非法的。
   3. 不能是 Java 的关键字或保留字 。如 int、class、if 等。
   4. 区分大小写 ：age 和 Age 是两个不同的标识符。
   5. 没有长度限制 ，但应保持简洁有意义。

4. Java语言是如何声明常量？

   通过 final 关键字来声明，表示其值在整个程序运行期间不能被修改。

5. 如何将字符串数据类型转换为数值型数据？如何将数值型数据转换为字符串类型？

   转换方向	方法示例
   String → int	Integer.parseInt(str)
   String → double	Double.parseDouble(str)
   int → String	String.valueOf(num)或num + ""

第四章 流程控制#

1. Java中的三种注释方式

   注释类型	符号	用途
   单行注释	//	注释一行内容
   多行注释	/* ... */	注释多行内容
   文档注释	/** ... */	生成API文档，通常用于类、方法、变量上方

2. break和continue的含义和区别

   特点	break	continue
   作用	立即终止整个循环	跳过当前循环体，进入下一轮
   执行后	继续执行循环之后的代码	开始下一次循环
   常见用途	提前退出循环或匹配到结果时	跳过某些不需要处理的情况

第五章 数组与字符串#

1. 数组的基本概念

   数组（Array） 是一种 有序、固定长度 的数据结构，用于存储 相同类型 的多个数据项。数组中的每个数据项称为一个 元素 ，通过 索引（下标） 来访问。

2. Java语言的栈内存和堆内存各自的特点。

   特性	栈内存（Stack）	堆内存（Heap）
   存储内容	基本类型变量、对象引用	对象实例（包括数组）
   生命周期	方法调用开始 → 方法结束	对象不再被引用时被 GC 回收
   访问速度	快	较慢
   是否共享	线程私有	所有线程共享
   内存管理方式	自动分配和释放	由垃圾回收机制自动管理

3. 什么是引用变量？

   引用变量 是一种用于指向（引用）堆内存中对象 的变量。它并不直接存储对象本身，而是存储该对象在堆内存中的地址。

4. String和StringBuffer的区别

   类型	是否可变	说明
   String	❌ 不可变	每次对字符串做修改都会生成新的对象，原对象不变。
   StringBuffer	✅ 可变	在原有对象基础上进行修改，不会产生新对象。

5. “==”和equals有什么区别？

   比较方式	基本类型	引用类型（默认）	引用类型（重写后，如 String）
   ==	比较值	比较引用地址	比较引用地址
   equals	无（仅用于对象）	比较引用地址（默认）	比较内容（常用方式）

第六章 类与对象#

1. 面向对象程序设计的基本思想是什么？什么是类？什么是对象？类和对象有怎样的关系？

   基本思想：将现实世界中的事物抽象为“对象” ，通过封装、继承、多态等机制，使程序更贴近人类的思维方式，提高代码的可重用性、可维护性和扩展性。

   什么是类：对一类具有相同特征和行为的对象的模板或蓝图

   什么是对象：类的一个具体实例，是一个真实存在的个体

   类与对象的关系：

   比较项	类（Class）	对象（Object）
   类型	抽象的概念模板	具体的实例
   存在形式	只有一个模板	可以有多个实例
   关系	类是对象的类型	对象是类的实例化结果

2. 成员变量与局部变量有哪些区别？

   特征	成员变量	局部变量
   定义位置	类中、方法外	方法或代码块内
   生命周期	对象存在即存在	方法调用期间存在
   访问权限	可设置访问修饰符	不可设置访问修饰符
   默认值	有	无（必须显式赋值）
   内存位置	堆内存	栈内存
   是否可以重名	可以，优先访问局部变量

3. 各种类型的默认初始值。

   数据类型	默认初始值	示例（成员变量）
   byte	0	byte b; // 0
   short	0	short s; // 0
   int	0	int i; // 0
   long	0L	long l; // 0L
   float	0.0f	float f; // 0.0f
   double	0.0d	double d; // 0.0d
   char	\u0000（空字符）	char c; // '\u0000'
   boolean	false	boolean flag; // false
   引用类型（如**String**、数组、对象等）	null	String str; // null

   成员变量有默认初始值，引用类型默认为 null；局部变量没有默认值，必须手动初始化后才能使用。

第七章 Java语言类的特征#

1. 私有成员（private）、公共成员（public）、保护成员（protected）、缺省访问控制符各自的访问权限是什么？

   访问修饰符	同一个类中	同一个包中	子类（不同包）	其他包
   private	✅	❌	❌	❌
   缺省（默认）	✅	✅	❌	❌
   protected	✅	✅	✅（通过继承）	❌
   public	✅	✅	✅	✅

2. 什么是方法的重载，即方法的重载条件是什么？会判断哪些是合法的重载形式。

   方法重载 是指在同一个类中，允许存在多个同名方法 ，但它们的 参数列表不同（参数个数、参数类型或参数顺序不同） 。

   判断是否为合法重载的关键点：#

   判断项	是否影响重载
   方法名	必须相同
   参数个数	✅ 影响
   参数类型	✅ 影响
   参数顺序	✅ 影响
   返回值类型	❌ 不影响
   访问修饰符	❌ 不影响
   异常声明	❌ 不影响

3. 什么是构造方法？构造方法有哪些特征？何时被调用？什么是默认构造方法？何时被调用

   构造方法是一种特殊的方法，用于在创建对象时对对象进行初始化操作。

   构造方法的特征

   特征	说明
   方法名必须与类名相同	如：Person()
   没有返回值类型	连**void**也不能写
   可以重载	一个类中可以有多个构造方法（参数不同）
   不能被继承、不能被覆盖（不能**override**）	子类可以调用父类构造方法（通过**super()**）
   可以有访问修饰符	如**public、private**等

   构造方法在使用 new 关键字创建对象时自动调用 。

   如果一个类没有显式定义任何构造方法 ，Java 编译器会自动为该类生成一个无参构造方法 ，称为默认构造方法 。

4. 什么是静态成员（类成员）？什么是实例成员？使用静态成员有什么意义？静态成员的访问格式是什么？main方法为何是public， static的呢

   什么是静态成员（类成员）？什么是实例成员？

   类型	静态成员（类成员）	实例成员（对象成员）
   定义方式	使用**static**关键字修饰	不使用**static**
   所属对象	属于类本身	属于类的每一个具体对象
   内存分配	只分配一次，独立于对象	每创建一个对象就分配一次
   访问权限	可通过类名或对象访问	必须通过对象访问

   使用静态成员有什么意义？

   1. 共享数据 ：多个对象共享同一个静态变量。
   2. 无需创建对象即可访问 ：适合工具类、常量定义等场景。
   3. 节省内存资源 ：只存储一份，避免重复占用。
   4. 作为程序入口点 ：如 main 方法必须是 public static。

   静态成员的访问格式

   • 推荐写法 （清晰明确）：类名.静态成员;
   • 也可以用对象访问 （不推荐）：对象名.静态成员;

   为什么 main 方法是 public static 的？

   1. public：

   • 表示该方法对外公开，JVM 可以从外部访问它。

   2. static：

   • 表示这是一个类方法 ，不需要创建对象就可以调用。
   • JVM 在启动时还没有创建任何对象，所以必须通过 static 方法来执行程序入口。

   如果 main 方法不是 static，JVM 就无法在没有对象的情况下调用它，导致程序无法运行。

第八章 继承、抽象类和接口#

1. 在子类中如何访问父类的成员？用父类的对象（名）访问子类的成员，只限什么情况才行？

   在子类中可以直接访问父类的可访问成员，或通过 super 显式调用；而用父类引用访问子类成员时，只能访问父类中定义的内容 ，若要访问子类特有成员，必须进行 向下转型 。

2. 什么是方法的覆盖？方法的覆盖与方法的重载有何区别？

   方法重载是在同一个类中方法名相同、参数不同的一组方法；方法覆盖是在子类中对父类方法进行重新实现，用于多态。

3. 什么是抽象类和抽象方法?抽象类有哪些特征？

   抽象类 是使用 abstract 关键字修饰的类，它不能被实例化（不能用 new 创建对象），通常用于作为其他类的父类。

   抽象类的特征：

   特征	说明
   使用**abstract**修饰	public abstract class Animal{}
   不能创建对象	不能通过**new**实例化
   可以包含抽象方法	也可以不包含（即全是具体方法）
   可以包含具体方法	和普通类一样，可以有实现的方法
   可以有构造方法	用于子类调用（通过**super()**）
   可以有成员变量和成员方法	支持各种访问控制符
   支持继承	子类必须实现所有抽象方法或本身也是抽象类
   与接口的区别	抽象类支持构造方法、成员变量、非抽象方法等

4. 接口的定义？接口与抽象类有何区别？

   接口 是一种特殊的“抽象类”，它只包含常量和抽象方法 （Java 8 之前），用于定义一组行为规范。从 Java 8 开始，接口支持默认方法和静态方法。

   接口与抽象类的区别

   比较项	接口（Interface）	抽象类（Abstract Class）
   定义关键字	interface	abstract class
   方法实现	可全为抽象（也可有默认/静态方法）	可以有具体方法
   成员变量	默认**public static final**	可以是普通变量
   构造方法	❌ 没有构造方法	✅ 有构造方法
   继承关系	类可以实现多个接口	类只能继承一个抽象类
   访问权限	方法默认**public**	成员可使用各种访问修饰符
   多继承支持	✅ 支持	❌ 不支持
   设计目的	行为规范（“能做什么”）	状态 + 行为模板（“是什么”）
   Java版本限制	Java 1.0 起	Java 1.0 起

5. Java8以后，接口中增加的static方法和default方法各自的含义、作用和使用？

   默认方法：

   定义：

   默认方法是使用 default 关键字修饰的方法，有方法体 ，提供一个默认实现。 子类可以选择重写或直接使用这个默认实现。

   作用：

   向后兼容 ：为已有的接口添加新方法时，不会破坏现有实现类。 共享默认行为 ：多个实现类可以共用一套默认逻辑。 支持多继承行为 ：一个类可以实现多个接口并继承它们的默认方法。

   静态方法：

   定义：

   接口中的静态方法类似于类的静态方法，可以直接通过接口名调用 ，不能被实现类继承或重写。

   作用：

   封装工具方法 ：可以将一些通用的辅助方法放在接口中。 明确归属 ：方法属于接口本身，而不是其实现类。 代码组织更清晰 ：接口不仅定义行为规范，也可以提供实用方法。

6. 如何理解Java的多态性？

   Java 的多态性是指在继承关系中，通过方法重写和向上转型，使父类引用可以指向不同子类对象，并在运行时自动调用对应的方法，从而实现“一个接口，多种行为”的机制。

第九章 异常处理#

1. 什么是异常？按照错误的性质将错误如何分类及其含义？

   异常（Exception） 是指程序在运行过程中发生的、打断正常流程的错误或意外情况。

   按照错误的性质，Java 中的错误主要分为以下三类：

   1. 语法错误（Compile-time Error）
      • 含义：代码不符合 Java 语法规则，在编译阶段就会被发现。
      • 示例：缺少分号、拼写错误、类型不匹配等。
      • 处理方式：必须在编译前修正，否则无法生成字节码。
   2. 运行时错误（Runtime Error）
      • 含义：程序在运行过程中出现的错误，通常由意外情况引起，编译时不会被检测到。
      • 示例：除以零、空指针访问、数组越界等。
      • 处理方式：通过异常处理机制（如 try-catch）捕获和处理。
   3. 逻辑错误（Logical Error）
      • 含义：程序语法正确，也能正常运行，但结果不符合预期。
      • 示例：条件判断写错、变量使用错误等。
      • 处理方式：需通过调试查找并修正逻辑问题。

2. 简述Java的异常处理机制？

   Java 的异常处理机制是一种结构化、统一的错误处理方式 ，通过 try-catch-finally 和 throws/throw 语句来管理和响应运行时错误。

   核心组成： try 块 ：用于包裹可能抛出异常的代码。 catch 块 ：捕获并处理 try 块中发生的异常。 finally 块 ：无论是否发生异常，都会执行，通常用于释放资源（如关闭文件或网络连接）。 throw ：手动抛出一个异常对象。 throws ：在方法声明中指明该方法可能抛出的异常，调用者需处理。

3. 什么是抛出异常和捕获异常？

   • 抛出异常 是产生并传递异常的过程；
   • 捕获异常 是对异常进行处理的过程；

第十一章 泛型和容器#

1. 泛型的实质是什么？使用泛型有什么好处？

   泛型的实质 是参数化类型，即在定义类、接口或方法时，不指定具体的类型，而是使用一个类型参数（如 T），在使用时再指定具体类型。

   使用泛型的好处：

   1. 类型安全 ：编译器在编译时进行类型检查，避免运行时因类型不匹配导致错误。
   2. 代码复用 ：一套逻辑可以适用于多种数据类型，减少重复代码。
   3. 去除强制类型转换 ：使用泛型后，集合或类中存储的对象无需再手动强转为目标类型。
   4. 提高可读性和维护性 ：类型信息明确，使代码更清晰易懂，易于维护。

2. 使用通配符的目的？

   使用通配符（?）的目的 是为了增强泛型的灵活性，特别是在不确定具体类型参数 或需要处理多种类型参数的场景下。

3. 什么是容器类？Java容器框架主要包含哪两个接口？

   容器类（Container Class） 是用于存储和管理其他对象 的类，本质上是用来组织数据的集合。在 Java 中，容器类主要指的是 Java 集合框架（Java Collection Framework） 中的类。

   Java 容器框架 的核心接口是：java.util.Collection java.util.Map

4. 链表类和数组列表类均为List的实现类，各自有什么特点和适用于哪类问题？

   特性	ArrayList	LinkedList
   底层结构	动态数组	双向链表
   访问速度	快（O(1)）	慢（O(n)）
   插入/删除速度	慢（O(n)）	快（O(1)）
   内存占用	较小	较大（节点开销）
   适用场景	多查询、少增删	多增删、实现数据结构

5. 什么叫做遍历（迭代）？

   遍历 就是“一个一个地访问集合中的元素”，是集合操作中最基本、最常用的操作之一。不同的遍历方式适用于不同的场景，选择合适的方式可以提升代码可读性和性能。

6. 哈希集合类与树集合类主要有什么区别？分别适用于哪类问题？

   特性	HashSet	TreeSet
   底层结构	哈希表	红黑树
   元素顺序	无序（插入顺序不保留）	有序（默认升序）
   插入/查找效率	O(1)	O(log n)
   是否允许 null	是（仅一个）	否
   是否支持排序	否	是
   主要用途	快速去重、高效查找	有序集合、范围查询、排序需求

7. 哈希映射和树映射主要有些什么区别？分别适用于哪类问题？

   特性	HashMap	TreeMap
   底层结构	哈希表	红黑树
   键的顺序	无序	按键排序（升序）
   插入/查找效率	O(1)	O(log n)
   是否允许 null 键	是（仅一个）	否
   是否支持排序	否	是
   主要用途	快速查找、缓存、去重	排序输出、区间查询、有序访问

第十二章 内部类、匿名内部类和函数式接口#

1. 内部类概念、定义及使用？内部类的主要作用是什么？

   概念：指定义在另一个类内部的类。它是 Java 中面向对象特性的一部分，用于更灵活地组织代码结构。

   定义：

   1
   public class OuterClass {
   2
       // 外部类成员
   3
   
   4
       // 内部类定义
   5
       public class InnerClass {
   6
           // 内部类成员
   7
       }
   8
   }
   

   使用：

   1
   public class Outer {
   2
       private String msg = "Hello Inner Class";
   3
   
   4
       public class Inner {
   5
           void print() {
   6
               System.out.println(msg); // 可以访问外部类的成员
   7
           }
   8
       }
   9
   
   10
       public static void main(String[] args) {
   11
           Outer outer = new Outer();
   12
           Outer.Inner inner = outer.new Inner();
   13
           inner.print(); // 输出：Hello Inner Class
   14
       }
   15
   }
   

   作用：

   1. 实现更好的封装性：
      • 内部类可以访问外部类的所有成员（包括私有成员），适合用于逻辑紧密相关的类之间。
   2. 提高代码可读性和维护性：
      • 将逻辑相关的类组织在一起，使结构更清晰、模块化更强。
   3. 实现多重继承的效果：
      • 一个类可以继承一个类并同时拥有多个内部类实现不同的接口，增强灵活性。
   4. 简化代码，特别是匿名内部类：
      • 常用于监听器、线程任务等场景，例如图形界面或多线程编程中简化回调逻辑。

2. 匿名内部类的概念、定义及使用。

   概念：没有显式名称的内部类，通常在创建对象的同时直接定义类并实例化。 它适用于只需要使用一次的类，比如事件监听、线程任务等。

   定义：

   1
   new 父类构造器参数或接口() {
   2
       // 类体（重写方法、定义变量等）
   3
   };
   

   使用：

   1
   // 定义一个接口
   2
   interface OnClickListener {
   3
       void onClick();
   4
   }
   5
   
   6
   public class Button {
   7
       public void setOnClickListener(OnClickListener listener) {
   8
           listener.onClick();
   9
       }
   10
   
   11
       public static void main(String[] args) {
   12
           Button button = new Button();
   13
   
   14
           // 使用匿名内部类实现接口
   15
           button.setOnClickListener(new OnClickListener() {
   16
               @Override
   17
               public void onClick() {
   18
                   System.out.println("按钮被点击了！");
   19
               }
   20
           });
   21
       }
   22
   }
   

3. 什么是函数式接口？什么是注解？

   函数式接口：只有一个抽象方法 的接口，可以有默认方法和静态方法。

   注解：注解是一种元数据（Metadata） ，它为程序元素（如类、方法、变量等）提供附加信息，并不会直接影响程序逻辑，但可以被编译器、框架或工具读取和处理。