Java注解和反射

已于 2022-03-30 17:51:53 修改
阅读量1.1k 收藏
点赞数 2
分类专栏： Java笔记 文章标签： java intellij idea spring spring boot spring cloud
于 2022-03-30 17:51:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangsf_/article/details/123852669
版权

注解和反射

您的导航

一、注解（Annotation）

注释和注解，一字之差，相似之处也很多，简单的说，注解是给编译器看的注释。

  • JDK5.0引入。
  • 不是程序本身，可以对程序本身做出解释（之恶一点和注释（comment）没什么区别）。
  • 可以被其他程序（如：编译器等）读取。

1.1 认识注解

Java写到现在，我们已经见过不少注解了。

  • @Override 就是重写的注解。

注解就是是以@注释名的形式在代码中存在的，有的还可以添加一些参数，如：

  • @SuppressWarnings(balue=“unchecked”)

那么，注解可以在哪里使用呢？

  • 哪里都可以使用，如附加在：package、class、method、field等上面，相当于给他们添加了额外的辅助信息，我们还可以通过反射机制编程实现对这些元数据的访问。

1.2 内置注解

  1. @Override

    • 定义在java.lang.Override中，适用于修辞方法，表示一个方法打算重写父类中的一个方法。

  2. @Deprecated

    • 定义在java.lang.Deprecated中，适用于修辞方法、类、属性、表示不鼓励程序员使用这样的元素。

  3. @SuppressWarnings

    • 定义在java.lang.SuppressWarnings中，用来抑制编译时的警告信息，与前两个不同的是，这个注解需要加一些参数才能使用，这些参数都是已经定义好了的。
      • @SuppressWarnings("all")
      • @SuppressWarnings("unchecked")
      • @SuppressWarnings(value={"unchecked","deprecation"})
      • ……

代码测试：

public class Test01 {
    // 重写的注解、如果不符合重写规范则会报错
    @Override
    public String toString() {
        return super.toString();
    }

    // 不推荐程序员使用此元素的注解，调用此元素时会出现提示
    @Deprecated
    public static void test() {

    }

    // 添加此注解，下面的方法则不会出现警告
    @SuppressWarnings("all")
    public void test02() {
        List l0ist = new ArrayList<String>();
    }

    public static void main(String[] args) {
        // 会提示test方法已弃用
        test();
    }
}

1.3 元注解

元注解负责注解其他注解，Java定义了4个标准的meta-annotation类型，他们被用来提供对其他的annotation类型说明。

这些类型和它们所支持的类在java.lang.annotation包中

它们是：@Target、@Retention、@Document、@Inherited

1.3.1 元注解作用以及@interface

直接上代码：

@MyAnnotation
public class Test02 {
    @MyAnnotation
    public void test() {

    }
}
// 定义注解 @interface
@Target(value = {ElementType.METHOD, ElementType.TYPE}) // 表示注解可以用在方法和类上，多个参数用逗号隔开
@Retention(value = RetentionPolicy.RUNTIME) //表示注解在什么时候有效 runtime > class > source
@Documented // 表示是否将我们的注解生成在JAVAdoc中
@Inherited // 子类可以继承父类的注解
@interface MyAnnotation {

}

从上述代码中可以看出，自定义注解时，使用@interface来声明。

  • @interface
    • 用来声明一个注解，格式和定义一个类一样，只不过class变成了@interface
    • 其中的每一个方实际上是声明了一个配置参数
    • 方法名就是参数名
    • 返回值类型就是参数类型
    • 可以通过default声明参数默认值
    • 如果只有一个参数，一般命名为value，使用时可以省略参数名
    • 注解元素必须要有值，定义注解元素时常用空字符串、0作为默认值

上代码：

@MyAnnotation2(name = "123", schools = "123")
public class Test03 {
    // 注解可以显式赋值，如果没有默认值，我们就必须给注解赋值
    @MyAnnotation2(schools = {"123", "456"})
    public void test() {
    }
    // 使用时可以不写value
    @MyAnnotation3("abc")
    public void test2() {

    }

}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2 {
    // 注解的参数：参数类型+参数名();
    String name() default "";
    int age() default 0;
    int id() default -1;

    String[] schools();
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3 {
    // 如果只有一个参数，可以用value命名，使用时可以不写value
    String value();
}

二、反射

2.1 静态语言和动态语言

  • 动态语言

    在运行时可以改变其结构：如新的函数、对象、或是代码能被引进，已有的函数可以被删除……

    代表有：Object-C、JavaScript、PHP、Python……

  • 静态语言

    与动态相对应，运行时不可改变其结构，如Java、C、C++。

    虽然Java不是动态语言，但Java可以称之为“准动态语言”。Java具有一定的动态性，我们可以利用反射机制获得类似动态语言的特性。

2.2 反射概述

反射（Reflection）是让Java“动”起来的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性以及方法

就像是一面镜子，可以通过堆内存中的Class对象看到这个类的结构。

2.3 反射的功能

获得反射对象

  1. 已知具体的类可以通过Class属性获取：

    Class c = User.class;

  2. 已知某个类的实例，调用该实例的getClass()方法

    Class c = user.getClass();

  3. 已知一个类的全类名，且在类路径下。

    Class c = Class.forName(“path”);

public class Test02 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println(person.name);

        // 方式一：
        Class c1 = person.getClass();
        System.out.println(c1.hashCode());

        // 方式二：
        Class<Student> c2 = Student.class;
        System.out.println(c2.hashCode());

        // 方式三：
        Class c3 = Class.forName("com.Student");
        System.out.println(c3.hashCode());

        // 方式四：
        Class<Integer> type = Integer.TYPE;
        System.out.println(type);
        
        // 获得父类类型
        Class c4 = c1.getSuperclass();
        System.out.println(c4);
    }
}

class Person {
    String name;

    public Person() {
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

class Student extends Person {
    public Student () {
        this.name = "学生";
    }
}

class Teacher extends Person {
    public Teacher () {
        this.name = "老师";
    }
}

Object类中定义了

public final Class getClass()

是反射的源头

2.4 类（Class）

public class Test03 {
    public static void main(String[] args) {
        Class c1 = Object.class;
        Class c2 = Comparable.class;
        Class c3 = String[].class;
        Class c4 = int[][].class;
        Class c5 = Override.class;
        Class c6 = ElementType.class;
        Class c7 = Integer.class;
        Class c8 = void.class;
        Class c9 = Class.class;

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);

        // 输出：
        /*
           class java.lang.Object
            interface java.lang.Comparable
            class [Ljava.lang.String;
            class [[I
            interface java.lang.Override
            class java.lang.annotation.ElementType
            class java.lang.Integer
            void
            class java.lang.Class   */
    }
}
类的加载与ClassLoader

类加载的过程：

  1. 类的加载：将类的class文件读入内存，并为之创建一个java.lang.Class对象，此过程由类加载器完成
  2. 类的连接：将类的二进制数据合并到JRE中
  3. 类的初始化：JVM负责对类进行初始化

加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象。

连接：将Java类的二进制代码合并到JVM的运行状态之中的过程。

  • 验证：确保加载的类信息符合JVM规范，没有安全方面的问题
  • 准备：正式为类变量(static)分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配
  • 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。

初始化：

  • 执行类构造器<clinit>()方法的过程。类构造器<clinit>()方法是由编译期自动收集类中所有变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
  • 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发父类的初始化。
  • 虚拟机会保证每一个类的<clinit>()方法在多线程环境中被正确加锁和同步。

看一段代码：

public class Test04 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(A.m);
        /* 输出：
            A类静态代码块初始化
            A类的无参构造器初始化
            100     */
    }
}

class A {
    static {
        System.out.println("A类静态代码块初始化");
        m = 300;	
    }
    static int m = 100;	

    public A() {
        System.out.println("A类的无参构造器初始化");
    }
}

加载过程：

  1. 加载到内存， 会产生一个类对应Class对象

  2. 链接。链接结束后 m=0

  3. 初始化

    <clinit>() {

    ​ System.out.println(“A类静态代码块初始化”);

    ​ m = 300;

    ​ m = 100;

    }

发生初始化的条件
  • 类的主动引用（一定发生初始化）
    1. 虚拟机启动，先初始化main方法所在的类
    2. new一个类的对象
    3. 调用类的静态成员（final常量除外）和静态方法
    4. 使用java.lang.reflect包的方法对类进行反射调用
    5. 先初始化一个类，如果父类没有被初始化，则先会初始化它的父类
  • 类的被动引用（不会发生类的初始化）
    1. 当访问一个静态域时，只有真正声明这个域的类才会被初始化。通过子类引用父类的静态变量，不会导致子类初始化。
    2. 通过数组的定义类引用，不会触发此类的初始化
    3. 引用常量不会触发此类的初始（常量在链接阶段就存入调用类的常量池中了）

看代码理解：

public class Test5 {

    static {
        System.out.println("main类被加载");
    }
    public static void main(String[] args) throws ClassNotFoundException {
        // 主动引用
        Son son = new Son();

        // 反射产生主动引用
        Class.forName("com.Son");

        // 不会加载子类
        System.out.println(Son.b);

        // 数组定义不会发生初始化
        Son[] arr = new Son[10];

        // 引用常量不会初始化
        System.out.println(Son.M);
    }
}

class Father {
    static int b = 2;
    static {
        System.out.println("父类被加载");
    }
}

class Son extends Father {

    static {
        System.out.println("子类被加载");
        m = 300;
    }
    static int m = 100;
    static final int M = 1;
}

2.5 类加载器

作用

类加载器将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆内存中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。

分类：

类加载器是用来把类（class）装载进内存的，JVM规范定义了

  1. 引导类加载器
  2. 扩展类加载器
  3. 系统类加载器

上代码：

public class Test06 {
    public static void main(String[] args) throws ClassNotFoundException {
        // 获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);

        // 获取系统类加载器的父类加载器 -> 扩展类加载器
        ClassLoader parent1 = systemClassLoader.getParent();
        System.out.println(parent1);

        // 获取扩展类加载器的父类加载器 -> 根加载器 此加载器无法获得
        ClassLoader parent2 = parent1.getParent();
        System.out.println(parent2);

        // 测试当前类是 由 哪个加载器加载的
        ClassLoader classLoader = Class.forName("com.Test06").getClassLoader();
        System.out.println(classLoader);

        // 测试JDK内置的类是谁加载的
        classLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader);

        // 获取系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));

    }
}

2.6 利用反射获取类的信息

public class Test07 {
    // 获得类的信息
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        User user = new User();
        Class c1 = user.getClass();

        // 获得类的名字
        System.out.println(c1.getName());   // 获得包名 + 类名
        System.out.println(c1.getSimpleName()); // 获得类名

        // 获得类的属性
        Field[] fields = c1.getFields();
        for (Field field : fields) {
            System.out.println(field);  // 不能获取 private 修饰的属性
        }

        fields = c1.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);  // 找到全部属性
        }

        // 获得指定属性值
        Field name = c1.getField("name");
        System.out.println(name);   // 不能获得private修饰的属性

        name = c1.getDeclaredField("age");  // private也能获取
        System.out.println(name);

        // 获得类的方法
        Method[] methods = c1.getMethods(); // 获得本类及父类的所有public方法
        for (Method method : methods) {
            System.out.println("正常的： " + method);
        }

        methods = c1.getDeclaredMethods();  // 获得本类的所有方法
        for (Method method : methods) {
            System.out.println("所有： " + method);
        }

        // 获得指定方法
        Method getName = c1.getMethod("getName",null);
        System.out.println(getName);

        Method test = c1.getDeclaredMethod("test", String.class);
        System.out.println(test);

        // 获得指定的构造器
        Constructor[] constructors = c1.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

        Constructor[] declaredConstructors = c1.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

        // 获得指定的构造器
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        System.out.println(declaredConstructor);
    }
}

2.7 通过反射动态创建对象

public class Test08 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        // 获取对象
        Class c1 = Class.forName("com.User");

        // 创建对象
        User user = (User) c1.newInstance();    // 调用了无参构造器
        System.out.println(user);

        // 通过构造器创建对象
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        User user1 = (User) declaredConstructor.newInstance("abc", 10, 10);
        System.out.println(user1);

        // 通过反射调用普通方法
        User user2 = (User)c1.newInstance();
        Method setName = c1.getDeclaredMethod("setName", String.class);
        setName.invoke(user2, "jerry");
        System.out.println(user2.getName());

        // 通过反射操作属性
        User user3 = (User) c1.newInstance();
        Field name = c1.getDeclaredField("name");

        name.set(user3, "tom");
        System.out.println(user3.getName());

        Field age = c1.getDeclaredField("age");
        age.setAccessible(true);    // 不能直接操作私有属性，需要关闭访问检查
        age.set(user3, 10);
        System.out.println(user3.getAge());
    }
}

  • 创建类的对象：调用Class对象的newInstance()方法

    1. 类必须有一个无参构造器
    2. 类的构造器的访问权限要足够

    如果没有无参构造器，则需要通过Class.getDeclaredConstructor(Class…parameterTypes)取得本类指定形参类型的构造器，然后通过这个构造器创建对象

  • 调用指定方法：通过反射，调用类中的方法，用Method类完成

    1. 通过Class类的getMethod(String name,class…paramenterTypes)方法取得一个Method对象，并设置此方法操作时所需要的参数类型。

    2. 之后使用Object invoke(Object obj, Object[] args)进行调用，并向方法中传递要设置的obj对象参数信息。

      Object invoke(Object obj, Object[] args)

      • Object对应原方法的返回值，若没有则为null
      • 若原方法为静态方法，此时Object obj 可为 null
      • 若原方法形参列表为空，则Object[] args为null
      • 若原方法声明为private，则需要在调用invoke之前，显示调用方法对象的setAccessible(true)方法，即可访问private的方法

    3. setAccessible

      • Method和Field\Constructor对象都有setAccessible()方法。

      • setAccessible作用是启动或禁用访问安全检查的开关

      • 参数值为true则表示反射的对象在使用时应该取消Java语言访问检查。

        提高反射效率，如果必须反射，又需要被频繁调用，那么就设置为true

        使得原本无法访问的私有成员也可访问

      • 参数为false则表示反射对象应该实施Java语言访问检查

2.8 反射操作泛型（了解）

Java采用泛型擦除的机制来引入泛型，确保数据的安全性和免去强制类型转换的问题，一旦编译完成，所有和泛型有关的类型全部擦除

为了通过反射操作这些类型，Java新增了ParameterizedType，GenericArrayType，TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型

public class Test09 {
    public void test01(Map<String, User> map, List<User> list) {
        System.out.println("test01");
    }

    public Map<String, User> test02() {
        System.out.println("test02");
        return null;
    }
    
    public static void main(String[] args) throws NoSuchMethodException {
        // 通过反射获取泛型
        Method method = Test09.class.getMethod("test01", Map.class, List.class);
        Type[] genericParameterTypes = method.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println("#" + genericParameterType);
            if (genericParameterType instanceof ParameterizedType) {
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);
                }
            }
        }

        method = Test09.class.getMethod("test02");
        Type genericReturnType = method.getGenericReturnType();
        if (genericReturnType instanceof ParameterizedType) {
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }
    }
}

2.9 反射操作注解

日后可通过反射获取注解信息，来做很多事情。

// 反射操作注解
public class Test10 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("com.Student2");

        // 通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

        // 获得注解value的值
        TableY annotation = (TableY) c1.getAnnotation(TableY.class);
        System.out.println(annotation.value());

        // 获得类指定的注解
        Field name = c1.getDeclaredField("name");
        FieldY annotation1 = name.getAnnotation(FieldY.class);
        System.out.println(annotation1.columnName());
        System.out.println(annotation1.type());
        System.out.println(annotation1.length());

    }
}

@TableY("db_student")
class Student2{
    @FieldY(columnName = "db_id", type = "int", length = 10)
    private int id;
    @FieldY(columnName = "db_age", type = "int", length = 10)
    private int age;
    @FieldY(columnName = "db_name",type = "varchar", length = 3)
    private String name;

    public Student2() {
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student2{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableY {
    String value();
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldY {
    String columnName();
    String type();
    int length();
}
yangsf_
关注
专栏目录
Java反射、注解
浅谈Android
09-25 1837
最近本着不求甚解的态度重温了一下主流框架的源码，所以趁热打铁的总结一下，学习框架或开发框架所必备的基础知识： Java反射 Java注解 注解代码自动生成 Java动态代理 AOP 一、反射 1.1、简介 本文简单总结一下Java反射和注解，反射可以算是必备条件了，基本学习的主流框架中都会看到反射的身影，他的灵活使用也为很多逻辑的扩展提供了可能，通过Java的反射机制，可以在程序中访...
Java反射和注解
weixin_50264963的博客
07-26 196
一.反射 1.定义 对于任意一个类，都能够知道这个类的所有属性和方法。对于任意一个对象，都能够调用它的任意一个方法和属性，这是由Class对象来完成的，这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 2.作用 反射机制可以用来： 在运行时判断任意一个对象所属的类； 在运行时构造任意一个类的对象; 在运行时判断任意一个类所具有的成员变量和方法; 在运行时调用任意一个对象的方法； 生成动态代理 应用场景： 逆向代码 ，例如反编译 与注...
java 反射和注解
weixin_41765786的博客
07-19 1454
示例12】自定义注解}//如果只有一个配置参数，一般命名为value}@MyAnnoation(id=5,name="张三",scoreArr={78,89,34})}}}定义注解的关键字是@interface自定义注解中可以定义多个配置参数，不是成员方法,不是成员变量；说明参数的名称，以及参数值的类型如果只有一个配置参数，一般命名为value如果配置参数是value，并且只有一个配置参数，value可以省略。...
java反射和注解
loque的博客
11-20 714
ReflectionAndAnnotation本文讲解java的 Reflect、Annotation 反射 和 注解的使用 文中的测试代码请前往 ReflectAndAnnotation反射java的反射机制运行程序在运行时通过反射的APIs取得class的内部信息。 关于反射的文字的说明可以看另一篇博文http://blog.csdn.net/renyuanchunby/article/de
Java注解与反射
qq_41202145的博客
02-22 132
1、注解 1.1 什么是注解 Annotation是从JDK5.0开始引入的新技术 Annotation的作用： 不是程序本身,可以对程序做出解释。 可以被其他程序（比如编译器）读取 Annotation在哪里使用？ 可以加载package,class,method,field等上面使用 1.2 内置注解 @Override 表明一个方法打算重写超类中的另一个方法，防止因程...
Java的注解和反射
萌新Java工程师
11-17 310
注解 参考B站狂什说教程，需要的小伙伴可以去B站关注下UP主 也是我的学习笔记 一.什么是注解 通俗的来说我们的注解就是解释这个类是用来干嘛的 是用来解释类的，这点我们可以百度到很多关于注解的解释，这点我们就不做太多解释，感兴趣的可以搜索下 最简单的例子 public class Test01 extends Object { @Override //这里就是重写注解，代表下面是重写了这个函数 public String toString() { retu
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
一种基于Java注解和反射机制的Excel文件读写操作方法.pdf
06-27
根据提供的文件信息，我们可以梳理出以下知识点： ...以上知识点详细阐述了文档中提到的方法和技术原理，为理解和应用Java注解和反射机制在Excel文件读写操作中的实际应用提供了理论基础和技术指导。
java注解和反射的12个demo.zip
04-28
Java注解和反射是Java编程中的重要特性，它们极大地增强了代码的灵活性和可维护性。在Java中，注解（Annotation）是一种元数据，它提供了将信息附加到代码（类、方法、变量等）的方式，而反射则允许我们在运行时检查...
java注解与反射的基本使用（这一篇就够了！）
12-21
一、注解（Annotation） 1.什么是注解？ 相信大家对注解应该并不陌生，在现在信息飞速发展的年代，各种优秀的框架或许都离不开注解的使用，像我们在实现接口一个方法时，也会有@Override注解。注解说白了就是对程序做出解释，与我们在方法、类上的注释没有区别，但是注解可以被其他程序所读取，进行信息处理，否则与注释没有太大的区别。 2.内置注解 内置注解就是我们的jdk所带的一些注解。常用的三个注解： @Override 这个应该都不陌生，修辞方法，表示打算重写超类中的方法声明。 @Deprecated 这个注解我们应该也不会陌生，我们可能看不到这个注解，但是我们肯定在使用一些方法时会出现
JAVA 注解和反射.7z
04-08
总结，Java注解和反射是Java开发中非常重要的技术，它们极大地增强了Java的灵活性和可扩展性。注解简化了代码，提供了元数据，而反射则允许程序在运行时探索和修改自身的结构，两者共同推动了Java的广泛应用。了解并...
一种基于Java注解和反射机制的Excel文件读写操作方法.zip
10-16
综上所述，基于Java注解和反射机制的Excel文件读写操作方法是一种将面向对象的编程理念应用于数据操作的有效方式。通过这种方式，我们能够以声明式的方式定义数据结构与Excel文件格式之间的映射，从而简化了代码，...
Java——反射及注解
qq_48389943的博客
02-25 474
反射：框架设计的灵魂概念优点获取Class对象的方式Class对象功能 反射：框架设计的灵魂 概念 将类的各个组成部分封装为其他对象。 优点 1.可以在程序运行过程中，操作Class对象 2.可以解耦，提高程序的可扩展性 获取Class对象的方式 /* 获取Class对象的三种方式 1.Class.forName("全类名"); 2.类名.class; 3.对象名.getClass(); .
Java反射与注解
qq_43456605的博客
06-11 2121
Annotation是JDK5.0开始引入的新技术，Annotation不是程序本身，它可以对程序作出解释（这一点和注释没什么区别），但它可以被其他程序读取。注解（Annotations）是一种用于提供元数据的机制，可以被用于类、方法、变量、参数和包等。这些元数据本身对代码的逻辑没有直接影响，但可以被用来影响编译、运行时行为，或者被用来做代码生成、测试和API文档等。标准注解：Java 提供的标准注解，比如 @Override, @Deprecated, @SuppressWarnings。
反射与注解的使用
tbdp6411的专栏
07-10 916
作用：注解是附加在代码中的一些信息，用于编译、运行时解析和使用，起到说明配置作用  主要学习两方面1 元注解，2 自定义注解  一、元注解  包括：1.@Target, 　2.@Retention 　3.@Documented, 4.@Inherited 几种 1 @Target    作用：用于描述注解的使用范围（即 注解是描述：包、类、字段、方法、参数、接口等）
Java中的反射和注解
To_be_Designer
08-05 1632
反射　　反射是将类抽象为一个Class对象。将类看成对象，分析它的构造方法，成员变量，方法以及内部类。 　　对类的分析，是将类抽象为Class对象；对构造方法的分析，是将构造方法抽象为Constructor类的对象；对成员变量的分析，是将变量抽象为Feild类的对象；对方法的分析，是将方法抽象为Method类的对象。 举个例子：public class Student { public
Java-网络
最新发布
2301_81543552的博客
09-14 708
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Java注解与反射详解
"java注解和反射的个人学习笔记" 在Java编程中，注解（Annotation）和反射（Reflection）是两种强大的工具，它们为开发者提供了更高级别的抽象和动态操作能力。注解自JDK 5.0版本起引入，主要用于提供元数据，即...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值