java注解和反射

最新推荐文章于 2024-10-01 09:29:45 发布
最新推荐文章于 2024-10-01 09:29:45 发布
阅读量318 收藏
点赞数
分类专栏： Java学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37718585/article/details/124201785
版权

一、注解（Annotation）

1.1 作用：

1、不是程序本身，对程序做处解释

2、能被其他程序读取

1.2 内置注解

@Override 重写

@Deprecated 不推荐使用，但是可以使用，或者存在更好的方式

@SuppressWarning 镇压警告

1.3 元注解

负责注解其他注解

@Target 表示注解可以用到哪些地方

@Rentention 表示注解在什么地方才有效 runtime>class>source

@Document 表示是否将注解生成在Javadoc文档中

@Inherited 子类可以继承父类的注解

1.4 自定义注解

1、使用@interface定义

2、可以有参数：参数类型 + 参数名()

3、参数可以设置default默认值，如果没有默认值就必须要给注解赋值；默认值为-1表示不存在

4、如果只有一个参数，可以使用value命名，使用时可以省略参数名

二、反射

通过反射机制实现对元数据（注解）的访问

2.1 java反射机制：

动态语言：在运行时可以根据某些条件改变自身结构

2.2 创建对象的过程

正常创建对象过程：定义一个类，new实例化对象

反射过程：通过对象反射求出类名

2.3 Class类：

  • Class类本身是一个类
  • 只能由系统建立对象
  • 一个加载的类在JVM中只会有一个class实例
  • 一个class对象对应一个在JVM中的.class文件
  • 每个类的实例都会记得自己是由那个Class实例生成的
  • 通过class可以完整地得到一个类中的所有被加载的结构
  • Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得对应的Class对象

2.4 java内存分析

堆：存放new对象和数组，可以被所有线程共享，不会存放别的对象引用

栈：存在基本变量类型（包含这个变量类型的具体数据），引用对象的变量（会存放这个引用在对里面的具体地址）

方法区：可以被所有线程共享，包含所有的class和static变量

2.5 类加载过程：

  • 加载：将class文件字节码内容加载到内存中，并将静态数据转成方法区运行 时数据结构，然后生成java.lang.class对象。
  • 连接：将java类的二进制代码合并到JVM的运行状态中数据的过程。
  • 初始化：<clinit>()方法初始化赋值

2.6 类主动引用（初始化）方法：

  • new对象
  • 反射

2.7 方法运行顺序：main > 父类 > 子类

2.8 类加载器 ClassLoader

引导类加载器（C/C++编写），根加载器，系统读取不到

扩展类加载器

系统类加载器

自定义类加载器

package com.yans.java.reflect;

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

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

        //获取扩展类加载器的父类 --》根加载器，返回null
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

        //测试当前类是由那个类加载器加载的 AppClassLoader
        ClassLoader classLoader = Class.forName("com.yans.java.reflect.Test03").getClassLoader();
        System.out.println(classLoader);

        //测试JDK内置的类是谁加载的 -> 根加载器， 返回null
        ClassLoader classLoader1 = Class.forName("java.lang.String").getClassLoader();
        System.out.println(classLoader1);

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

        //双亲委派机制
        //先找用户类加载器-》找到后，然后找扩展类加载器 -》 找到后，然后根加载器，
        // 如果根加载器存在，其他加载器定义的就会失效
        //自定义一个java.lang.String类，执行会报错找不到，因为根加载器存在了java.lang.String类
    }

}

2.9 通过反射获取类信息

package com.yans.java.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

//获得类信息，通过反射
public class Test04 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class cl = Class.forName("com.yans.java.reflect.User");

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

        //获得类属性
        System.out.println("=======获得属性=====");
        Field[] fields = cl.getFields(); //只能找到public属性

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

        //获得指定属性
        System.out.println("=======获得指定属性=====");
        //Field name = cl.getField("name"); //只能获得public属性
        Field name = cl.getDeclaredField("name");
        System.out.println(name);

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

        Method[] declaredMethods = cl.getDeclaredMethods();// 获得本类及父类所有所有方法
        for (Method method : declaredMethods) {
            System.out.println(method);
        }

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

        System.out.println("=======获得全部构造器=====");
        Constructor[] constructors = cl.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

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

2.10 通过反射动态创建类

package com.yans.java.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

//动态创建对象，通过反射
public class Test05 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        //获取class对象
        Class c1 = Class.forName("com.yans.java.reflect.User");

        //构造一个对象
        //对象类必须要有无参构造器
        //类的访问权限足够
        User user1 = (User) c1.newInstance(); //本质是调用无参构造器
        System.out.println(user1);

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

        //通过反射调用普通方法
        System.out.println("==================");
        User user3 = (User) c1.newInstance();
        //通过反射获取一个方法
        Method setName = c1.getDeclaredMethod("setName", String.class);
        //invoke：激活
        //(对象， “方法的值”)
        setName.invoke(user3, "jack1");
        System.out.println(user3.getName());

        //通过反射操作属性
        System.out.println("==================");
        User user4 = (User) c1.newInstance();
        Field name = c1.getDeclaredField("name");
        //name属性是private私有的，不能直接操作
        //需要关闭安全检查（可以提高效率），通过属性或者方法、构造器的 setAccessible(true) 方法
        name.setAccessible(true);
        name.set(user4, "jack2");
        System.out.println(user4.getName());
    }
}

2.11 通过反射获取泛型

package com.yans.java.reflect;

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;

//通过反射操作泛型
public class Test06 {
    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 = Test06.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 = Test06.class.getMethod("test02", null);
        Type genericReturnType = method.getGenericReturnType(); //获取泛型返回值
        Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments(); //获取真实类型
        for (Type actualTypeArgument : actualTypeArguments) {
            System.out.println(actualTypeArgument);
        }
    }
}

2.12 通过反射获取注解

package com.yans.java.reflect;

import java.lang.annotation.*;
import java.lang.reflect.Field;

//通过反射获取注解
//ORM 对象关系映射
public class Test07 {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("com.yans.java.reflect.Student01");

        //获取类的注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

        //获得注解里value的值
        Table table = (Table) c1.getAnnotation(Table.class);
        System.out.println(table.value());

        //获得属性注解的值
        Field f = c1.getDeclaredField("name");
        FieldAtrribute annotation = f.getAnnotation(FieldAtrribute.class);
        System.out.println(annotation.columName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());

    }
}

@Table("db")
class Student01 {
    @FieldAtrribute(columName = "db_id", type = "int", length = 10)
    private int id;

    @FieldAtrribute(columName = "db_age", type = "int", length = 3)
    private int age;

    @FieldAtrribute(columName = "db_name", type = "varcahr", length = 60)
    private String name;

    public Student01() {
    }

    public Student01(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 "Student01{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

//定义一个类的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table {
    String value();
}

//定义属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldAtrribute {
    String columName();
    String type();
    int length();
}

qq_37718585
关注
专栏目录
Java 中的注解反射
半身风雪
04-12 1347
文章目录一、注解1、注解声明2、元注解3、注解类型元素4、注解的应用场景(1)、SOURCE(2)、CLASS(3)、RUNTIME二、反射1、Class2、获得Class 对象 一、注解 Java 注解（Annotation）又称Java 标注，是JDK5.0 引入的一种注释机制。注解是元数据的一种形式，提供有关于程序但不属于程序本身的数据。注解对它们注解的代码的操作没有直接影响。 1、注解声明 声明一个注解类型 Java 中所有的注解，默认实现Annotation public interface
java注解和反射原理_Java中的注解和反射
weixin_35803802的博客
02-16 1257
最近又回顾了一下 Java 中的注解和反射知识点，注解在日常开发中使用很多，但是反射比较少。值得注意的是 Java 的各种框架底层源码中大量使用了注解和反射，阅读源码，这些是基本功，面试中这部分内容也经常问到。这里面概念不多，内容略微有些枯燥，但是通过一些简单的例子，能让我们明白一些基本概念和 API 的使用。所以，说到底，这篇博客只能算是一个简单的笔记，希望对你有帮助。 以前也写过枚举类和注解...
Java-注解与反射(Java.Annotation)
xuruhua的博客
10-25 234
一、基础 所有的类都继承自Object类 1、注解入门 2、内置注解 eg: (1)@Override 重写的注解 (2)@Deprecated:已经被淘汰,不推荐程序员使用,但是可以使用,或者存在更好的方式 (3)@SuppressWarnings 3、元注解 (一)自定义元注解 一个类里面只能有一个公共的方法,不能有多个public 说明: 点击@Override查看源码中用到的元注解 (1)Target表示我们的注解可以用在哪些地方 (2...
java——反射与注解
Why_does_it_work的博客
06-24 6264
我们可以通过Java的元注解来自定义注解。Java的元注解包括@Retention、@Target、@Inherited和@Documented。其中，@Retention用于指定注解的生命周期，@Target用于指定注解可以应用于哪些元素，@Inherited用于指定子类是否继承注解，@Documented用于指定注解是否出现在Java文档中。上述代码定义了一个名为MyAnnotation的注解，它有两个属性：name和age。
Retrofit中的注解反射与动态代理
soulli的专栏
03-07 638
注解的应用场景 1.源码：APT注解处理器 Annotatino Processing Tool, 作用是处理代码中的注解, 用来生成代码, 用代码生成代码的工具。 2.字节码：字节码增强 打开运行时JVM的钥匙，动态代理 、AOP也与字节码增强有关。 3.运行时：反射 是java被视为动态语言的关键 ...
Java注解与反射
weixin_64026220的博客
07-20 825
Java注解与反射的学习
Java注解和反射
qq_39565343的博客
03-02 2035
一、注解 注解（Annotation）： 从jdk5.0开始引进，可以对程序进行解释或被其他程序读取。 注解格式："@注释名"，并可以添加一些参数。 例：@MyAnnotation(value=‘value’) 1、内置注解 @override： 用于修饰方法，表示该方法声明是重写或实现一个父类的方法 @Deprecated： 用于修饰方法、属性、类，表示已过时不建议使用的 @SuppressWarnings： 用于抑制编译时的警告信息 2、元注解 作用：用于注解其他注解 @Target： 用于描述注解的适
Java：注解和反射
希望有点用
05-21 2495
文章目录 学习视频来自于：秦疆（遇见狂神说）Bilibili地址 他的自学网站：kuangstudy 唯有热爱，能抵岁月漫长
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
一种基于Java注解和反射机制的Excel文件读写操作方法.pdf
06-27
根据提供的文件信息，我们可以梳理出以下知识点： ...以上知识点详细阐述了文档中提到的方法和技术原理，为理解和应用Java注解和反射机制在Excel文件读写操作中的实际应用提供了理论基础和技术指导。
java注解和反射的12个demo.zip
04-28
Java注解和反射是Java编程中的重要特性，它们极大地增强了代码的灵活性和可维护性。在Java中，注解（Annotation）是一种元数据，它提供了将信息附加到代码（类、方法、变量等）的方式，而反射则允许我们在运行时检查...
JAVA 注解和反射.7z
04-08
总结，Java注解和反射是Java开发中非常重要的技术，它们极大地增强了Java的灵活性和可扩展性。注解简化了代码，提供了元数据，而反射则允许程序在运行时探索和修改自身的结构，两者共同推动了Java的广泛应用。了解并...
一种基于Java注解和反射机制的Excel文件读写操作方法.zip
10-16
综上所述，基于Java注解和反射机制的Excel文件读写操作方法是一种将面向对象的编程理念应用于数据操作的有效方式。通过这种方式，我们能够以声明式的方式定义数据结构与Excel文件格式之间的映射，从而简化了代码，...
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 694
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 646
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
spring-boot 整合 mybatis
m0_72168501的博客
09-29 476
spring boot 整合 mybatis
Java内存布局
最新发布
阿呆的专栏
10-01 758
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 308
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
Java注解与反射详解
"java注解和反射的个人学习笔记" 在Java编程中，注解（Annotation）和反射（Reflection）是两种强大的工具，它们为开发者提供了更高级别的抽象和动态操作能力。注解自JDK 5.0版本起引入，主要用于提供元数据，即...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值