注解与反射详解

最新推荐文章于 2024-05-31 09:20:54 发布
最新推荐文章于 2024-05-31 09:20:54 发布
阅读量321 收藏 2
点赞数 1
分类专栏： Java 文章标签： java 反射 编程语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zSoaring/article/details/112531881
版权

文章目录

注解

什么是注解

  • 注解（Annotation）可以对程序作出解释，并且可以被其他程序（比如：编译器等）读取（通过反射读取）。
  • 注解是以"@注释名"在代码中存在的，还可以添加一些参数值，例如@SuppressWarnings(value=“unchecked”)。
  • 注解可以附加在package，class，method，field等上面，相当于给他们添加了额外的辅助信息，从而可以通过反射机制编程实现对这些元数据的访问。

在这里插入图片描述

上图的两个示例就是两个注解，并且为内置注解，可以起到检查和约束的作用，我们挑几个详细说一下。

  1. @Override：定义在java.lang.Override中，它只能适用于修辞方法，表示一个方法声明打算重写超类中的另一个方法声明。
  2. @Deprecated：定义在java.lang.Deprecated中，它可以用于修辞方法，属性，类，表示不推荐程序员使用，因为它很危险或者存在更好的选择。
  3. @SuppressWarnings：定义在java.lang.SuppressWarnings中，用来抑制编译时的警告信息。与前面两个不同的是，这个注解需要添加一个参数才能正确使用，这些参数都是已经定义好了的，选择性适用。例如：@SuppressWarnings(“all”)

元注解

  • 元注解的作用就是负责注解其他注解，Java定义了4个标准的meta-annotation类型，他们被用来提供对其他annotation类型作说明。
  • 这些类型和它们所支持的类在java.lang.annotation包中可以找到(@Target,@Retention,@Documented,@Inherited)
    • @Target:用来描述注解的适用范围(即：被描述的注解可以用在什么地方)
    • @Retention:表示需要在什么级别保存该信息，用于描述注解的生命周期(SOURCE < CLASS < RUNTIME)
    • @Document：说明该注解将被包含在javadoc中
    • @Inherited：说明子类可以继承父类中的该注解
import java.lang.annotation.*;
//测试元注解
public class Test02 {
    @MyAnnotation
    public void test(){

    }
}
//定义一个注解
//Target表示我们的注解可以用在哪些地方
@Target(value = {ElementType.METHOD,ElementType.TYPE})

//Retention 表示注解在什么地方还有效
@Retention(value = RetentionPolicy.RUNTIME)

//Documented 表示是否将我们的注解生成在JAVADOC中
@Documented

//Inherited 子类可以继承父类的注解
@Inherited
@interface MyAnnotation{

}

自定义注解

使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口。

  • @interface 用来声明一个注解，格式：public @interface 注解名{定义内容}
  • 其中的每一个方法实际上是声明了一个配置参数，方法的名称就是参数名称，可以通过default来声明参数的默认值
  • 返回值类型就是参数的类型(返回值只能是基本类型，Class，String，enum)
  • 如果只有一个参数成员，一般参数名为value
  • 注解元素必须要有值，定义注解元素时，经常使用空字符串，0作为默认值。
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//自定义注解
public class Test03 {
    //注解可以显示复制，如果没有默认值，就必须给注解赋值
    @MyAnnotation2(name = "哈哈",schools = {"西北大学","清华大学"})
    public void test(){}

    //如果注解只有一个值，那么可以省略,直接使用默认
    @MyAnnotation3("")
    public void test2(){}
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
    //注解的参数：参数类型 参数名();
    String name() default "";
    int age() default 0;
    int id() default -1;//如果默认值为-1,代表不存在

    String[] schools();
}
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
    String value();
}

反射机制

反射概述

反射(Reflection)机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。反射的优点是可以实现动态创建对象和编译，体现出很大的灵活性；缺点是对性能有影响。

例如：Class c = Class.forName("java.lang.String");

加载完类之后，在堆内存的方法区就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息，我们可以通过这个对象看到类的结构。

Java反射机制提供的功能

  • 在运行时判断任意一个对象所属的类
  • 在运行时构造任意一个类的对象
  • 在运行时判断任意一个类所具有的成员变量和方法
  • 在运行时获取泛型信息
  • 在运行时调用任意一个对象的成员变量和方法
  • 在运行时处理注解
  • 生成动态代理等等

反射相关的主要API

  • java.lang.Class:代表一个类
  • java.lang.reflect.Method:代表类的方法
  • java.lang.reflect.Field:代表类的成员变量
  • java.lang.reflect.Constructor:代表类的构造器

Class类

对于每个类而言，JRE都为其保留一个不变的Class类型的对象。

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

那么如何获取Class类的实例呢?

  • 已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高。

    Class clazz = Person.class;

  • 已知某个类的实例，调用该实例的getClass()方法获取Class对象，getClass()方法是Object提供的方法，所以所有的类都有。

    Class clazz = person.getClass();

  • 已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException

    Class clazz = Class.forName("code_2021_0110.Student");

  • 内置基本数据类型可以直接用类名.TYPE

详细代码如下：

public class Test06 {
    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());

        //方式二：forname获得
        Class c2 = Class.forName("code_2021_0110.Student");
        System.out.println(c2.hashCode());

        //方式三：通过类名.class获得
        Class c3 = Student.class;
        System.out.println(c3.hashCode());

        //方式四：基本内置类型的包装类都有一个Type属性
        Class c4 = Integer.TYPE;

        //获得父类类型
        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对象？

class（外部类，成员内部类，静态内部类，局部内部类，匿名内部类）、interface（接口）、[] ( 数组 )、enum（枚举）、annotation（注解）、primitive type（基本数据类型包装类）、void。

类加载内存分析（扩充）

堆、栈、方法区回顾：

在这里插入图片描述

类的加载：

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

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

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

  • 初始化：

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

    那么接下来就通过代码来探索一下这个过程。

    public class Test07 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println(a.m);
        /*
        1.加载到内存，会产生一个类对应Class对象
        2.链接，链接结束后 m = 0
        3.初始化
            <clinit>(){
                System.out.println("A类静态代码块初始化");
                m = 300;
                m = 100;
            }
         */
    }
}

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

    static int m = 100;

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

运行结果：

在这里插入图片描述

什么时候会发生初始化？

  • 类的主动引用（一定会发生类的初始化）
    • 当虚拟机启动，先初始化main方法所在的类
    • new一个类的对象
    • 调用类的静态成员（除final常量）和静态方法
    • 使用java.lang.reflect包的方法对类进行反射调用
    • 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类
  • 类的被动引用（不会发生类的初始化）
    • 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化。
    • 通过数组定义类引用，不会触发此类的初始化
    • 引用常量不会触发此类的初始化（常量在链接阶段就存入调用的常量池中了）
//测试类什么时候会初始化
public class Test08 {
    static {
        System.out.println("Main类被加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        //1.主动引用
        Son son = new Son();
        //反射也会产生主动引用
        Class.forName("code_2021_0110.Son");
        /*运行结果分别都是：
        Main类被加载
        父类被加载
        子类被加载
        */

        //2.被动引用
        System.out.println(Son.b);
        /*运行结果：
        Main类被加载
        父类被加载
        2
        */

        Son[] array = new Son[5];
        /*运行结果：
        Main类被加载
        */

        System.out.println(Son.M);
        /*运行结果：
        Main类被加载
        1
        */
    }
}

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;
}

注：以上main方法里都是单独执行的结果。

类加载器：

类加载器作用是把类装载进内存的。JVM规范定义了如下类型的类的加载器。

在这里插入图片描述

  • Bootstap Classloader（引导类加载器）：用C++编写的，是JVM自带的类加载器，负责Java平台核心库，用来装载核心类库。该加载器无法直接获取。
  • Extension Classloader（扩展类加载器）：负责jre/lib/ext目录下的jar包或-D java.ext.dirs指定目录下的jar包装入工作库。
  • System Classloader（系统类加载器）：负责java -classpath或-D java.class.path所指的目录下的类与jar包装入工作，是常用的加载器。
public class Test09 {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);

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

        //获取扩展类加载器的父类加载器-->根加载器（c/c++),无法直接获取，所以为null
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

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

        //测试JDK内置类是谁加载的
        ClassLoader classLoader1 = Class.forName("java.util.Collections").getClassLoader();
        System.out.println(classLoader1);


    }
}

获取运行时类的结构

Class类的常用方法：

方法名功能说明
static ClassforName(String name)返回指定类名name的Class对象
Object newInstance()调用缺省构造函数，返回Class对象的一个实例
getName()返回此Class对象所表示的实体(类，接口，数组类或void)的名称
Class getSuperClass()返回当前Class对象的父类的Class对象
Class[] getinterfaces()获取当前Class对象的接口
ClassLoader getClassLoader()返回该类的类加载器
Constructor[] getConstructors()返回一个包含某些Constructor对象的数组
Method getMothed(String name,Class… T)返回一个Method对象，此对象的形参类型为paramType
Field[] getDeclaredFields()返回Field对象的一个数组
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

//获得类的信息
public class Test10 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("code_2021_0110.User");

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

        //获得类的属性
        Field[] fields = c1.getFields();//只能找到public属性

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

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

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

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

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

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

动态创建对象执行方法

对象的创建：

  1. 创建类的对象(无参创建)：调用Class对象的newInstance()方法
    • 类必须有一个无参构造器。
    • 类的构造器的访问权限需要足够
  2. 创建类的对象(指定构造器创建)
    • 通过Class类的getDeclaredConstructor(Class…parameterTypes)取得本类的指定形参类型的构造器
    • 向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。
    • 通过Constructor实例化对象。

调用指定方法：

  1. 通过反射，调用类中的方法，Method类完成
    • 通过Class类的getMethod(String name,Class…parameterTypes)方法取得一个Method对象，并设置此方法操作时所需要的参数类型。
    • 之后使用Object invoke(Object obj,Object[] args)进行调用，并向方法中传递要设置的obj对象的参数信息。
  2. 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语言访问检查。

代码示例：

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

//动态的创建对象，通过反射
public class Test11 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        Class c1 = Class.forName("code_2021_0110.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("用户",001,18);
        System.out.println(user1);

        //通过反射调用普通方法
        User user2 = (User)c1.newInstance();
        Method setName = c1.getDeclaredMethod("setName", String.class);
        //invoke:激活
        //(对象，“方法的值”）
        setName.invoke(user2,"哈哈");
        System.out.println(user2.getName());

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

        //不能直接操作私有属性，需要关闭程序的安全监测，属性或方法的setAccessible(true).
        name.setAccessible(true);//默认是false的,修改为true
        name.set(user3,"嘿嘿");
        System.out.println(user3.getName());

    }
}

运行结果：

在这里插入图片描述

性能分析

监测直接调用方法和反射调用方法的性能。

//性能分析
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Test12 {
    //普通方式调用
    public static void test01(){
        User user = new User();
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            user.getName();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("普通方法执行10亿次："+(endTime-startTime)+"ms");
    }

    //反射方式调用
    public static void test02() 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("反射方式执行10亿次："+(endTime-startTime)+"ms");
    }

    //反射方式关闭检测后
    public static void test03() 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("关闭检测执行10亿次："+(endTime-startTime)+"ms");
    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        test01();
        test02();
        test03();
    }
}

运行结果：

在这里插入图片描述

获取泛型信息

Java采用泛型擦除机制来引入泛型，Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除。为了通过反射操作这些类型，Java新增了ParameterizedType，GenericArrayType，TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型。

  • ParameterizedType：表示一种参数化类型，比如Collection< String >
  • GenericArrayType:表示一种元素类型是参数化类型或者类型变量的数组类型
  • TypeVariable：是各种类型变量的公共父接口
  • WildcardType：代表一种通配符类型表达式
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 Test13 {
    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 = Test13.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);
                }
            }
        }

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

运行结果：

在这里插入图片描述

反射操作注解

getAnnotation与getAnnotations

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

public class Test14 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("code_2021_0110.People");
        //通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        
        //获得注解的value值
        Table1 table = (Table1)c1.getAnnotation(Table1.class);
        String value = table.value();
        System.out.println(value);

        //获得类指定的注解
        Field f = c1.getDeclaredField("name");
        Field1 annotation = f.getAnnotation(Field1.class);
        System.out.println(annotation.colName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());
    }
}

@Table1("db_People")
class People{

    @Field1(colName = "de_id",type = "int",length = 10)
    private int id;
    @Field1(colName = "de_age",type = "int",length = 10)
    private int age;
    @Field1(colName = "de_name",type = "varchar",length = 3)
    private String name;

    public People(){}

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

//类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table1{
    String value();
}

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

运行结果：
在这里插入图片描述

郭贼不是我的菜
关注
专栏目录
注解与反射
猫宁的博客
03-03 180
注解 注解与注释的区别 内置注解：基本除了Override其他注解都已经淘汰 元注解 作用：用于定义注解其他注解 自定义注解 只有参数设置为value，传参的时候才可以忽略参数名称字段 反射机制 基本原理 个人理解： 通过对象来了解其本身的类 其优缺点 反射相关API 然后可以通过反射对象获取所有的class结构 Class类 类中常用方法 内存图解 反射操作泛型 练习ORM [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3jHneG
注解与反射知识详解
qq_52253798的博客
03-28 836
一、什么是注解 （1） Annotation 是从JDK5.0开始引入的新技术。 （2）Annotation 的作用： 不是程序本身，可以对程序作出解释这一点和注释（ comment 没什么区别） 可以被其他程序（比如：编译器等）读取 （3）Annotation 的格式： 注解是以“＠注釋名”在代码中存在的还可以添加一些参数值，例如：@ SuppressWarnings ( value =" unchecked ")； （4） Annotation 在哪里使用？...
JVM内存结构（从字节码分析字符串常量池）
RwTo的博客
10-03 256
JVM的内存结构内存结构程序计数器虚拟机栈本地方法栈堆方法区 内存结构 程序计数器 Program Counter Register 程序计数器（寄存器） 作用：是记住下一条jvm指令的执行地址特点 是线程私有的 不会存在内存溢出 虚拟机栈 Java Virtual Machine Stacks （Java 虚拟机栈） 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法 问题辨析 垃圾回收是否涉及栈内存？ 栈内存分配越大越好吗？ 方法内的局部变量是否线程安全？ 如果方法内局部变量没有
Java 反射、注解
weixin_30467087的博客
07-09 102
1. 泛型 基本用法、泛型擦除、泛型类/泛型方法/泛型接口、泛型关键字、反射泛型！ a. 概述 泛型是JDK1.5以后才有的， 可以在编译时期进行类型检查，且可以避免频繁类型转化！ // 运行时期异常 @Test publicvoidtestGeneric() throwsException { // 集合的声明 Listlist =...
枚举类和注解小结（自用小结笔记）
Giapeace的博客
10-29 226
枚举类和注解枚举类的使用注解 枚举类的使用 1.枚举类的说明 枚举类的理解：当一个类的对象是有限个，确定的时候，我们称此类为枚举类。 当需要定义一组常量时，强烈建议使用枚举类。 如果枚举类中只有一个对象，则可以作为单例模式的实现方式。 2.如何自定义枚举类，步骤： 方式一：jdk5.0之前自定义枚举类 方式二：jdk5.0，可以使用enum关键字定义枚举类 //自定义枚举类 class Season{ //1.声明Season对象的属性:private final 来修饰 priva
Java注解和反射
oldwangold的博客
03-16 122
注解 什么是注解 Annotation是从JDK1.5开始引入的新技术 Annotation的作用： 不是程序本身，可以对程序作出解释（这一点和注释（comment）没什么区别） 可以被其他程序（比如编译器）读取 Annotation的格式 注解是以“@注释名”在代码中存在的，还可以添加一些参数值，例如@SU盘热身赛Warning(value=“unchecked”) An...
Java 注解与反射详解（一遍过）
最新发布
liuyangzhengwei的博客
05-31 1975
Java 注解与反射（一遍过）类的初始化，类缓存，双亲委派机制
注解与反射详解（含手写ORM底层demo、Javabean定义）
成为一位优秀的职场人，我在路上
11-12 354
一、注解 1、简介 java注解（Annotation）又称java标注，是JDK5.0引入的一种注释机制 注解可以和注释联系起来，注释是给程序员看的，注解是给机器看的。注解相当于把代码注释到运行时使用，可以简化开发 java语言中的类、方法、变量、参数和包都可以被标注 java标注可以通过反射获取标注内容，在编译器生成类文件时，标注可以被嵌入到字节码中。java虚拟机可以保留标注内容，在运行时可以获取到标注内容 也支持自定义的java标注，即自定义编写注解 主要用途 编译格式的检查
Android 反射注解与动态代理综合使用详解
01-20
在Android开发中，反射、注解和动态代理是三个非常重要的高级特性，它们极大地提高了代码的灵活性和可维护性。接下来我们将深入探讨这三个概念以及它们的综合应用。 反射（Reflection）是Java提供的一种机制，允许...
【示例】Java进阶注释与反射详解
Gyuau的博客
02-09 316
目录 注解 1.1、什么是注解 1.2、内置注解 1.3、元注解 1.4、自定义注解 反射 2.1、反射机制概述 2.2、获得反射对象 2.3、得到Class类的几种方式 2.4、所有类型的Class对象 2.5、类加载内存分析 2.6、分析类初始化 2.7、类加载器 2.8、获取类的运行时结构 2.9、动态创建对象执行方法 2.10、性能对比分析 2.11、获取泛型信息 2.12、获取注解信息 ...
注解和反射
aaa948771854的博客
01-08 160
注解 内置注解 例如@Override、@Deprecated、@SuppressWarnings 注解等 元注解 元注解的作用就是负责注解其他注解，Java定义了4个标准的meta-annotation类型，他们被用来提供对其他annotation类型作说明 @Target 用于描述注解的使用范围（例如类、方法、变量......） @Retention 表示需要再什么级别保存该注释信息，用于描述注解的生命周期 source < class < runtime @Docume
Java 注解和反射详解
Woo_home的博客
09-15 3628
文章目录注解什么是注解？内置注解元注解@Target@Retention@Documented@Inherited自定义注解反射静态语言 VS 动态语言动态语言静态语言Java 反射机制概述Java 反射机制提供的功能Java 反射优点和缺点反射相关的主要 API理解 Class 类并获取 Class 实例Class 类Class 类的常用方法获取 Class 类的实例所有类型的 Class 对象Java 内存分析类的加载与 ClassLoader 的理解 注解 什么是注解？ Annotation 是从
注解和反射知识总结(纯干货,附代码举例)
Nohara Rin
03-16 1427
注解和反射知识总结(纯干货,附代码举例) 注解 Annotation是从JDK5.0开始引入的技术 Annotation的作用： 不是程序本身，可以对程序作出解释。（这一点和注释（comment）没什么区别） 可以被其他程序（比如：编译器等）读取 Annotation的格式： 注解是以"@注释名"在代码中存在的，还可以添加一些别的参考值，例如：@SuppressWarnings(value=“unchecked”). Annotation在哪里使用？ 可以附加在package，class，method，fi
Java反射（Reflection）
hgh1998的博客
06-12 123
反射 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类； 在运行时构造任意一个类的对象； 在运行时判断任意一个类所具有的成员变量和方法； 在运行时调用任意一个对象的方法； 生成动态代...
Spring常用注解（收藏大全）
wlh_150568的博客
02-13 302
Spring部分 1.声明bean的注解 @Component 组件，没有明确的角色 @Service 在业务逻辑层使用（service层,一般用在service的实现类上） @Repository 在数据访问层使用（dao层,一般用在访问数据库的TestMapper接口上） @Controller 在展现层使用，控制器的声明（C） 2.注入bean的注解 @Autowired：由S...
Java注解与反射详解
"java注解和反射的个人学习笔记" 在Java编程中，注解（Annotation）和反射（Reflection）是两种强大的工具，它们为开发者提供了更高级别的抽象和动态操作能力。注解自JDK 5.0版本起引入，主要用于提供元数据，即...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值