【JAVA基础】什么是泛型? 什么是反射?

什么是泛型?

一 , 泛型 (Generics) 概述

泛型是Java编程语言的一项重要特性，它允许在定义类、接口和方法时使用类型参数。通过泛型，可以编写更加通用和类型安全的代码，避免了类型转换的繁琐和潜在的类型错误。

二 , 泛型的主要功能

1. 类型安全

   • 泛型确保编译时的类型安全，避免了运行时的类型转换错误。

2. 代码复用

   • 通过泛型，可以编写通用的类和方法，减少重复代码。

3. 消除类型转换

   • 使用泛型后，编译器会自动进行类型转换，提高了代码的可读性和安全性。

三 , 泛型的基本概念

1. 类型参数
   • 在定义类、接口或方法时使用的占位符，表示具体的类型。
   • 例如：List<T> 中的 T 就是一个类型参数。
2. 类型参数的限定
   • 可以对类型参数进行限定，指定它可以接受的类型范围。
   • 例如：List<? extends Number> 表示列表中的元素必须是 Number 或其子类。
3. 泛型类
   • 带有类型参数的类。
   • 例如：class Box<T> { ... }
4. 泛型接口
   • 带有类型参数的接口。
   • 例如：interface List<T> { ... }
5. 泛型方法
   • 带有类型参数的方法。
   • 例如：<T> T getFirst(List<T> list) { ... }

四 , 泛型的使用场景

1. 集合类
   • 泛型最常用在集合类中，如 List<T>、Set<T> 和 Map<K, V> 等。
   • 例如：List<String> 表示一个存储字符串的列表。
2. 自定义类和接口
   • 可以在自定义类和接口中使用泛型，使其更加通用。
   • 例如：class Pair<K, V> { ... }
3. 方法参数和返回值
   • 方法可以使用泛型参数和返回值，提高方法的通用性。
   • 例如：<T> T findFirst(List<T> list) { ... }

五 , 泛型的基本步骤

1. 定义泛型类或接口
   • 在类或接口的声明中添加类型参数。
   • 例如：class Box<T> { ... }
2. 使用泛型类或接口
   • 在实例化类或实现接口时指定具体的类型参数。
   • 例如：Box<String> box = new Box<>();
3. 定义泛型方法
   • 在方法的返回类型前添加类型参数。
   • 例如：<T> T getFirst(List<T> list) { ... }
4. 调用泛型方法
   • 调用泛型方法时，编译器会自动推断类型参数。
   • 例如：String first = getFirst(list);

六 , 泛型的优缺点

• 优点
  • 类型安全：编译时检查类型，避免运行时的类型转换错误。
  • 代码复用：泛型类和方法可以处理多种类型的对象，减少了代码冗余。
  • 消除类型转换：编译器自动进行类型转换，提高了代码的可读性和安全性。
• 缺点
  • 复杂性增加：泛型增加了代码的复杂性，特别是对于初学者来说。
  • 性能影响：泛型在编译时会进行类型擦除，可能会导致一些性能开销。

七 , 示例代码

// 定义一个泛型类
class Box<T> {
    private T item;

    public Box(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }

    public void setItem(T item) {
        this.item = item;
    }
}

// 定义一个泛型方法
public class GenericExample {
    public static <T> void printItem(Box<T> box) {
        System.out.println("Item: " + box.getItem());
    }

    public static void main(String[] args) {
        // 使用泛型类
        Box<String> stringBox = new Box<>("Hello");
        Box<Integer> integerBox = new Box<>(123);

        // 调用泛型方法
        printItem(stringBox);  // 输出: Item: Hello
        printItem(integerBox); // 输出: Item: 123
    }
}

什么是反射?

一 , 反射 (Reflection) 概述

• 反射是Java编程语言的一个强大特性，它允许程序在运行时检查类、接口、字段和方法的信息，并能动态地创建对象和调用方法。
• 反射机制为Java提供了极大的灵活性，使得程序员可以在运行时访问或“自省”程序的内部属性。

二 , 反射的主要功能

1 . 获取类的信息

• 获取类的名称、父类、实现的接口等。
• 获取类的构造器、方法、字段等成员信息。

2 . 创建对象

• 通过类的构造器动态创建对象实例。

3 . 访问私有成员

• 访问类的私有字段和方法，即使它们通常对外部不可见。

4 . 调用方法

• 动态调用类的方法，包括私有方法。

5 . 设置字段值

• 动态设置类的字段值，包括私有字段。

三 , 反射的使用场景

1. 框架开发

• 许多Java框架（如Spring、Hibernate）广泛使用反射来实现依赖注入、ORM等功能。

2. 动态代理

• 用于创建动态代理类，实现AOP（面向切面编程）等功能。

3. 插件系统

• 允许应用程序在运行时加载和使用外部插件。

4. 测试工具

• 测试工具可以使用反射来访问和修改私有成员，进行更全面的测试。

四 , 反射的基本步骤

1. 获取Class对象

通过类名、对象实例或类加载器获取Class对象。

2. 获取类的成员信息

使用Class对象的getDeclaredFields、getDeclaredMethods等方法获取类的字段和方法信息。

3. 创建对象

使用Class对象的newInstance方法或Constructor对象的newInstance方法创建对象实例。

4. 调用方法

使用Method对象的invoke方法调用类的方法。

5. 设置字段值

使用Field对象的set方法设置字段值。

五 , 反射的优缺点

优点

• 灵活性高：可以在运行时动态地操作类和对象。
• 扩展性强：支持插件化开发，增强系统的可扩展性。
• 测试方便：可以访问私有成员，便于单元测试。

缺点

• 性能开销大：反射操作比直接调用方法或访问字段要慢。
• 安全性问题：可以访问私有成员，可能导致安全漏洞。
• 代码可读性差：反射代码通常比较复杂，不易阅读和维护。

六 , 示例代码

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ReflectionExample {
    public static void main(String[] args) {
        try {
            // 获取Class对象
            Class<?> clazz = Class.forName("java.util.ArrayList");

            // 获取类名
            System.out.println("类名: " + clazz.getName());

            // 获取所有公有构造器
            Constructor<?>[] constructors = clazz.getConstructors();
            for (Constructor<?> constructor : constructors) {
                System.out.println("构造器: " + constructor);
            }

            // 获取所有公有方法
            Method[] methods = clazz.getMethods();
            for (Method method : methods) {
                System.out.println("方法: " + method);
            }

            // 获取所有公有字段
            Field[] fields = clazz.getFields();
            for (Field field : fields) {
                System.out.println("字段: " + field);
            }

            // 创建对象
            Object obj = clazz.newInstance();
            System.out.println("创建的对象: " + obj);

        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}