总结Java中反射+枚举+Lambda表达式

最新推荐文章于 2024-09-28 17:13:20 发布
最新推荐文章于 2024-09-28 17:13:20 发布
阅读量1k 收藏 4
点赞数 1
分类专栏： javaSE 数据结构 文章标签： java 反射 枚举类 lambda 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/starry1441/article/details/116595749
版权

反射+枚举+Lambda表达式

反射

定义

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

基本信息

Java程序中许多对象在运行时会出现两种类型：运行时类型(RTTI)和编译时类型，例如Person p = new Student()；这句代码中p在编译时类型为Person，运行时类型为Student。程序需要在运行时发现对象和类的真实信心。而通过使用反射程序就能判断出该对象和类属于哪些类。

反射相关的类

（反射当中几个重要的类型）

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

反射机制起源

Java文件被编译后，生成了.class文件，.class文件需要加载到JVM虚拟机上
在这里插入图片描述

字节码文件所对应的对象就是Class对象，它会板寸当前类型的信息

所以反射的根本就是从Class对象出发点

Class对象只有一个，因为.class文件是从.java文件的类对象信息获取的，类只有一个

我们通过Java的反射机制应用到这个Class对象实例，就可以去获得甚至去添加改变这个类的属性和动作，使得这个类成为一个动态的类

Class类中相关方法及使用

获得类相关方法

方法用途
getClassLoader()获得类的加载器
getDeclaredClasses()返回一个数组，数组中包含该类中所有类和接口类的对象(包括私有的)
forName(String className)根据类名返回类的对象
newInstance()创建类的实例
getName()获得类的完整路径名字
    //通过反射创建对象
    public static void reflectNewInstance() {
        try {
            //1. 通过getClass获取Class对象
            Class<?> c1 = Class.forName("work5_10.Student");
            //2. 创建类的实例
            Student student = (Student) c1.newInstance();
            //3. 调用Student中的toString方法
            System.out.println(student);
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        reflectNewInstance();
    }

获得属性相关方法

方法用途
getField(String name)获得某个公有的属性对象
getFields()获得所有公有的属性对象
getDeclaredField(String name)获得某个属性对象
getDeclaredFields()获得所有属性对象
    // 反射获取属性
    public static void reflectPrivateField() {
        try {
            //1. 通过getClass获取Class对象
            Class<?> c1 = Class.forName("work5_10.Student");
            //2. 获取到全部的属性（包括私有的）
            //getField()：获取到公有的属性
            Field field = c1.getDeclaredField("name");
            //3. 私有属性必须设置为true后可修改访问权限
            field.setAccessible(true);
            //4. 通过构造方法创建类的实例
            Student student = (Student) c1.newInstance();
            //5. 更改student中的属性name
            field.set(student,"lala");
            //6. 调用Student中的toString方法
            System.out.println(student);
        } catch (ClassNotFoundException | NoSuchFieldException | InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        reflectPrivateField();
    }

获得类中方法相关方法

方法用途
getMethod(String name, Class…<?> parameterTypes)获得该类某个公有的方法
getMethods()获得该类所有公有的方法
getDeclaredMethod(String name, Class…<?> parameterTypes)获得该类某个方法
getDeclaredMethods()获得该类所有方法
    //反射获取类中方法
    public static void reflectMethod() {
        try {
            //1. 通过getClass获取Class对象
            Class<?> c1 = Class.forName("work5_10.Student");
            //2. 获取到全部的方法（包括私有的）
            //getMethod()：获取到公有的方法
            Method method = c1.getDeclaredMethod("function", String.class);
            //3. 私有方法必须设置为true后可修改访问权限
            method.setAccessible(true);
            //4. 通过构造方法创建类的实例
            Student student = (Student) c1.newInstance();
            //5. 调用student对象中添加function方法
            method.invoke(student,"我是给私有的function函数传的参数");
        } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        reflectMethod();
    }

获得类中构造器相关方法

方法用途
getConstructor(Class…<?> parameterTypes)获得该类中与参数类型匹配的公有构造方法
getConstructors()获得该类的所有公有构造方法
getDeclaredConstructor(Class…<?> parameterTypes)获得该类中与参数类型匹配的构造方法
getDeclaredConstructors()获得该类所有构造方法
    // 反射获取私有的构造方法
    public static void reflectPrivateConstructor2() {
        try {
            //1. 通过getClass获取Class对象
            Class<?> c1 = Class.forName("work5_10.Student");
            //2. 获取到带有参数的构造方法
            //getDeclaredConstructor()：获取到所有的构造方法
            Constructor<?> constructor =
                    c1.getDeclaredConstructor(String.class,int.class);
            //3. 私有方法必须设置为true后可修改访问权限
            constructor.setAccessible(true);
            //4. 通过构造方法创建类的实例
            Student student = (Student) constructor.newInstance("狒狒",21);
            //5. 调用Student中的toString方法
            System.out.println(student);
        } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    // 反射获取属性
    public static void reflectPrivateField() {
        try {
            //1. 通过getClass获取Class对象
            Class<?> c1 = Class.forName("work5_10.Student");
            //2. 获取到全部的属性（包括私有的）
            //getField()：获取到公有的属性
            Field field = c1.getDeclaredField("name");
            //3. 私有属性必须设置为true后可修改访问权限
            field.setAccessible(true);
            //4. 通过构造方法创建类的实例
            Student student = (Student) c1.newInstance();
            //5. 更改student中的属性name
            field.set(student,"lala");
            //6. 调用Student中的toString方法
            System.out.println(student);
        } catch (ClassNotFoundException | NoSuchFieldException | InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        reflectPrivateConstructor();
        reflectPrivateConstructor2();
    }

反射优点和缺点

优点：

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

缺点：

  1. 使用反射会有效率问题。会导致程序效率降低。具体参考这里：http://www.imooc.com/article/293679
  2. 反射技术绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂 。

枚举

定义

枚举是在JDK1.5以后引入的。主要用途是：将一组常量组织起来，在这之前表示一组常量通常使用定义常量的方式：

public enum TestEnum {
	RED,BLACK,GREEN;
}

优点：将常量组织起来统一进行管理

场景：错误状态码，消息类型，颜色的划分，状态机等等…

本质：是 java.lang.Enum 的子类，也就是说，自己写的枚举类，就算没有显示的继承 Enum ，但是其默认继承了这个类。

使用

switch语句

public enum TestEnum {
    RED,GREEN,BLACK;

    public static void main(String[] args) {
        TestEnum testEnum = TestEnum.BLACK;
        switch (testEnum) {
            case RED:
                System.out.println("red");
                break;
            case GREEN:
                System.out.println("green");
                break;
            case BLACK:
                System.out.println("black");
                break;
            default:
                break;
        }
    }
}

常用方法

方法名描述
values()以数组形式返回枚举类型的所有成员
ordinal()获取枚举成员的索引位置
valueOf()将普通字符串转换为枚举实例
compareTo()比较两个枚举成员在定义时的顺序
public enum TestEnum {
    RED,GREEN,BLACK;

    public static void main(String[] args) {
        //将当前的枚举对象，封装为数组
        TestEnum[] testEnums = TestEnum.values();
        for (TestEnum testEnum : testEnums) {
            System.out.print(testEnum + " ");//RED GREEN BLACK
        }
        System.out.println();
        //打印枚举对象数组的下标
        for (int i = 0; i < testEnums.length; i++) {
            System.out.print(testEnums[i].ordinal() + " ");//0 1 2
        }
        System.out.println();
        //根据字符串解析出来一个枚举对象
        System.out.println(TestEnum.valueOf("GREEN"));//GREEN

        System.out.println(RED.compareTo(BLACK));//-2
    }
}

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

public enum TestEnum {
    RED("red",1),GREEN("green",2),BLACK("black",3);

    public String color;
    public int ordinal;

    /**
     *  1、当枚举对象有参数后，需要提供相应的构造函数
     *  2、枚举的构造函数默认是私有的
     * @param color
     * @param ordinal
     */
    private TestEnum(String color,int ordinal) {
        this.color = color;
        this.ordinal = ordinal;
    }
}

枚举优点缺点

优点：

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

缺点：

  1. 不可继承，无法扩展

枚举和反射

枚举是否可以通过反射，拿到实例对象呢？

如果一个类的构造方法是私有的，那么在类外通过反射可以拿到这个类的对象，那么枚举应该也可以吗？

public enum TestEnum {
    RED("red",1),GREEN("green",2),BLACK("black",3);

    public String color;
    public int ordinal;

    /**
     *  1、当枚举对象有参数后，需要提供相应的构造函数
     *  2、枚举的构造函数默认是私有的
     * @param color
     * @param ordinal
     */
    private TestEnum(String color,int ordinal) {
        this.color = color;
        this.ordinal = ordinal;
    }

    public static void reflectPrivateConstructor() {
        try {
            Class<?> c1 = Class.forName("work5_10.TestEnum");
            Constructor<?> constructor = c1.getDeclaredConstructor(String.class,int.class,String.class,int.class);
            constructor.setAccessible(true);
            TestEnum yello = (TestEnum) constructor.newInstance("黄色",4,"父类的参数",10);
            System.out.println(yello);
        } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }

    }
}

自己的枚举类是继承java.lang.Enum的，Enum是抽象类，子类需要帮助父类进行构造
这里编译器自动帮我们进行构造了，我们不写也可以
但是我们在用反射传入构造方法的时候，需要再给两个父类的参数

Exception in thread “main” java.lang.IllegalArgumentException: Cannot reflectively create enum objects
at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
at work5_10.TestEnum.reflectPrivateConstructor(TestEnum.java:37)
at work5_10.TestEnum.main(TestEnum.java:46)

会报出这个异常，反射不能拿到内聚类

得出结论：枚举很特殊，就算是反射，也不能拿到对象

用枚举来实现单例模式是最好的

单例模式分为：懒汉式和饿汉式
实现单例模式：可以用静态内部类，可以用枚举
（之后会发博客专门解释单例模式）

总结枚举

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

Lambda表达式

Lambda语法

基本语法: (parameters) -> expression 或 (parameters) ->{ statements; }

Lambda表达式由三部分组成：

  1. paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明
    也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。
  2. ->：可理解为“被用于”的意思
  3. 方法体：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不反
    回，这里的代码块块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不反回。

举例说明

// 1. 不需要参数,返回值为 2
() -> 2

// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x

// 3. 接受2个参数(数字),并返回他们的和
(x, y) -> x + y

// 4. 接收2个int型整数,返回他们的乘积
(int x, int y) -> x * y

// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)

函数式接口

函数式接口定义：一个接口有且只有一个抽象方法 。

注意：

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

但是也可以有默认类型的具体方法

@FunctionalInterface
interface NoParameterNoReturn {
	void test();
	default void test2() {
		System.out.println("JDK1.8新特性，default默认方法可以有具体的实现");
	}
}

Lanmbda表达式使用

Lambda表达式本质是一个匿名函数，我们在调用接口的时候只需要关注：参数 -> 方法体

1. 无返回值无参数

//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
    void test();
}

//无返回值无参数
NoParameterNoReturn noParameterNoReturn = () -> {
    System.out.println("lala");
};
noParameterNoReturn.test();//lala

2. 无返回值一个参数

//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
    void test(int a);
}

//无返回值一个参数
OneParameterNoReturn oneParameterNoReturn = (int a) -> {
    System.out.println(a);
};
oneParameterNoReturn.test(10);//10

3. 无返回值多个参数

//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
    void test(int a,int b);
}

//无返回值多个参数
MoreParameterNoReturn moreParameterNoReturn = (int a,int b) -> {
    System.out.println(a+b);
};
moreParameterNoReturn.test(10,20);//30

4. 有返回值无参数

//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}

//有返回值无参数
NoParameterReturn noParameterReturn = () -> {
    return 10;
};
System.out.println(noParameterReturn.test());//10
//可简写
NoParameterReturn noParameterReturn2 = () -> 10;
System.out.println(noParameterReturn2.test());//10

5. 有返回值一个参数

//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
    int test(int a);
}

//有返回值一个参数
OneParameterReturn oneParameterReturn = (int a) -> {
    return a;
};
System.out.println(oneParameterReturn.test(4));//4
//可简写
OneParameterReturn oneParameterReturn2 = a -> a;
System.out.println(oneParameterReturn2.test(10));

6. 有返回值多参数

//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
    int test(int a,int b);
}

//有返回值多参数
MoreParameterReturn moreParameterReturn = (int a,int b) -> {
    return a+b;
};
System.out.println(moreParameterReturn.test(2,3));//5
MoreParameterReturn moreParameterReturn2 = (a,b) -> a+b;
System.out.println(moreParameterReturn2.test(2,3));//5

具体简写总结：

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

变量捕获

匿名内部类的变量捕获

class Test {
    public void func() {
        System.out.println("lala");
    }
}

public static void main(String[] args) {
    int a = 100;
    new Test() {
        @Override
        public void func() {
            System.out.println("匿名内部类function");
            System.out.println("捕获到的变量" + a + "这个变量是不能修改过的！");
        }
    }.func();
}

变量a就是，捕获的变量。这个变量要么是被final修饰，如果不是被final修饰的 你要保证在使用之前，没有修改。如下代码就是错误的代码。

Lambda的变量捕获

@FunctionalInterface
interface NoParameterNoReturn {
	void test();
} 

public static void main(String[] args) {
	int a = 10;
	NoParameterNoReturn noParameterNoReturn = ()->{
		// a = 99; error
		System.out.println("捕获变量："+a);
	};
	noParameterNoReturn.test();
}

Lambda在集合当中的使用

为了能够让Lambda和Java的集合类集更好的一起使用，集合当中，也新增了部分接口，以便与Lambda表达式对接。
在这里插入图片描述

Collection接口

forEach()

        ArrayList<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("world");
        list.add("hello");
        list.add("lambda");
        list.forEach(new Consumer<String>(){
            @Override
            public void accept(String str){
                //简单遍历集合中的元素。
                System.out.print(str+" ");
            }
        });

        //lambda写法
        list.forEach(s -> {
            System.out.println(s);
        });

List接口

sort()

        ArrayList<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("world");
        list.add("hello");
        list.add("lambda");
        list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });

        //简写
        list.sort((o1,o2) -> o1.compareTo(o2));
        list.forEach(s -> System.out.println(s));

Map接口

HashMap 的 forEach()

        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "hello");
        map.put(2, "world");
        map.put(3, "hello");
        map.put(4, "lambda");
        map.forEach(new BiConsumer<Integer, String>() {
            @Override
            public void accept(Integer k, String v) {
                System.out.println(k + " " + v);
            }
        });

        //简化
        map.forEach((k,v) -> System.out.println(k+" "+v));
满眼*星辰
关注
专栏目录
Java中反射、枚举及lambda表达式的使用
dddddrrrzz的博客
03-02 1395
目录一、反射1.1 定义1.2 用途1.3 反射基本信息1.4 与反射相关的类1.5 Class类(反射机制的起源 )1.6 Class类中的相关方法1.7 获得Class对象的三种方式1.8 反射的使用1.9 反射优点和缺点二、枚举2.1 Enum 类的常用方法2.2 枚举的优点和缺点三、Lambda 表达式总结 一、反射 1.1 定义 Java的反射（reflection）机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性，既然能拿到，那
java 多态替代switch表达式+lambda表达式
guohao_Kwok的博客
07-10 4400
精选30+云产品，助力企业轻松上云！>>> 原代码：...
java 通过反射获取枚举类，及枚举类的值，枚举类枚举实例名
10-09
java 通过反射获取枚举类，及枚举类的值，枚举类枚举实例名。本项目为普通java项目
方法的直接调用，反射调用与……Lambda表达式调用
weixin_34153893的博客
11-24 210
想调用一个方法很容易，直接代码调用就行，这人人都会。其次呢，还可以使用反射。不过通过反射调用的性能会远远低于直接调用——至少从绝对时间上来看的确是这样。虽然这是个众所周知的现象，我们还是来写个程序来验证一下。比如我们现在新建一个Console应用程序，编写一个最简单的Call方法。class Program { static void Main(string[] args) ...
Java数据结构——反射枚举及Lambda
最新发布
2302_76435884的博客
09-28 787
Java数据结构——反射枚举及Lambda
Java中的Lambda表达式枚举
asnowdream的博客
12-09 606
Java中的Lambda表达式枚举
Java中的反射，枚举
weixin_45804960的博客
08-30 326
反射 定义 Java的反射（reflection）机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任 意一个对象，都能够调用它的任意方法和属性，既然能拿到那么，我们就可以修改部分类型信息；这种动态获取信 息以及动态调用对象方法的功能称为java语言的反射（reflection）机制。 反射基本信息 Java程序中许多对象在运行时会出现两种类型：运行时类型(RTTI)和编译时类型，例如Person p = new Student()；这句代码中p在编译时类型为Person，运行时类型
Java 中的反射和枚举
lfm1010123的博客
06-25 466
在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量或成员方法是私有的或只对系统应用开放，这时候就可以利用 Java 的反射机制通过反射来获取所需的私有成员或方法，当然，公开的成员变量和方法显然也能通过反射获取得到。 反射最重要的用途就是开发各种通用框架，比如在 spring 中，我们将所有的类Bean 交给 spring 容器管理，无论是 XML 配置 Bean 还是注解配置，当我们从容器中获取 Bean 来依赖注入时，容器会读取配置，而配置中给的就是类的信息，spring 根据这些信息，需要创建
数据结构 反射、枚举 + Lambda的使用
m0_58157267的博客
05-22 255
反射 反射（reflection）机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任 意一个对象，都能够调用它的任意方法和属性，既然能拿到那么，我们就可以修改部分类型信息；这种动态获取信 息以及动态调用对象方法的功能称为java语言的反射（reflection）机制 以下了6点很重要： 树化需满足的条件： （考得多）查找成功的平均长度：先用哈希函数算这个数在哪个下标，如果在就是1，如果那个下标已经有值了，就接着找，
Java零基础（二十五）之单例设计模式+枚举+Java8新特性
默主归沙的博客
06-05 513
好处：可读性更强，更容易复用设计模式的归类，分三大类：（23种） 1.对象型模式：对象的创建方式；例如：单例，工厂模式等 2.结构型模式：组织结构的包装；例如：装饰者模式(处理流)，代理模式等 3.行为型模式：对象的行为监听；例如：观察者模式等1.1 工厂模式（重点） 1.2 单例（重点） 单例： 目标：每次获取到的对象都是同一个对象 步骤： 1.通过静态方法返回对象 2.返回的对象是静态属性(静态属性只初始一份) 3.属性私有化 单例中的饿汉式—立即加载的模式 饿汉式 懒汉式 懒汉式在多线程中的安全
注解&&Lambda表达式
qq_43310689的博客
10-13 2357
文章目录一、注解1、注解基础知识2、内置注解2.1、@Override2.2、@Deprecated2.3、@SuppressWarnings3、自定义注解3.1、**定义格式：**3.2、**注解的本质：**3.3、注解属性3.4、元注解4、程序中使用（解析）注解5、综合案例6、后记二、Lambda 表达式1、Lambda 表达式概述语法2、Lambda 表达式实例3、变量作用域4、函数式接口5、常用技巧三、Stream1、什么是 Stream？2、生成流3、操作流3.1、forEach3.2、过滤3.3
JAVA基础-反射-枚举
02-19
java基础，反射枚举基础，自己总结的笔记。
Java中的反射和枚举
weixin_61518137的博客
06-05 732
反射枚举以及面试题
Java——反射与枚举
m0_60867520的博客
07-23 406
反射与枚举的基本概念，使用方法，和使用实例
Java中的反射，枚举和Lambda表达式
qq_61658398的博客
11-23 594
反射常用的类switch语句中使用枚举枚举enum中的常用方法自定义构造枚举对象枚举的安全性2. 什么是Lambda表达式？3. Lambda表达式的基本使用红色标注内容则为重点内容！！！Reflection(反射) 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查。被private封装的资源只能类内部访问，外部是不行的，但反射能直接操作类私有属性。
java反射+枚举+泛型
qq_34117495的博客
10-10 941
1.调用反射的三种方法 2.class.forName 动态编译 静态加载类，是编译时刻加载；动态加载类，是运行时刻加载new创建对象：是静态加载类，在编译时刻就需要加载所有的【可能使用到的类】。有一个类有问题（如不存在），都不能通过编译，会报错。Class.forName()通过动态加载类，可以用到一个类时，才进行加载。【功能性的类尽量使用动态加载，并对新添的类实现功能性接口（标准）
Java基础语法：12.反射,枚举,Lambda的使用
qq_43799599的博客
06-29 229
一、反射 1、定义 Java的反射（reflection）机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性，既然能拿到那么，我们就可以修改部分类型信息；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射（reflection）机制。 2、用途 a、在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法 。 b
Java——枚举、反射、注解
qq_56013994的博客
01-11 350
Java，枚举、反射、注解
java通过反射获取枚举对象
热门推荐
y_hai_yang的博客
10-20 1万+
随着项目的功能越来越多.里面使用到的枚举对象也随之增加,以往是每个枚举都有一个获取的方法,后来网上查了一下.可以通过java的反射机制来获取代码如下 Class<?> onwClass = Class.forName("com.cheshangma.operation.common.enums." + typeName);//这里的typeName就是枚举对象的名称,是需要写全路径的,注意小数点别少
Java大厂面试必备：1000+题库含答案解析
2. **Java高级特性**：如泛型、枚举、注解、Lambda表达式、Stream API、并发工具类、模块化系统(Jigsaw)以及Java 8及以上版本的新特性。 3. **MyBatis**：MyBatis是一个流行的持久层框架，面试题可能包括其工作原理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值