当前位置：首页 > news >正文

java复习 11

news 2025/6/14 6:44:57

1 Java接口的修饰符只能是public或abstract。其中abstract是接口的默认修饰符

1. 接口中的所有方法默认都是public abstract的
2. 接口中的所有属性默认都是public static final的
3. 接口是一种完全抽象的类型,用于定义类需要实现的方法规范
4. Java 8之后接口中可以有默认方法(default)和静态方法(static)的实现

2 泛型的类型擦除机制，依旧可以在运行时动态获取List<T>中T的实际类型？

答案：正常情况下，因泛型类型擦除机制，无法直接在运行时动态获取 List<T> 中 T 的实际类型；但可通过一些 “技巧手段” 间接获取，核心原理与字节码中泛型信息的特殊保留、反射结合处理有关，以下展开理解：

1. 先理解 “类型擦除机制” 的本质

Java 的泛型是 “伪泛型” ，编译时，List<String>、List<Integer> 等泛型声明里的 <T>（比如 String、Integer 这些具体类型参数）会被擦掉。最终字节码中，List<T> 会被处理成原始类型（Raw Type）List ，T 会被替换成 Object（若泛型没限定边界）或限定的边界类型。运行时，JVM 看到的只有原始类型，“天生” 丢失了 T 的具体类型信息 。

2. 常规思路：直接用 `List<T>` 想拿 `T` → 做不到

比如写了 List<String> list = new ArrayList<>(); ，编译后字节码里是 List list = new ArrayList(); ，运行时单纯通过这个 list 对象，没办法直接拿到 T 是 String 。因为类型擦除后，JVM 根本不知道编译前 T 具体是啥，只认 List 原始类型和 Object 相关操作。

3. 特殊手段：间接 “套路” 获取 `T` 的思路

借助子类继承 + 反射：
若定义一个子类 class StringList extends ArrayList<String> {} ，编译时，Java 会把泛型信息（这里 T 是 String ）以 “元数据” 形式（在字节码的 Signature 属性里）保留下来。运行时，通过反射 StringList.class.getGenericSuperclass() 拿到 ParameterizedType ，再调用 getActualTypeArguments() ，就能提取到 T 对应的 String 类型。
原理是：子类继承带泛型的父类时，编译器会把父类的泛型信息 “固化” 到子类的字节码元数据里 ，反射可以读取这些元数据 “反推” 出 T 。
利用 TypeToken 等工具类（如 Guava 库）：
原理类似上面的继承 + 反射，但封装得更易用。比如 TypeToken<List<String>> token = new TypeToken<List<String>>() {}; ，内部也是靠匿名子类继承 TypeToken ，让编译器保留泛型信息，再通过反射解析拿到 T 类型。

4. 总结关键理解

类型擦除机制下，单纯的 List<T> 对象本身，运行时不携带 T 的具体类型信息 ，直接拿不到。
但通过 “让泛型信息以元数据形式被字节码保留（如子类继承场景）” + “反射读取元数据” 的组合玩法，能间接 “恢复” 出 T 的实际类型，本质是利用了 Java 编译时对泛型子类的特殊处理（保留泛型元数据）来 “绕开” 类型擦除的限制。

简单说就是：类型擦除 “擦” 了常规运行时的直接类型信息，但通过子类继承等手段让编译器 “悄悄存下” 泛型元数据，反射又能把这些元数据 “挖出来” ，变相实现运行时获取 T 。

嗯~ o(*￣▽￣*)o！

我们可以通过反射机制在运行时获取泛型类型信息。例如，通过Class类的getGenericSuperclass()或getGenericInterfaces()方法获取泛型父类或接口的类型参数。

Java 的反射机制确实提供了获取泛型类型信息的能力，这正是我在上文提到的 "特殊手段" 之一。通过 getGenericSuperclass() 和 getGenericInterfaces() 方法，我们可以突破类型擦除的限制，在运行时获取泛型参数的具体类型。

关键点解析

1. 类型擦除与元数据保留

类型擦除：编译后，泛型参数 T 会被擦除为原始类型（如 Object），但 泛型的元数据信息 会被保留在字节码中（如 Signature 属性）。
反射获取：通过反射 API 可以读取这些元数据，从而推断出泛型参数的具体类型。

2. 核心 API

getGenericSuperclass()：获取带泛型参数的父类。
getGenericInterfaces()：获取带泛型参数的接口。
ParameterizedType：反射中的类型接口，用于表示泛型类型（如 List<String>）。

3 输入流

BufferedWriter是字符输出流，用于缓冲字符输出；
FileInputStream是字节输入流；
ObjectInputStream是对象输入流，用于对象的反序列化；
InputStreamReader是将字节输入流转换为字符输入流，属于面向字符的输入流。

4 构造方法的修饰符

Java 中的构造方法（Constructor）可以使用修饰符来控制其访问权限和行为。构造方法的修饰符主要分为两类：

访问修饰符

public：任何类都可以访问
protected：同一包内的类和不同包的子类可以访问
private：只有类内部可以访问
默认（无修饰符）：只有同一包内的类可以访问

非访问修饰符

static：静态构造方法（Java 中不直接支持，但可以通过静态代码块实现）
final：构造方法不能被重写（但构造方法本身不能被继承，所以这个修饰符对构造方法无实际意义）
synchronized：同步构造方法（不推荐使用，可能导致死锁）

public class ConstructorDemo {// 私有构造方法（单例模式常用）private ConstructorDemo() {System.out.println("私有构造方法被调用");}// 默认访问修饰符（包内可见）ConstructorDemo(String message) {System.out.println("默认构造方法被调用: " + message);}// 受保护的构造方法（包内和子类可见）protected ConstructorDemo(int value) {System.out.println("受保护的构造方法被调用: " + value);}// 公共构造方法（全局可见）public ConstructorDemo(boolean flag) {System.out.println("公共构造方法被调用: " + flag);}// 静态代码块（模拟静态构造方法）static {System.out.println("静态代码块执行（类加载时）");}// 构造方法不能使用abstract修饰符// abstract ConstructorDemo() {} // 编译错误// 构造方法不能使用final修饰符（无意义）// final ConstructorDemo() {} // 编译错误// 构造方法不能使用static修饰符（但可以有静态代码块）// static ConstructorDemo() {} // 编译错误// 同步构造方法（不推荐）public synchronized ConstructorDemo(double num) {System.out.println("同步构造方法被调用: " + num);}// 示例用法public static void main(String[] args) {// 注意：这里只能调用public构造方法// 其他构造方法需要在同一包内或子类中调用ConstructorDemo demo = new ConstructorDemo(true);}
}

5 String类的replace()方法

String str = "hello";
str.replace('h', 'H');
System.out.println(str);

String类的replace()方法会返回一个新的字符串对象，而不会修改原有字符串的内容。这是因为String类的对象是不可变的(immutable)。

在这段代码中:
1. str.replace('h', 'H') 确实会执行替换操作，但是返回的新字符串并没有被赋值给任何变量
2. 原始的str变量依然指向原来的"hello"字符串
3. 所以最终打印str的值时，输出的还是原始的"hello"

分析其他选项:
B错误:虽然replace()方法确实会将'h'替换为'H'，但因为没有接收返回值，所以str的值不会变成"Hello"
C错误:replace()方法不会将所有字符都转换为大写，且原字符串内容也不会改变
D错误:代码可以正常运行，不会出现运行错误

要想实现字符串的替换效果，正确的写法应该是:
str = str.replace('h', 'H');
这样才能将替换后的新字符串赋值给str变量。

6 Java 中面向字节和字符的流类区分

（字节流是Stream~~字符流是Reader Writer！）

在 Java 的 IO 体系中，流分为两类：面向字节的流和面向字符的流。它们的主要区别在于处理的数据单位不同：

字节流：处理 8 位字节数据（byte），适合处理二进制数据（如图片、音频、视频等）
字符流：处理 16 位 Unicode 字符数据（char），适合处理文本数据

字节流类层次结构

字节流的基类是InputStream（输入）和OutputStream（输出），常用的子类包括：

文件操作：
- FileInputStream / FileOutputStream：读写文件内容
缓冲操作：
- BufferedInputStream / BufferedOutputStream：带缓冲区的字节流
数据类型操作：
- DataInputStream / DataOutputStream：读写基本数据类型
对象序列化：
- ObjectInputStream / ObjectOutputStream：读写对象
内存操作：
- ByteArrayInputStream / ByteArrayOutputStream：读写字节数组
管道操作：
- PipedInputStream / PipedOutputStream：线程间通信

字符流类层次结构

字符流的基类是Reader（输入）和Writer（输出），常用的子类包括：

文件操作：
- FileReader / FileWriter：读写文本文件内容
缓冲操作：
- BufferedReader / BufferedWriter：带缓冲区的字符流
格式化操作：
- PrintWriter：格式化输出文本
内存操作：
- CharArrayReader / CharArrayWriter：读写字符数组
- StringReader / StringWriter：读写字符串
转换流：
- InputStreamReader / OutputStreamWriter：字节流与字符流之间的转换