注解与反射-笔记

最新推荐文章于 2024-09-10 10:21:38 发布
最新推荐文章于 2024-09-10 10:21:38 发布
阅读量76 收藏
点赞数
分类专栏： Java # Java基础 文章标签： 反射 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mistyzcc/article/details/114849751
版权

概要

注解和注释
注释：给人看
注解：给人看，“解”：加给程序看
Java.Annotation

文章目录

1、内置注解

//java.lang
//重写
@Override

//废弃
@Deprecated

//抑制编译时警告信息
@SuppressWarnings

2、元注解

元注解：解释其他注解的注解

@Target
用来描述注解的使用范围
@Retention
表示需要在什么级别保存注释信息，用于描述注释的生命周期
（SOURCE[源代码的时候]《CLASS[.class的时候有用]<RUNTIME[运行时有用]）
@Document
说明该注解将被包含在javadoc中
@Inherited
说明子类可以继承父类中的该注解

3、自定义注解

//自动继承java.lang.annotation.Annotation接口
public @interface 注解名{
	//方法其实是注解的一个参数
	(返回值类型是String,Class,enum)method()
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
    //参数
    String name() default "";
    int age() default 0;
    //默认值为-1，代表找不到
    int id() default -1;

    String[] schools();
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
    //使用注解的时候可以不用加参数名
    String value();
}

4、反射

reflect可以直接改变内部对象
创建对象：new 、clone 、反射[运行时创建对象]
使用反射机制，使得静态的Java变成准动态语言

加载完类之后，在堆内存的方法区产生了一个Class对象（一个类对应一个Class对象）

java.lang.Class
java.lang.reflect

Class类是描述类的类
Class对象只能由系统创建
一个加载类在JVM中只有一个Class实例
一个Class对象对应一个加载到JVM的一个.class文件

Class类的方法
获取Class类的实例
a) Person.class;
b) person.getClass();
c) Class.forName(“demo01.Student”);

Person student = new Student();
        System.out.println("this person:"+student.name);

        Class c1 = student.getClass();
        System.out.println(c1.hashCode());

        Class c2 = Class.forName("com.kuang.reflection.Student");
        System.out.println(c2.hashCode());

        Class c3 = Student.class;
        System.out.println(c3.hashCode());

        Class type = Integer.TYPE;
        System.out.println(type);

        Class c5 = c1.getSuperclass();
        System.out.println(c5);

5、不同类型的Class

Class<Object> c1 = Object.class;
        Class<Comparable> c2 = Comparable.class;
        Class<String[]> c3 = String[].class;
        Class<String[][]> c4 = String[][].class;
        Class<Override> c5 = Override.class;
        Class<ElementType> c6 = ElementType.class;
        Class<Integer> c7 = Integer.class;
        Class<Void> c8 = void.class;
        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);

        //元素类型和维度一样的是同一个类型
        int[] a =new int[10];
        int[] b =new int[100];
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());

		//output
		class java.lang.Object
		interface java.lang.Comparable
		class [Ljava.lang.String;
		class [[Ljava.lang.String;
		interface java.lang.Override
		class java.lang.annotation.ElementType
		class java.lang.Integer
		void
		class java.lang.Class
		356573597
		356573597

6、内存分析

Java内存分为堆、栈、方法区（特殊的堆）
堆：存放new的对象和数组；可以被所有线程所共享，不会存放别的对象引用
栈：存放基本类型变量（包含这个基本类型的具体数值）；引用对象的变量（会存放这个引用在堆里面的具体地址）
方法区：可以被所有线程共享；包含所有class和static变量

类加载过程
程序主动使用某个类时，三步骤：
类的加载->类的链接->类的初始化

  • 1.类的加载：将.class文件读入内存方法区，随后在堆中创建一个java.lang.Class对象

  • 2.类的链接：将类的二进制代码合并到JVM运行状态之中的过程
    – 验证：
    – 准备：为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都在方法区中进行分配
    – 解析：虚拟机常量池中符号引用（常量名）替换成直接引用（地址）的过程

  • 3.类的初始化：执行构造器方法是由编译期自动收集所有类变量的赋值动作和静态代码块中的语句合并产生。（类构造器是构造类信息的，不是构造该对象构造器）
    在这里插入图片描述

package com.kuang.reflection;

public class test05 {

    static {
        System.out.println("main加载");
    }
    public static void main(String[] args) {
        A a = new A();
        System.out.println(A.m);
        System.out.println(B.n);
        B b= new B();
    }
}

class A{


    static int m = 100;
    static void find(){
        System.out.println("find");
    }

    static{
        System.out.println("Astatic代码块");
        m=300;
    }

    public A() {
        this.m= 10;
        System.out.println("A类无参构造方法");
    }
}

class B{


    static int n = 150;
    static void find(){
        System.out.println("find");
    }

    static{
        System.out.println("Bstatic代码块");
        n=350;
    }

    public B() {
        System.out.println("B类无参构造方法");
    }
}


//output
main加载
Astatic代码块
A类无参构造方法
10
Bstatic代码块
350
B类无参构造方法

类会初始化：

package com.kuang.reflection;

public class test06 {
    static {
        System.out.println("main加载");
    }
    public static void main(String[] args) throws ClassNotFoundException {
        Son son = new Son();

        Class<?> c1 = Class.forName("com.kuang.reflection.Son");

        Father father = new Father();
    }
}

class Father{
    static int b = 2;
    static {
        System.out.println("father");
    }

    public Father() {
        System.out.println("father constrance");
    }
}

class Son extends Father{
    static {
        System.out.println("son");
        m=300;
    }

    static int m=100;
    static final int M =1;

    public Son() {
        System.out.println("son constrance");
    }
}

//output
main加载
father
son
father constrance
son constrance
father constrance

类不会被初始化,类的被动引用

package com.kuang.reflection;

public class test06 {
    static {
        System.out.println("main加载");
    }
    public static void main(String[] args) throws ClassNotFoundException {


        System.out.println(Son.b);

        Son[] array = new Son[5];

        System.out.println(Son.M);
    }
}

class Father{
    static int b = 2;
    static {
        System.out.println("father");
    }

    public Father() {
        System.out.println("father constrance");
    }
}

class Son extends Father{
    static {
        System.out.println("son");
        m=300;
    }

    static int m=100;

    //常量池中的变量
    static final int M =1;

    public Son() {
        System.out.println("son constrance");
    }
}

在这里插入图片描述

7、类加载器的作用

在这里插入图片描述

package com.kuang.reflection;

public class test07 {
    public static void main(String[] args) throws ClassNotFoundException {
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);

        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);

        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

        ClassLoader classLoader = Class.forName("com.kuang.reflection.test07").getClassLoader();
        System.out.println(classLoader);

        ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader1);

        System.out.println(System.getProperty("java.class.path"));

        //双亲委派机制
        //找包的时候找最上层的，如果找不到再往下找

    }
}

8、反射常用方法

package com.kuang.reflection;

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

public class test08 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class<?> c1 = Class.forName("com.kuang.reflection.User");

        System.out.println(c1.getName());
        System.out.println(c1.getSimpleName());

        System.out.println("============");
        //get public field
        Field[] fields = c1.getFields();
        for (Field field : fields){
            System.out.println(field);
        }
        //get private field
        fields = c1.getDeclaredFields();
        for (Field field : fields){
            System.out.println(field);
        }

        Field name = c1.getDeclaredField("name");
        System.out.println(name);

        System.out.println("=========================");
        //get father && son public method
        Method[] methods = c1.getMethods();
        for (Method method:methods){
            System.out.println("public:"+method);
        }

        //only get son all method
        methods = c1.getDeclaredMethods();
        for (Method method:methods){
            System.out.println("private:"+method);
        }

        Method getNaem = c1.getMethod("getNaem", null);
        System.out.println(getNaem);
        Method setNaem = c1.getMethod("setNaem", String.class);
        System.out.println(setNaem);

        System.out.println("============================");
        //get public constructor
        Constructor[] constructors = c1.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }

        //get private constructor
        constructors = c1.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.println("$"+constructor);
        }

        Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        System.out.println(constructor);
    }
}

实际对象使用

package com.kuang.reflection;

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

public class test09 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        Class c1 = Class.forName("com.kuang.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("zcc", 001, 18);
//        System.out.println(user2);

        //通过反射调用普通方法,因为传递参数是写死在程序中的，所以通过反射，可以重新传递参数
        User user3 = (User) c1.newInstance();
        Method setNaem = c1.getDeclaredMethod("setNaem", String.class);
        setNaem.invoke(user3, "zcc");
        System.out.println(user3.getNaem());

        //通过反射设置操作属性
        User user4 = (User) c1.newInstance();
        Field name = c1.getDeclaredField("name");
        //取消安全检测，访问private属性
        name.setAccessible(true);
        name.set(user4,"mistyzcc");
        System.out.println(user4.getNaem());

    }
}



//反射获取方法和普通获取方法效率问题
package com.kuang.reflection;

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

public class test10 {
    public static void test1(){
        User user = new User();

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 100000000; i++) {
            user.getNaem();
        }

        long endTime = System.currentTimeMillis();

        System.out.println("1:"+(startTime-endTime));
    }

    public static void test2() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user = new User();
        Class c1 = user.getClass();
        Method getNaem = c1.getDeclaredMethod("getNaem", null);
        getNaem.invoke(user,null);

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 100000000; i++) {
            getNaem.invoke(user,null);
        }

        long endTime = System.currentTimeMillis();

        System.out.println("1:"+(startTime-endTime));
    }

    public static void test3() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user = new User();
        Class c1 = user.getClass();
        Method getNaem = c1.getDeclaredMethod("getNaem", null);
        getNaem.invoke(user,null);
        getNaem.setAccessible(true);
        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 100000000; i++) {
            getNaem.invoke(user,null);
        }

        long endTime = System.currentTimeMillis();

        System.out.println("1:"+(startTime-endTime));
    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        test1();
        test2();
        test3();
    }
}

9、反射操作泛型

java采用泛型擦出机制，仅仅给javac编译器使用，确保数据安全性和免去强制类型转换问题，编译完成后，泛型擦除

在这里插入图片描述

package com.kuang.reflection;

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 test11 {
    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 = test11.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);
                }
            }
        }
    }
}

//output
#java.util.Map<java.lang.String, com.kuang.reflection.User>
class java.lang.String
class com.kuang.reflection.User
#java.util.List<com.kuang.reflection.User>
class com.kuang.reflection.User

10、反射获取注解

ORM：Object Relationship Mapping
类和表结构对应
属性和字段对应
对象和记录对应

mistyzcc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Class<Object>与Class<?>有何区别
~
01-29 995
最近在项目中写了一些底层的公共方法，写公共方法不同于写普通方法，有很多的参数都是不具体的指明某个类或者对象的，所以只能用object，class等这些通用的东西代替，所以在做的同时也学习了一些基础的东西。可能很多人已经觉得这很基础了，不过由于没有亲自在项目中写过这些公共的内容，对这些细节思考的还是很少的，现在分享一下自己的一点小收获。 1、? 和 Object 差不多，不过还是有差别
注解与反射_学习笔记
qq_41494557的博客
05-30 236
注解与反射 前言 在B站跟着狂神学习注解与反射的一些笔记，后期若有补充会更新该博文，加油！ 什么是注解？ 注解 Annotation是JDK5开始引入的技术 Annotation作用： 不适程序本身，可以对程序作出解释 可以被其他程序读取，例如编译器 Annotation的格式： 注解是以“@注解名”在代码中存在，还可以添加参数值，例如@SuppressWarning(value=“unchecked” ). Annotation在哪儿使用？ 可以在package、class、method、fie
所有类型的class对象
bianboxian018323的博客
08-11 125
package reflection; import java.lang.annotation.ElementType; //所有类型的class public class Test04 { public static void main(String[] args) { Class<Object> c1 = Object.class; //类 Class<Comparable> c2 = Comparable.class; //接口.
注解与反射-复习
Hello_ZhangCL的博客
04-05 168
文章目录注解内置注解元注解自定义注解反射机制简介Class类Java内存**类加载的过程**ClassLoader反射获取运行时类的结构信息动态创建对象通过反射创建对象 (一般情况)通过"构造器对象"创建对象 (不存在无参构造)通过反射调用成员:methodfield测试: 性能分析反射获取泛型数据反射获取注解数据 基于B站秦疆老师的课. 非常感谢! 注解 @since JDK1.5 不是程...
应用开发--反射
tyf2007635的博客
11-10 153
动态语言 vs 静态语言 1 、动态语言 是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。 主要动态语言：Object-C、C#、JavaScript、PHP、Python、Erlang。 2 、静态语言 与动态语言相对应的，运行时结构不可变的语言就是静态语言。如J...
注解与反射
taraex的博客
06-13 324
注解 注解（Annotation） 作用： 1.不是程序本身 , 可以对程序作出解释.(这一点和注释(comment)没什么区别) 2.可以被其他程序(比如:编译器等)读取 格式： 注解是以"@注释名"在代码中存在的 , 还可以添加一些参数值 , 例如:@SuppressWarnings(value=“unchecked”). 在哪里使用？ 可以附加在package , class , metho...
注解与反射-狂神说Java学习笔记
07-22
在Java编程语言中，注解（Annotation）和反射（Reflection）是两个非常重要的高级特性，它们为程序提供了元数据信息和运行时动态操作类的能力。本文将深入探讨这两个概念及其在实际开发中的应用。 首先，让我们了解...
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
注解与反射---狂胜说Java学习笔记
rzz65452064的博客
04-05 429
注解与反射 狂神说Java[注解与反射]视频网址 新词 解析 归类 Annotation 注解 注解 package 包 class 类 method 方法 field 属性 constructor 构造器 Override 重写注解 注解 Deprecated 不鼓励使用 注解 SuppressWarnings 删除警告 注解 .getAnnotation() 获得指定注解 注解 .getAnnotations() 获得所有注解 注解
【狂神说笔记—— Java基础13-注解与反射】
weixin_46055348的博客
07-10 258
【狂神说笔记—— Java基础13-注解与反射】
Spring全注解开发---常用注解笔记整理
2401_84010061的博客
04-18 416
互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！框架也可以使用，至于其他框架，只要对其做了对应的支持同样也可以使用@Resource和@Autowired注解都是用来实现依赖注入的。只是@AutoWried默认先按by type自动注入，而@Resource默认按byName自动注入。@Resource有两个重要属性，分别是name和typespring将name属性解析为bean的名字，而type属性则被解析为bean的类型。
spring事务详细讲解-深入浅出
小电玩
09-08 421
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1424
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1353
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 353
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 496
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
自定义Stater
m0_63624484的博客
09-07 694
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
基于JavaWeb开发的JavaSpringboot+Vue实现前后端分离房屋租赁系统
央顺科技官方博客
09-05 557
2021年处于信息科技高速发展的大背景之下。在今天，缺少手机和电脑几乎已经成为不可能的事情，人们生活中已经难以离开手机和电脑。针对增加的成本管理和操作,各大商家非常有必要建立自己的网上房屋租赁平台系统，这既可以让更多的人体验到网络所带来的方便，也有助于提高房屋的租赁。在经过几十年的高速发展后，互联网已成为最流行、最普及的媒体，每天的信息流量甚至能比得上过去十年。其以便捷的信息交换、快速的沟通速度，悄然地改变着会员的消费方式。
MyBatis面试
Tony_yitao的博客
09-09 559
MyBatis面试
Java注解与反射详解
"java注解和反射的个人学习笔记" 在Java编程中，注解（Annotation）和反射（Reflection）是两种强大的工具，它们为开发者提供了更高级别的抽象和动态操作能力。注解自JDK 5.0版本起引入，主要用于提供元数据，即...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值