java复习 11

发布于：2025-06-14 ⋅ 阅读:(21) ⋅ 点赞:(0)

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（输出），常用的子类包括：

  1. 文件操作：

    • FileInputStream / FileOutputStream：读写文件内容

  2. 缓冲操作：

    • BufferedInputStream / BufferedOutputStream：带缓冲区的字节流

  3. 数据类型操作：

    • DataInputStream / DataOutputStream：读写基本数据类型

  4. 对象序列化：

    • ObjectInputStream / ObjectOutputStream：读写对象

  5. 内存操作：

    • ByteArrayInputStream / ByteArrayOutputStream：读写字节数组

  6. 管道操作：

    • PipedInputStream / PipedOutputStream：线程间通信

字符流类层次结构

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

  1. 文件操作：

    • FileReader / FileWriter：读写文本文件内容

  2. 缓冲操作：

    • BufferedReader / BufferedWriter：带缓冲区的字符流

  3. 格式化操作：

    • PrintWriter：格式化输出文本

  4. 内存操作：

    • CharArrayReader / CharArrayWriter：读写字符数组
    • StringReader / StringWriter：读写字符串

  5. 转换流：

    • InputStreamReader / OutputStreamWriter：字节流与字符流之间的转换

转换流的重要性

转换流（InputStreamReader和OutputStreamWriter）是连接字节流和字符流的桥梁，它们允许：

  • 将字节流转换为字符流（例如：从文件读取字节并转换为字符）
  • 指定字符编码（如 UTF-8、GBK 等）

字节流与字符流的使用场景

  1. 字节流适合：

    • 处理二进制文件（图片、音频、视频等）
    • 需要直接操作字节数据
    • 不需要字符编码转换

  2. 字符流适合：

    • 处理文本文件
    • 需要进行字符编码转换
    • 处理人类可读的文本数据

 7 在finally块中使用return的做法虽然合法,但在实际编程中应当避免


1. finally块的代码一定会执行
2. 如果finally块中包含return语句,这个return会覆盖try块中的任何return语句
3. 这种在finally块中使用return的做法虽然合法,但在实际编程中应当避免,因为它会导致代码逻辑难以理解和维护。

-----------

哎期末周好想玩游戏啊......我就是这样的人，平时没事干的时候就那么闲着，有事做的时候就很想玩，好想玩啊！

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布