反射，枚举，lambda

学习自省

于 2022-10-26 22:09:00 发布

阅读量780

点赞数

文章标签： java 数据结构

本文链接：https://blog.csdn.net/c_study__c/article/details/127526675

版权

日升时奋斗，日落时自省

一、反射

1、反射的定义

java反射：机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任
意一个对象，都能够调用它的任意方法和属性，既然能拿到那么，我们就可以修改部分类型信息；

个人理解：就是通过另一种方式取的需要类的属性和方法，这种方式就是反射

2、用途

（1）当有某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时就需要反射来调用修改里面的属性和方法。

（2）反射最重要的用途就是开发各种通用框架

3、与反射相关类（常用）

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

上面的类型不用硬记，每个都是我们先前学的构造方法，方法。

这些当然是不能实例化的，还是需要找其他办法的

4、获取.class

方法一：使用.getClass()

方法二：类.class

方法三：Class.forName（“路径”）（之后最常用的方法）

class Student{  //寻常的一个例子
    private  String name="bit";
    public  int age =18;

    public Student(){
        System.out.println("Student");
    }
    private  Student(String name ,int age){
        this.name=name;
        this.age=age;
        System.out.println("Student(String ,int)");
    }
    private void eat(){
        System.out.println("干饭");
    }
    private void sleep(){
        System.out.println("酣睡");
    }
 @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Test {
    public static void main(String[] args) {
        //以下有三种方法
        Student student=new Student();
        //第一种调用的方法
        Class<?> c1=student.getClass();    //这里就选用通配符了，当前你写Student也没事
        //第二种调用方法
        Class<?> c2=Student.class;       //直接.class 就可以直接调用
        //第三种调用方式
        Class<?> c3=null;   //当前就是第三种方法  这里没有直接写的原因是因为当下要抛出异常
        // 第三种方法调用的是 forName（"这里是你的路径"）   //这里是因为Student本来就在当前这文件里，直接就调用了
        try{
            c3=Class.forName("Student");  //这里写的时候是会提示有报错的，不要慌张，这里需要抛一个异常
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
        System.out.println(c1.equals(c2));
        System.out.println(c2.equals(c3));
        System.out.println(c3.equals(c1));
        //以上三种方式都是一样的，我们之后最长用的方法是forName（）方法来进行反射
        //为啥嘞，因为找的是路径放方便
    }
}

运行结果：

展现这个结果更能看出，这三个方法其实都是一样的，三个方法都是反射同一个类，第三种方法之所以是最常用的方法，是因为路径是唯一的，如果类多了，可能会有重复的命名，但是路径的唯一性，就可以解决该问题

5、classde使用方法

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

1.1创建类的实例

当前没有让Student直接实例化，而是通过反射的方法进行的，反射同样可以实现我们需要类的实例化，但是这里能看见，反射实例化写了两行代码，而且还需要调用了多个方法，速度一定不是那么快的，不是说明他没有用，只是当前在这个地方确实没有什么用，特殊情况，如有些只能应用系统去调用的时候就需要反射来。

1.2构造方法

方法	用途
getConstructor(Class...<?> parameterTypes)	获得该类中与参数类型匹配的公有构造方法
getConstructors()	获得该类的所有公有构造方法
getDeclaredConstructor(Class...<?> parameterTypes)	获得该类中与参数类型匹配的构造方法
getDeclaredConstructors()	获得该类所有构造方法

这里会报一个错误

缺了一行代码，来解决当前问题

现在合法了，就可以跑了

1.3FIeld 方法

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

field修改成员属性

1.4反射方法

方法	用途
getMethod(String name, Class...<?> parameterTypes)	获得该类某个公有的方法
getMethods()	获得该类所有公有的方法
getDeclaredMethod(String name, Class...<?> parameterTypes)	获得该类某个方法
getDeclaredMethods()	获得该类所有方法

这里没有打印，但是Invoke是会直接调用到Student类的方法的，进行打印

1.5总结

反射如果在前面的代码中注意到了，就会发现我们的Student 里面方法还有成员都有封装类型是Private的，反射打破了封装的规则，具有两面性，这就已经是看到比较危险的地方了，但是肯定还是有好处的，凡是存在必有道理

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

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

二、枚举

1、枚举的优缺点

优点：
1. 枚举常量更简单安全。
2. 枚举具有内置方法
注：枚举反射是不能实例化的，所以枚举很安全，这也是枚举的缺点

缺点：

1.不能扩展

2、枚举接口简单应用

public enum TestEnum {
    RED("red",1),   //注意：枚举的构造方法传值与其他有所不同，直接在枚举的成员变量后面进行传参
    BLACK("black",2),
    WHITE("white",3),
    GREEN("green",4);
    private String name;
    private int key;
    private TestEnum (String name,int key) {
        this.name = name;
        this.key = key;
    }
    public static void main(String[] args) {  //java中的枚举是可以写main函数的，
        TestEnum testEnum=TestEnum.BLACK;   //众所周知接口是不能实例化的，枚举的特殊形式
        switch (testEnum){
            case RED:
                System.out.println("红色");
                break;
            case BLACK:
                System.out.println("黑色");
                break;
            case WHITE:
                System.out.println("白色");
                break;
            case GREEN:
                System.out.println("绿色");
                break;
            default:
                System.out.println("没有找到");
                break;
        }
    }
}

这里有一个不存在该方法的报错（原码显示）

前面可以看见是有的，但是不存在是什么意思，因为当前我们创建的枚举接口是继承java里面原有的Enum接口所以

那为什么又不行，其实是真不行，前面注意看细节的友友们，枚举是不能被反射所调用的，所以这里是真走不了。

3、总结

1、枚举本身就是一个类，其构造方法默认为私有的
2、枚举可以避免反射和序列化问题

三、Lambda表达式

1.Lambda表达式

1.1、基本语法

Lambda设计函数式接口，函数式接口是什么呢，是一个接口只能有一个抽象方法

这就是一个函数式接口如果，已经有了一方法了

这里已经给了提示了，当出现第二个抽象方法

那是不是就只能这么写了，当然不是，这里加上一个default来修饰就不会报错了

//当前就是一个函数式接口 如何证明呢
@FunctionalInterface   //@FunctionalInterface 注解存在的时候，会对函数式接口有提示
interface NoParameterNoReturn {
    void test();
    
}
@FunctionalInterface
interface OneParameterNoReturn {
    void test(int a);
}
@FunctionalInterface
interface MoreParameterNoReturn {
    void test(int a,int b);
}




@FunctionalInterface
interface NoParameterReturn {
    int test();
}
//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
    int test(int a);
}
@FunctionalInterface
interface MoreParameterReturn {
    int test(int a,int b);
}
public class Test2 {
    public static void main(String[] args) {
        NoParameterNoReturn noParameterNoReturn=new NoParameterNoReturn() {
            @Override
            public void test() {
                System.out.println("当前方法");
            }
        };
        //匿名内部类
        noParameterNoReturn.test();  //调用方法
    }
}

以上是以个匿名内部类，要从这里开始看如何使用lambda表达式