Overthinker

“无所谓，跳探戈不像人生，一步跳错了，继续跳就行了”

浏览量：-，访问次数：-

公告

欢迎来到我的博客！

了解更多

1691 字

8 分钟

Java从入门到“放弃”（精通）之旅——反射、枚举与Lambda

2024-04-29

JavaSE

/

博客

浏览量：加载中...，访问次数：加载中...

Java从入门到“放弃”（精通）之旅🚀——反射、枚举与Lambda#

在这里插入图片描述

一、反射：Java的“照妖镜”🔍#

1.1 什么是反射？#

想象一下，你正在参加一个化妆舞会，每个人都戴着面具。突然，你掏出一面“照妖镜”（反射），不仅能看穿对方的面具（私有属性），还能让对方即兴跳支舞（调用私有方法）。这就是Java反射——在运行时窥探和操作类的私密信息。

1.2 反射的“武器库”#

反射四大金刚：

类名	用途
`Class`	代表类的实体（一切起点）
`Field`	操作属性（甚至私有）
`Method`	调用方法（包括私有的）
`Constructor`	调用构造方法（偷偷new对象）

1.3 获取Class对象的三种姿势#

1
// 1. 通过对象getClass()（最直白）
2
Student s1 = new Student();
3
Class c1 = s1.getClass();
4

5
// 2. 通过类名.class（最安全）
6
Class c2 = Student.class;
7

8
// 3. 通过Class.forName()（最常用，但容易翻车）
9
Class c3 = Class.forName("com.example.Student"); // 注意全限定名！

💡冷知识：一个类在JVM中只有一个Class实例，所以c1==c2==c3都是true！

1.4 反射实战：偷看私有日记📖#

1
public class ReflectClassDemo {
2
    // 1. 反射创建对象（无参构造）
3
    public static void reflectNewInstance() {
4
        try {
5
            Class<?> clazz = Class.forName("Student");
6
            Student student = (Student) clazz.newInstance(); // 相当于new Student()
7
            System.out.println("反射创建对象: " + student);
8
        } catch (Exception e) {
9
            e.printStackTrace();
10
        }
11
    }
12

13
    // 2. 反射私有构造方法（带参数）
14
    public static void reflectPrivateConstructor() {
15
        try {
16
            Class<?> clazz = Class.forName("Student");
17
            Constructor<?> constructor = clazz.getDeclaredConstructor(String.class, int.class);
18
            constructor.setAccessible(true); // 关键！突破私有限制
19
            Student student = (Student) constructor.newInstance("高博", 15);
20
            System.out.println("反射私有构造: " + student);
21
        } catch (Exception e) {
22
            e.printStackTrace();
23
        }
24
    }
25

26
    // 3. 反射私有属性（修改name）
27
    public static void reflectPrivateField() {
28
        try {
29
            Class<?> clazz = Class.forName("Student");
30
            Field field = clazz.getDeclaredField("name");
31
            field.setAccessible(true); // 再次突破限制
32
            Student student = (Student) clazz.newInstance();
33
            field.set(student, "小明"); // 偷偷改名字
34
            System.out.println("修改后的name: " + field.get(student));
35
        } catch (Exception e) {
36
            e.printStackTrace();
37
        }
38
    }
39

40
    // 4. 反射私有方法（调用function）
41
    public static void reflectPrivateMethod() {
42
        try {
43
            Class<?> clazz = Class.forName("Student");
44
            Method method = clazz.getDeclaredMethod("function", String.class);
45
            method.setAccessible(true); // 继续突破
46
            Student student = (Student) clazz.newInstance();
47
            method.invoke(student, "我是参数"); // 偷偷调用方法
48
        } catch (Exception e) {
49
            e.printStackTrace();
50
        }
51
    }
52
}

⚠️警告：反射虽好，可不要滥用哦！否则你的代码会变成“蜘蛛网”，维护起来想哭。

二、枚举：Java的“选择题”🔘#

2.1 为什么需要枚举？#

以前定义常量：

1
public static final int RED = 1;
2
public static final int GREEN = 2;
3
public static final int BLACK = 3;

问题：

容易混淆（1是RED还是ERROR？）
没有类型安全（你可以把1赋值给任何int）

枚举来了！

1
public enum Color {
2
    RED, GREEN, BLACK, WHITE;
3
}

现在Color.RED是一个类型安全的常量，再也不会和1搞混了！

2.2 枚举的高级玩法（带参数的枚举）#

1
public enum Color {
2
    RED("红色", 1), GREEN("绿色", 2), BLACK("黑色", 3), WHITE("白色", 4);
3

4
    private String name;
5
    private int key;
6

7
    // 枚举构造默认是私有的！
8
    private Color(String name, int key) {
9
        this.name = name;
10
        this.key = key;
11
    }
12

13
    public static Color getByKey(int key) {
14
        for (Color color : values()) {
15
            if (color.key == key) {
16
                return color;
17
            }
18
        }
19
        return null;
20
    }
21
}

2.3 枚举与反射的“爱恨情仇”#

尝试用反射创建枚举实例：

1
public static void reflectPrivateConstructor() {
2
    try {
3
        Class<?> clazz = Class.forName("Color");
4
        Constructor<?> constructor =
5
            clazz.getDeclaredConstructor(String.class, int.class, String.class, int.class);
6
        constructor.setAccessible(true);
7
        Object object = constructor.newInstance("父类参数", 666, "子类参数", 888);
8
        Color color = (Color) object;
9
        System.out.println("反射创建枚举: " + color);
10
    } catch (Exception e) {
11
        e.printStackTrace();
12
    }
13
}

输出：

1
java.lang.IllegalArgumentException: Cannot reflectively create enum objects

结论：枚举防反射！这是Java专门设计的安全机制。所以枚举实现单例模式是安全的（阿里面试题哦！）。

三、Lambda表达式：Java的“瘦身教练”💃#

3.1 什么是Lambda？#

以前写匿名内部类：

1
Runnable r = new Runnable() {
2
    @Override
3
    public void run() {
4
        System.out.println("Hello");
5
    }
6
};

现在：

1
Runnable r = () -> System.out.println("Hello");

从“臃肿大叔”变身“精神小伙”！

3.2 函数式接口（Lambda的前提）#

只有一个抽象方法的接口就是函数式接口。可以用@FunctionalInterface注解标记。

1
@FunctionalInterface
2
interface NoParameterNoReturn {
3
    void test();
4
    // 可以有默认方法
5
    default void test2() {
6
        System.out.println("我是默认方法");
7
    }
8
}

3.3 Lambda语法精简规则#

参数类型可省略
只有一个参数时，()可省略
方法体只有一句时，{}可省略
有返回值且只有一句时，return可省略

示例：

1
// 1. 无参无返回值
2
NoParameterNoReturn () -> System.out.println("Hello");
3

4
// 2. 有参无返回值
5
OneParameterNoReturn a -> System.out.println(a);
6

7
// 3. 有参有返回值
8
MoreParameterReturn (a, b) -> a + b; // 自动return

3.4 Lambda在集合中的应用#

forEach遍历：#

1
List<String> list = Arrays.asList("Hello", "bit", "Lambda");
2
list.forEach(s -> System.out.println(s));

sort排序：#

1
list.sort((s1, s2) -> s1.length() - s2.length());

Map遍历：#

1
Map<Integer, String> map = new HashMap<>();
2
map.put(1, "Hello");
3
map.put(2, "Lambda");
4
map.forEach((k, v) -> System.out.println(k + "=" + v));

3.5 变量捕获（Lambda的“闭包”）#

Lambda只能捕获final或等效final的局部变量。

1
int a = 10;
2
NoParameterNoReturn r = () -> {
3
    // a = 20; // 错误！不能修改捕获的变量
4
    System.out.println(a); // 可以读取
5
};

四、总结：三剑客的优缺点#

技术	优点	缺点
反射	动态、灵活、框架基石	性能低、代码复杂、不安全
枚举	安全、清晰、防反射	不可继承、扩展性差
Lambda	代码简洁、函数式编程、并行友好	可读性差、调试困难

五、彩蛋：单例模式大PK#

5.1 静态内部类实现#

1
class Singleton {
2
    private Singleton() {}
3
    private static class Holder {
4
        private static final Singleton INSTANCE = new Singleton();
5
    }
6
    public static Singleton getInstance() {
7
        return Holder.INSTANCE;
8
    }
9
}

5.2 枚举实现（最安全！）#

1
public enum Singleton {
2
    INSTANCE;
3
    public void doSomething() {
4
        System.out.println("我是单例！");
5
    }
6
}
7
// 使用：Singleton.INSTANCE.doSomething();

最后提醒：

反射要用在正道（框架、工具），别偷看别人隐私！

枚举是单例的最佳选择，安全又省心。

Lambda能让代码变帅，但别写得太抽象，否则同事会打你。

致谢：感谢Java设计者给了我们这么多好玩的东西，也感谢各位佬们的关注和支持，点个赞再走吧😊 在这里插入图片描述

JavaSE专栏（CSDN）

Java从入门到“放弃”（精通）之旅——启航①

Java从入门到“放弃”（精通）之旅——数据类型与变量②

Java从入门到“放弃”（精通）之旅——运算符③

Java从入门到“放弃”（精通）之旅——程序逻辑控制④

Java从入门到“放弃”（精通）之旅——方法的使用⑤

Java从入门到“放弃”（精通）之旅——数组的定义与使用⑥

Java从入门到“放弃”（精通）之旅——类和对象全面解析⑦

Java从入门到“放弃”（精通）之旅——继承与多态⑧

Java从入门到“放弃”（精通）之旅——抽象类和接口⑨

Java从入门到“放弃”（精通）之旅——String类⑩

Java从入门到“放弃”（精通）之旅——JavaSE终篇（异常）

Java从入门到“放弃”（精通）之旅——反射、枚举与Lambda

Java从入门到“放弃”（精通）之旅——反射、枚举与Lambda

https://mizuki.mysql.com/posts/java/contentl/

作者

Overthinker

发布于

2024-04-29

许可协议

CC BY-NC-SA 4.0

⏰ 时间与空间复杂度解析

Java从入门到“放弃”（精通）之旅——JavaSE（异常）

Overthinker!

Overthinker!

Overthinker!

Java从入门到“放弃”（精通）之旅🚀——反射、枚举与Lambda#

一、反射：Java的“照妖镜”🔍#

1.1 什么是反射？#

1.2 反射的“武器库”#

1.3 获取Class对象的三种姿势#

1.4 反射实战：偷看私有日记📖#

二、枚举：Java的“选择题”🔘#

2.1 为什么需要枚举？#

2.2 枚举的高级玩法（带参数的枚举）#

2.3 枚举与反射的“爱恨情仇”#

三、Lambda表达式：Java的“瘦身教练”💃#

3.1 什么是Lambda？#

3.2 函数式接口（Lambda的前提）#

3.3 Lambda语法精简规则#

3.4 Lambda在集合中的应用#

forEach遍历：#

sort排序：#

Map遍历：#

3.5 变量捕获（Lambda的“闭包”）#

四、总结：三剑客的优缺点#

五、彩蛋：单例模式大PK#

5.1 静态内部类实现#

5.2 枚举实现（最安全！）#