一、反射

Java的反射（reflection）机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任
意一个对象，都能够调用它的任意方法和属性，既然能拿到那么，我们就可以修改部分类型信息；这种动态获取信
息以及动态调用对象方法的功能称为java语言的反射（reflection）机制。
在这里插入图片描述

反射的相关类

.在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统
应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法。

类名	用途
Class类	代表类的实体，在运行的java应用程序种表示类和接口
Field	代表类的成员变量
Method类	代表类的方法
Constructor类	代表类的构造方法

反射机制的起源:
Java文件被编译后，生成了.class文件，JVM此时就要去解读.class文件 ,被编译后的Java文件.class也被JVM解析为一个对象，这个对象就是 java.lang.Class .这样当程序在运行时，每个java文件就最终变成了Class类对象的一个实例。我们通过Java的反射机制应用到这个实例，就可以去获得甚至去添加改变这个类的属性和动作，使得这个类成为一个动态的类

获得Class对象的三种方法

这里我们已获取Person为例

class Person {
    int age;
    String name;

    public Person() {
        
    }
    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }
}

1.使用类对象的getClass()方法

public static void main(String[] args) {
        Person person = new Person();
        Class<? > p = person.getClass();
    }

2.通过类名 .class方法

public static void main(String[] args) {
        Class<?> p1 = Person.class;
    }

3.使用 Class.forName(“类的全路径名”);
这里我们需要处理相关的异常

public static void main(String[] args) {
        Class<?> p2 = null;
        try {
             p2 = Class.forName("Person");
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }

我们来验证一下这三种方式获取的类对象

public static void main(String[] args) {
        Person person = new Person();
        Class<? > p = person.getClass();
        Class<?> p1 = Person.class;
        Class<?> p2 = null;
        try {
             p2 = Class.forName("Person");
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
        System.out.println(p.equals(p1));
        System.out.println(p.equals(p2));
        System.out.println(p1.equals(p2));
    }

在这里插入图片描述

反射的基本使用

获得类常用方法

方法	用途
getClassLoader()	获得类的加载器
getDeclaredClasses()	返回一个数组，包含类中所有类和接口的对象
forName(String className)	根据类名返回对象
newInstance()	创建类的实例
getName	获取类的完整路径名字

1.通过反射创建对象

public static void reflectNewInstance() {
        try {
            Class<?> personClass = Class.forName("Person");
            Person student = (Person)personClass.newInstance();
            System.out.println(student);
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

在这里插入图片描述
我们需要注意newInstance返回的是一个泛型，在编译阶段擦除为Object，所以我们在接受的时候需要强制类型转换

2.通过反射获取构造方法

我们来获取一下私有的构造方法

public static void reflectConstructor() {
        try {
            Class<?> personClass = Class.forName("Person");
            Constructor<?> constructor = personClass.getDeclaredConstructor(int.class, String.class);
            Person person = (Person)constructor.newInstance(18, "张三");
            System.out.println(person);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

在这里插入图片描述
我们可以发现系统报错，无法获取私有的，那到底是怎么回事呢？因为我们需要打开一下权限。

public static void reflectConstructor() {
        try {
            Class<?> personClass = Class.forName("Person");
            Constructor<?> constructor = personClass.getDeclaredConstructor(int.class, String.class);
            constructor.setAccessible(true);//把权限打开
            Person person = (Person)constructor.newInstance(18, "张三");
            System.out.println(person);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

在这里插入图片描述

3.通过反射获取相关属性

方法	用途
getField(String name)	获得某个公有的属性对象
getFields()	获得所有公有的属性对象
getDeclaredField(String name)	获得某个属性对象
getDeclaredFields()	获得所有属性对象

public static void reflectField() {
        try {
            Class<?> personClass = Class.forName("Person");
            Field field = personClass.getDeclaredField("name");
            field.setAccessible(true);
            Person person = (Person)personClass.newInstance();
            field.set(person,"张三");
            System.out.println(person);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        } catch (NoSuchFieldException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

在这里插入图片描述
3.通过反射获取相关方法

private void print(String s) {
        System.out.println(s);
    }

这里以获取这个私有方法为例

public static void reflectMethod() {
        try {
            Class<?> personClass = Class.forName("Person");
            Method print = personClass.getDeclaredMethod("print",String.class);
            print.setAccessible(true);
            Person person = (Person)personClass.newInstance();
            print.invoke(person,"反射测试方式成功！");
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        }
    }

在这里插入图片描述

反射优点和缺点

优点：

对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法
增加程序的灵活性和扩展性，降低耦合性，提高自适应能力
反射已经运用在了很多流行框架如：Struts、Hibernate、Spring 等等。

缺点：

使用反射会有效率问题。会导致程序效率降低。
反射技术绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂。

二、枚举

背景及定义

我们创建一个Color枚举类型

public enum ColorEnum {
    BLACK,YELLOW,GREEN;
}

优点：将常量组织起来统一进行管理
场景：错误状态码，消息类型，颜色的划分，状态机等等…
本质：是 java.lang.Enum 的子类，也就是说，自己写的枚举类，就算没有显示的继承 Enum ，但是其默认继承了这个类。

枚举的使用

1.switch语句

enum ColorEnum {
    BLACK,YELLOW,GREEN;
}
public class Test {
    public static void main(String[] args) {
        ColorEnum colorEnum = ColorEnum.YELLOW;
        switch (colorEnum) {
            case BLACK:
                System.out.println("BLACK");
                break;
            case YELLOW:
                System.out.println("YELLOW");
                break;
            case GREEN:
                System.out.println("GREEN");
                break;
            default:
                break;
        }
    }
}

在这里插入图片描述
2.常用方法
values() 以数组形式返回枚举所有成员

public static void main(String[] args) {
        ColorEnum[] colorEnums = ColorEnum.values();
        for (int i = 0; i < colorEnums.length; i++) {
            System.out.println(colorEnums[i]);
        }
    }

在这里插入图片描述
ordinal()获取枚举成员的索引位置

public static void main(String[] args) {
        ColorEnum[] colorEnums = ColorEnum.values();
        for (int i = 0; i < colorEnums.length; i++) {
            System.out.println(colorEnums[i].ordinal());
        }
    }

在这里插入图片描述
valueOf()将普通字符串转换为枚举实例

public static void main(String[] args) {
        ColorEnum colorEnum = ColorEnum.valueOf("BLACK");
        System.out.println(colorEnum);
    }

在这里插入图片描述
只能转换枚举类型种已经定义的

public static void main(String[] args) {
        ColorEnum colorEnum = ColorEnum.valueOf("RED");
        System.out.println(colorEnum);
    }

在这里插入图片描述

compareTo() 比较两个枚举成员在定义时的顺序

public static void main(String[] args) {
        System.out.println(ColorEnum.GREEN.compareTo(ColorEnum.YELLOW));
        System.out.println(ColorEnum.BLACK.compareTo(ColorEnum.YELLOW));
    }

在这里插入图片描述

为什么Enum源码中找不到values()方法？

在这里插入图片描述
Enum类和enum关键字定义的类型都有values方法，但是点进去会发现找不到这个方法。这是因为java编译器在编译这个类（enum关键字定义的类默认继承java.lang.Enum）的时候自动插入了一条static的方法values。在官方文档中有说明。
文档地址：官方文档

枚举与反射

枚举的构造方法默认是私有的

enum ColorEnum {
    BLACK(0,"black"),YELLOW(1,"yellow"),GREEN(2,"green");
    private int id;
    private String color;

    private ColorEnum(int id, String color) {
        this.id = id;
        this.color = color;
    }
}

在枚举中调用
在这里插入图片描述
为什么我们通过反射调用枚举的构造方法时会报java.lang.IllegalArgumentException: 异常呢？

我们在源码中可以发现枚举在这里被过滤了，你不能通过反射获取枚举类的实例。
这里证明: 枚举实现单例模式是安全的

总结

1、枚举本身就是一个类，其构造方法默认为私有的，且都是默认继承与 java.lang.Enum
2、枚举可以避免反射和序列化问题
3、枚举实现单例模式是安全的
优点：

枚举常量更简单安全。
枚举具有内置方法，代码更优雅

缺点：

不可继承，无法扩展

三、Lambda表达式

Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。 Lambda 表达式（Lambda expression），基于数学中的λ演算得名，也可称为闭包（Closure）。
先了解一下什么是函数式接口？

函数式接口

要了解Lambda表达式,首先需要了解什么是函数式接口，函数式接口定义：一个接口有且只有一个抽象方法。
注意：

如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口
如果我们在某个接口上声明了 @FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求该接
口，这样如果有两个抽象方法，程序编译就会报错的。所以，从某种意义上来说，只要你保证你的接口中只
有一个抽象方法，你可以不加这个注解。加上就会自动进行检测的。

我们以优先级队列为例，传入的比较器，我们可以发现这个接口上面有@FunctionalInterface关键字，证明它就是一个函数式接口，我们在传入参数的时候就可以使用lambda表达式。

Lambda表达式的基本使用

参数类型可以省略，如果需要省略，每个参数的类型都要省略。
参数的小括号里面只有一个参数，那么小括号可以省略
如果方法体当中只有一句代码，那么大括号可以省略
如果方法体中只有一条语句，其是return语句，那么大括号可以省略，且去掉return关键字

在这里我们自定义几个函数式接口。
1.无参数无返回值

@FunctionalInterface
interface LambdaTest {
     void func();
}
    public static void main(String[] args) {
        LambdaTest lambda = new LambdaTest() {
            @Override
            public void func() {
                System.out.println("lambda测试");
            }
        };
        lambda.func();
    }

这里我们使用匿名内部类
在这里插入图片描述

public static void main(String[] args) {
        LambdaTest lambdaTest = (() -> System.out.println("lambda测试"));
        lambdaTest.func();
    }

在这里插入图片描述
2.有参数无返回值

@FunctionalInterface
interface LambdaTest {
    void func(String s);
}
    public static void main(String[] args) {
        LambdaTest lambda = new LambdaTest() {
            @Override
            public void func(String s) {
                System.out.println("lambda测试" + s);
            }
        };
       lambda.func("匿名内部类");
    }

在这里插入图片描述

public static void main(String[] args) {
        LambdaTest lambda = s -> System.out.println("lambda测试" + s);
        lambda.func("lambda测试");
    }

在这里插入图片描述
参数只有一个时，可以去掉括号。
3.没有参数有返回值

@FunctionalInterface
interface LambdaTest {
    int func();
}
    public static void main(String[] args) {
        LambdaTest lambdaTest = new LambdaTest() {
            @Override
            public int func() {
                return 1;
            }
        };
        System.out.println(lambdaTest.func());
    }

在这里插入图片描述

interface LambdaTest {
    int func();
}
public class Test {
    public static void main(String[] args) {
        LambdaTest lambdaTest = () -> 1;
        System.out.println(lambdaTest.func());
    }

在这里插入图片描述

4.有参数有返回值

@FunctionalInterface
interface LambdaTest {
    int func(int a,int b);
}
    public static void main(String[] args) {
        LambdaTest lambdaTest = new LambdaTest() {
            @Override
            public int func(int a, int b) {
                return a + b;
            }
        };
        System.out.println(lambdaTest.func(1, 2));
    }

在这里插入图片描述

public static void main(String[] args) {
        LambdaTest lambdaTest = (a,b) -> a+b;
        System.out.println(lambdaTest.func(1, 2));
    }

在这里插入图片描述

lambda在集合中的应用

1.forEach() 方法演示
在这里插入图片描述
我们来看一下forEach的参数

我们发现是一个函数式接口，所以我们可以使用lambda表达式

public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        set.add(1);
        set.add(2);
        set.add(3);
        set.add(4);
        set.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.print(integer + " ");
            }
        });
    }

lambda表达式:

public static void main(String[] args) {
        Set<Integer> set = new HashSet<>();
        set.add(1);
        set.add(2);
        set.add(3);
        set.add(4);
        set.forEach(integer -> System.out.print(integer + " "));
    }

在这里插入图片描述
2.HashMap 的 forEach()
匿名内部类:

public static void main(String[] args) {
        HashMap<String,Integer> hashMap = new HashMap<>();
        hashMap.put("aaa",1);
        hashMap.put("bbb",2);
        hashMap.put("ccc",3);
        hashMap.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println(s + " -> " + integer );
            }
        });
    }

lambda表达式:

public static void main(String[] args) {
        HashMap<String,Integer> hashMap = new HashMap<>();
        hashMap.put("aaa",1);
        hashMap.put("bbb",2);
        hashMap.put("ccc",3);
        hashMap.forEach((String s,Integer i) -> System.out.println(s + " -> " + i ));
    }

在这里插入图片描述
3.sort() 方法演示

我们发现这里是一个函数式接口

public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(3);
        arrayList.add(1);
        arrayList.add(2);
        arrayList.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
    }

lambda表达式:

public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(3);
        arrayList.add(1);
        arrayList.add(2);
        arrayList.sort((o1,o2) -> o1 - o2);
        for (Integer integer : arrayList) {
            System.out.print(integer + " ");
        }
    }

在这里插入图片描述

总结

Lambda表达式的优点很明显，在代码层次上来说，使代码变得非常的简洁。缺点也很明显，代码不易读。
优点：

代码简洁，开发迅速
方便函数式编程
非常容易进行并行计算
Java 引入 Lambda，改善了集合操作

缺点：

代码可读性变差
在非并行计算中，很多计算未必有传统的 for 性能要高
不容易进行调试

声明：本站所有资源，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。

Java 源代码

一、反射

反射的相关类

获得Class对象的三种方法

反射的基本使用

反射优点和缺点

二、枚举

背景及定义

枚举的使用

为什么Enum源码中找不到values()方法？

枚举与反射

总结

三、Lambda表达式

函数式接口

Lambda表达式的基本使用

lambda在集合中的应用

总结

合作伙伴

我要赚钱

有站网，站长需要的精彩内容从这里开始

一、反射

反射的相关类

获得Class对象的三种方法

反射的基本使用

反射优点和缺点

二、枚举

背景及定义

枚举的使用

为什么Enum源码中找不到values()方法？

枚举与反射

总结

三、Lambda表达式

函数式接口

Lambda表达式的基本使用

lambda在集合中的应用

总结

相关文章