1.1 Java注解和反射

最新推荐文章于 2024-08-04 11:07:52 发布
最新推荐文章于 2024-08-04 11:07:52 发布
阅读量143 收藏
点赞数
分类专栏： Java基础 文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53879048/article/details/123061323
版权

注解 ：不仅人能看，而且程序也能看。

注解有检查和规范的作用。

（1、1.1 ）

 

1、内置注解

（1、1.2 ）

 

2、元注解

（1、1.3 ）

 

package annotation;
​
import java.lang.annotation.*;
​
//测试元注解
@MyAnnotation
public class Test01 {
​
    public void test(){
​
    }
}
​
//定义一个注解
//Target 表示我们注解可以用在那些地方
@Target(value = {ElementType.ANNOTATION_TYPE,ElementType.TYPE})
​
//Retention 表示我们注解在什么地方还有效
@Retention(value = RetentionPolicy.RUNTIME)
//表示是否将注解生成在JavaDOC文档
@Documented
​
// 子类可以继承父类的注解
@Inherited
@interface MyAnnotation{
​
}

3、自定义注解

（1、1.4 ）

 

package annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
​
//自定义注解
public class Test02 {
    //注解可以显示赋值，如果没有默认值，我们就必须给注解赋值
    @MyAnnotation2(name = "hello word",schools = {"1,2,3,4"})
    public void test2(){
​
    }
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
    //注解的参数
    String name();
    int age() default 0;//默认值
    int id() default -1;//如果默认值为-1，代表不存在。
    String [] schools();
}

1.2 反射机制

1、获得反射机制

（1、1.5 ）

 

（1、1.6 ）

 

package reflection;
//什么叫反射
public class Test1 {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的class对象
        Class c1 = Class.forName("reflection.User");
        System.out.println(c1);
​
    }
}
//一个类中只有属性称之为实体类。和数据库去映射。
//实体类 : entity pojo
class User{
    private String name;
    private int age;
    private int id;
    public User(){
​
    }
​
    public User(String name,int age,int id){
        this.name = name;
        this.age = age;
        this.id = id;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    public int getId() {
        return id;
    }
​
    public void setId(int id) {
        this.id = id;
    }
​
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                '}';
    }
}

2、得到class中几种方式

（1、1.7 ）

 

（1、1.8 ）

 

package reflection;
​
//测试class类中方式有哪些
public class Test2 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println("这个人是"+person.name);
​
        //方式一 ：通过对象获得
        Class c1 = person.getClass();
​
        //方式二 ：通过forName 获得
        Class c2 = Class.forName("reflection.Student");
​
        //方式三 ：通过类名.class获得
        Class c3 = Student.class;
​
        //方式四 ：基本内置属性的包装类都有一个Type属性
        Class c4 = Integer.TYPE;
        System.out.println(c4);
​
        //获得父类的类型
        Class c5 = c1.getSuperclass();
        System.out.println(c5);
    }
}
​
class Person{
    public 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 = "老师";
    }
}

3、所有class对象

（1、1.9 ）

 

package reflection;
​
import java.lang.annotation.ElementType;
​
//所有类型的class对象
public class Test3 {
    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;       //基本数据类型，int的包装类
        Class c8 = void.class;          //void
        Class c9 = Class.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);
​
        int [] a = new int[10];
        int [] b = new int[100];
        //两个长度不一样的数组，但是他们都是同一个类型，都是int类型，
        // 他们底层的hashCode都一样
        
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());
​
    }
}
​

4、类加载内存分析

（1、1.10 ）

 

（1、1.11 ）

 

（1、1.12 ）

 

5、类初始化

（1、1.13 ）

 

package reflection;
​
//测试类什么时候初始化
public class Test4 {
    static {
        System.out.println("main类被加载");
    }
​
    public static void main(String[] args) throws ClassNotFoundException {
        //1.主动引用
        Son son = new Son();
​
        //反射也会产生主动引用
        Class.forName("reflection.Son");
​
        //不会产生类的引用方法,子类不会初始化
        System.out.println(Son.b);
​
        //不会加载类
        Son [] array = new Son[10];
​
    }
}
​
class Father{
    static int b = 5;
        static {
            System.out.println("父类被加载");
        }
}
​
class Son extends Father{
    static {
        System.out.println("子类被加载");
        m = 300;
    }
    static int m = 100;
    static final int M = 1;
​
}
​

6、类加载器

（1、1.14 ）

 

（1、1.15 ）

 

package reflection;
​
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
​
public class Test6 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        //获得Class对象
        Class c1 = Class.forName("reflection.User");
​
        //构造一个对象
        User user = (User) c1.newInstance();//本质上是调用无参构造器
        System.out.println(user);
​
        //通过构造器创建对象
        //Constructor Constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        //User user2 = (User) Constructor.newInstance("你好", 1, 18);
        //System.out.println(user2);
​
        //通过反射调用方法
        User user3 =  (User) c1.newInstance();
​
        //通过反射获取一个方法
        Method setName = c1.getDeclaredMethod("setName", String.class);
        
        //invoke : 激活的意思
        //(对象，对象的值)
        setName.invoke(user3,"你好");
        System.out.println(user3.getName());
​
        //通过反射创建属性
        User user4 = (User) c1.newInstance();
        Field name = c1.getDeclaredField("name");
        
        //不能直接操作私有属性，User是私有的在Test一中，我们需要关闭程序安全监测。
        name.setAccessible(true);
        name.set(user4,"你好2");
        System.out.println(user4.getName());
​
    }
}
​

1.3 性能分析

package reflection;
​
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
​
//分析性能问题
public class Test7 {
​
​
    //普通调用方法
    public static void test(){
        
        User user = new User();
        //开始时间
        long startTime = System.currentTimeMillis();
​
        for (int i = 0; i < 1000000000; i++) {
            user.getName();
        }
        //结束时间
        long endTime = System.currentTimeMillis();
​
        System.out.println("普通调用方法"+(endTime-startTime)+"ms");
    }
​
    //反射调用方式
​
    public static void test2() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        
        User user = new User();
        Class c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName", null);
​
        long startTime = System.currentTimeMillis();
​
        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(user,null);
        }
​
        long endTime = System.currentTimeMillis();
​
        System.out.println("反射调用方法"+(endTime-startTime)+"ms");
    }
​
    //反射调用方式 关闭监测
​
    public static void test3() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
       
        User user = new User();
        Class c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName", null);
        
        getName.setAccessible(true);
        long startTime = System.currentTimeMillis();
​
        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(user,null);
        }
​
        long endTime = System.currentTimeMillis();
​
        System.out.println("反射关闭调用方法"+(endTime-startTime)+"ms");
    }
​
    public static void main(String[] args) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException {
        test2();
        test();
        test3();
    }
}
​
​
输出结果 : 
​
反射调用方法2458ms
普通调用方法4ms
反射关闭调用方法1326ms
​

1.4 获取泛型信息

（1、1.16 ）

 

CHONSK
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java：注解和反射
希望有点用
05-21 2357
文章目录 学习视频来自于：秦疆（遇见狂神说）Bilibili地址 他的自学网站：kuangstudy 唯有热爱，能抵岁月漫长
Java中的注解和反射
m0_70990872的博客
07-16 534
Java中的注解和反射
Java 注解和反射
kezhou的博客
05-22 712
注解是 JDK 5.0 引入的新技术。注解是不是程序本身，但可以对程序做出解释；可以被其他程序（比如编译器）读取。注解是以 “@注解名” 在代码中存在，还可以添加一些参数，例如 @SuppressWarnings(value=“ubchecked”)。可以加在 package、class、method、field 等上面，相当于给他们添加额外的信息；我么可以通过反射机制编程实现对这些元数据的访问。使用@interface自定义注解时，自动继承了接口。@interface用来声明一个注解；
Java进阶——注解和反射
万里顾一程的博客
03-26 5953
文章目录Java基础——注解和反射1、注解1.1、什么是注解(Annotation)1.2、内置注解1.3、自定义注解和元注解(meta-annotation)2、反射1、反射和反射机制2、CLass类3、哪些类型可以有Class对象4、类加载理解5、类加载器6、通过反射动态的创建对象7、反射操作注解 Java基础——注解和反射 1、注解 1.1、什么是注解(Annotation) 从JDK5开始,Java增加对元数据的支持，也就是注解，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记， 注解的作
java 反射和注解
weixin_41765786的博客
07-19 1189
示例12】自定义注解}//如果只有一个配置参数，一般命名为value}@MyAnnoation(id=5,name="张三",scoreArr={78,89,34})}}}定义注解的关键字是@interface自定义注解中可以定义多个配置参数，不是成员方法,不是成员变量；说明参数的名称，以及参数值的类型如果只有一个配置参数，一般命名为value如果配置参数是value，并且只有一个配置参数，value可以省略。...
java--注解和反射
qq_45929019的博客
03-06 865
java专题---注解和反射的理解。
Java注解和反射机制
Korbin的博客
08-10 329
文章目录1.注解1.1 注解介绍1.2 内置注解1.3 元注解1.4 自定义注解2.反射机制2.1 Java反射机制概述2.2 获取Class类对象2.2.1 类的class属性2.2.2 Object.getClass()方法2.2.3 Class.forName()方法2.2.4 ClassLoader类加载器2.3 Class类的常用方法2.3 类的加载与ClassLoader2.4 创建运行时类的对象2.5 获取运行时类的完整结构2.6 调用运行时类的指定结构 1.注解 1.1 注解介绍 注解（An
Java注解和反射 01 什么是 Annotation（注解）
小哞^同^学的技术博客
07-21 68
1.1 什么是 Annotation（注解） 注解和反射是所有框架的 底层！比如：Mybatis Springboot …等等。 注解(Annotation)其实和注释(Comment) 很相似！注释是给人看的，但它只给人看。不被其它东西所处理。而注解 虽然也是给人看的，但会被程序所解释。（也就是说 注解既可以给人看，又可以给程序看，甚至还能被其它程序读取。这就是注解的高级之处！） Annoatation 是从 JDK 5.0 开始引入的新技术 Annotation 的作用： 1. 不是程序本身，可
Java入坑之注解和反射
qq_62377885的博客
04-16 540
当我们理解了内置注解, 元注解和获取注解的反射接口后，我们便可以开始自定义注解了。创建自定义注解和创建一个接口相似，但是注解的interface关键字需要以@符号开头，我们可以为注解声明方法。// 元注解public @interface 注解名称{// 属性列表在Java中，我们可以使用@interface关键字来定义自己的注解，这和定义接口或类类似。@Retention(RetentionPolicy.RUNTIME) // 注解保留到运行时。
Java注解和反射
yangsf_的博客
03-30 776
Java注解和反射，通过代码学习。
通过反射获取注解的属性值（源代码)
03-10
通过反射获取注解的属性值 1、获取类上注解的值 1.1 定义注解类 1.2 定义使用注解的类 1.3 测试类 1.4 测试结果 2、获取属性变量上注解的值 2.1 定义注解类 2.2 定义使用注解的类 2.3 定义测试类 2.4 测试结果 3、...
day021-反射和注解笔记和代码.rar
03-16
基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象； 注意 ： 1、 Class类 和它的实例的产生： Class的对象是已经存在的类型， 所以不...
没弄懂这些Java基础，简历上千万别写熟悉：异常+反射+注解+泛型
01-21
Java注解是一种元数据，可以为源代码或类文件添加额外信息。注解本身并不影响程序的执行，但可以通过反射机制在运行时读取这些信息，从而提供额外的功能。 **3.2 注解类型** - **内置注解**：Java提供了几种内置...
枚举工具类
qq_43049583的博客
08-04 201
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
最新发布
泰勒今天想展开的博客
08-04 199
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
社区养老服务小程序的设计
Karen198的博客
07-31 602
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
JavaSE面向对象进阶
qq_45348840的博客
07-30 522
需求：在实际开发中，经常会遇到一些数组使用的工具类;请按照如下要求编写一个数组的工具类：ArrayUtil提供一个工具类方法printArr,用于返回整数数组的内容。返回的字符串格式如：[10,20,50,34,100 ]（只考虑整数数组，且只考虑一维数组)提供这样一个工具方法getAerage,用于返回平均分。（只考虑浮点型数组，且只考虑一维数组)定义一个测试类TestDemo,调用该工具类的工具方法，并返回结果。// 私有化构造方法// 定义静态方法，方便调用。i++) {
Java编程语言：互联网的革命
此外，还会讨论Java的核心概念，如类、对象、包、接口、异常处理、多线程、输入/输出(I/O)、网络编程、数据库连接(JDBC)、集合框架、反射、注解等。通过深入学习这些知识点，读者将能够掌握编写高效、安全和可维护的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值