一、JAVA注解与反射

最新推荐文章于 2024-05-22 23:24:01 发布
最新推荐文章于 2024-05-22 23:24:01 发布
阅读量174 收藏
点赞数
分类专栏： java 文章标签： 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52719135/article/details/114882449
版权

注解与反射

​​# 一、Annotation 注解

1、基本内容

是从jdk5.0开始引入的新技术

作用

不是程序本身，可以对程序做出解释（这点和comment没啥区别）

可以被其他程序（如编译器）读取

格式

  • 注解是以“@注释名”在代码中存在的，还可以添加一些参数值，例如：@SuppressWarnings(value=“unchecked”)

在哪使用

  • 注解可以附加在package，class，method，field等上面，相当于给他们添加了额外的辅助信息，我们可以通过反射机制编程实现对这些元数据的访问
public class Test1 extends  Object  {

    //@Override重写的注解
    @Override
    public String toString() {
        return super.toString();
    }
}

2、内置注解(@Override @Deprecated @SuppressWarnings)

@Override:定义在java.lang. Override中此注释只适用于修辞方法,表示一个方法声明打算重写超类中的另一个方法声明

@Deprecated:定义在java.lang. Deprecated中,此注释可以用于修辞方法,属性,类,表示不鼓励程序员使用这样的元素,通常是因为它很危险或者存在更好的选择

@SuppressWarnings:定义在java.lan. SuppressWarnings中用来抑制编译时的警告信息
口与前两个注释有所不同你需要添加一个参数才能正确使用这些参数都是已经定义好了的
我们选择性的使用就好了

  • @SuppressWarnings(“all”)
  • @SuppressWarnings(“unchecked”)
  • @SuppressWarnings(value=("unchecked,“deprecation”})
  • ​ 等等
//@Deprecated不推荐程序员使用，但是可以使用
@Deprecated
public static  void  test(){
    System.out.println("@Deprecated");
}


@SuppressWarnings("all")
public  void  test02(){
    List list    = new ArrayList();

}

3、元注解(@Target @Retention @Document @Inherited)

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

这些类型和他们锁支持的类型在java.lang.annotation包中可以找到.(@Target,@Rentetion,@Document,@InherIted)

@Target:用于表述注解使用范围（即：被描述的注解可以用在什么地方）
@Rentetion：表示需要在什么级别保存该注释信息，用于描述注解的生命周期
（SOURCE<CLASS<RUNTIME）
@Document:说明该注释将被包含在javadoc中
@InherIted：说明子类可以继承父类中的该注解
package for1;
//测试元注解

import javax.xml.bind.Element;
import java.lang.annotation.*;

public class Test2 {
}
//定义一个注解
//@Targe表示我们的注解可以用在哪些地方
@Target(value = {ElementType.METHOD,ElementType.TYPE})
//@Retention表示我们的注解在什么地方还有效
//runtime>class>sources
@Retention(value = RetentionPolicy.RUNTIME)

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

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

}

4、自定义注解

4.1、使用@interface自定义注解是，自动继承了java.lang.anntation.Annotation接口

4.2、分析

* @interface用来声明一个注释，格式：public @interface注释名{自定义内容}
* 其中的每一个方法实际上是声明一个配置参数
* 方法的名称就是参数的名称
* 返回值类型就是参数的类型（返回值只能是基本类型：Class，String，enum）
* 可以通过default来声明参数的默认值
* 如果只有一个参数成员，一般参数名为value
* 注解元素必须要有值，我们定义注解元素时，经常使用空字符串，0作为默认值

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//自定义注解
public class Test3 {
    @MyAnnotation2(name="lwm",age = 15,school = {"复旦","清华"})
   public  void  test(){}
    @MyAnnotation3("cwm")//只有一个参数是不需要写参数名
   public void  test2(){}

}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface  MyAnnotation2{
    //注解的参数：参数类型+参数名（）；
    String name() default "";//default ""   表示默认值为空，也可以显示赋值
    int age();
    int id()   default-1;//如果默认值为-1，代表不存在
    String []school()default {"杉达","sanda"};
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
    String value();
}

二、Reflection 反射

1、静态语言与动态语言

  • 动态语言时一类在运行时可以改变器结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他其结构上的变化。通俗点说就是在运行时代码可以根据默写条件改变自身结构

  • 静态语言

    • 与静态语言相对应的，运行时结构不可变的语言就是静态语言。如java，C，C++

    • java不是动态语言，但java可以称之为“准动态语言”。即java有一定的动态性，我们可以利用反射机制获得类似动态语言的特性。java的动态性让编程的时候更加灵活！

2、概述

  • Reflection(反射)时java被视为动态语言的关键，反射机制允许程序在执行期借助ReflectionAPI取得任何类的内部信息，并能直接操作任意对象的内部属性及方法

image-20210308143821304

image-20210308143832208

package reflection;

public class Test2 {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的class对象
        Class c1 = Class.forName("reflection.Users");
        Class c2 = Class.forName("reflection.Users");
        Class c3 = Class.forName("reflection.Users");
        Class c4 = Class.forName("reflection.Users");
        System.out.println(c1);

        //一个类在内存中只有一个class对象
        //一个类被加载后，类的整个结构都会被封装在这个class对象中
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
        System.out.println(c4.hashCode());
    }
}
//实体类：pojo entity
class  Users{
    private String name;
    private  int id;
    private  int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        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;
    }

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

3、Class类概述

image-20210308151305365

image-20210308151828696

4、class的常用方法

image-20210308212909394

5、获取Class类的实例

image-20210308220220036

image-20210308220239052 
package reflection;
//测试class类的创建方式有哪些
public class Test3 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person=new Student();
        System.out.println("is "+person.name);
        //方式1：通过对象获得
        Class c1=person.getClass();
        System.out.println(c1.hashCode());
        //方式2：forname获得
        Class c2 = Class.forName("reflection.Student");
        System.out.println(c2.hashCode());
        //方式3：通过类名.class获得
        Class c3=Student.class;
        System.out.println(c3.hashCode());
        //方式4：基本内置类型的包装都有一个Type属性
        Class c4 = Integer.TYPE;
        System.out.println(c4);
        //获得父类类型
        Class c5 = c1.getSuperclass();
        System.out.println(c5);

    }
}

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="老师";

    }
}

6、哪些类型可以又Class对象？

image-20210308234429588

package reflection;

import java.lang.annotation.ElementType;

//所有类型的class对象
public class Test04 {
    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;//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);
        //只要元素类型与维度一样，就是同一个class。
        int [] a=new int[10];
        int [] b=new int[100];
        System.out.println(a.hashCode());
        System.out.println(b.hashCode());
    }
}

快捷键选多行alt+鼠标移动

image-20210308234151609

7、内存分析

image-20210308234943150

类的加载过程

image-20210308235016104

类的加载与ClassLocalder的理解

image-20210310230655697

package reflection;

public class Test5 {
    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;
         *      }
         *
         *      m=100
         */
        

    }
}

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

什么时候会发生类的初始化？

image-20210309003030883

package reflection;

import java.net.Socket;

//测试类什么时候会初始化
public class Test6 {
    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[] arry=new Son[5];
        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;
}

类加载器的作用

image-20210309090653184

image-20210309090704417

类加载器的作用

image-20210309091052127

package reflection;

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

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

        //获取扩展类加载器的父类加载器-->根加载器（c++/c）
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

        //测试当前类是哪个加载器加载的
        ClassLoader classLoader  = Class.forName("reflection.Test7").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"));
        /*
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\charsets.jar;
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\deploy.jar;
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\access-bridge-64.jar;
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\cldrdata.jar;
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\dnsns.jar;
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\jaccess.jar;
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\jfxrt.jar;
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\localedata.jar;
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\nashorn.jar;
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\sunec.jar;
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\sunjce_provider.jar;
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\sunmscapi.jar;
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\sunpkcs11.jar;
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\ext\zipfs.jar;
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\javaws.jar;
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\jce.jar;
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\jfr.jar;
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\jfxswt.jar;
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\jsse.jar;
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\management-agent.jar;
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\plugin.jar;
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\resources.jar;
        C:\Program Files\Java\jdk1.8.0_231\jre\lib\rt.jar;
        E:\学习资源下载\java\idea\javaee\javaforme\注解和反射\out\production\注解和反射;
        E:\学习资源下载\IDEA\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar

         */

    }
}

获取运行时类的完整结构

image-20210309094308995

package reflection;

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

public class Test8 {
    public static void main(String[] args) throws Exception {
        Class<?> c1 = Class.forName("reflection.Users");

        /*
        //通过对象来获得他的1类名+包名
        Users user = new Users();
        c1=user.getClass();
         */

        //获得类的名字
        System.out.println(c1.getName());//获得包名+类名
        System.out.println(c1.getSimpleName());//获得类名
        System.out.println("-------");
        //获得类的属性
        Field[] field = c1.getDeclaredFields();//找到全部属性
        for (Field filed:field) {
            System.out.println(filed);
        }
        field=c1.getFields();//只能找到public属性

        //获得制定属性值
        Field names = c1.getDeclaredField("name");
        System.out.println(names);
        System.out.println("---------------------------------");
        //获得类的方法
        Method[] methods = c1.getMethods();//获得本类机器父类的全部public方法
        for (Method meth:methods
             ) {
            System.out.println("正常的："+meth);
            
        }
        methods = c1.getDeclaredMethods();//获得本类的所有方法
        for (Method meth:methods
        ) {
            System.out.println("getDeclaredMethods："+meth);
        }

        //获得指定的方法
        //重载
        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);
        }


       

    }
}

8、有了Class对象，能做什么

image-20210310010004236

调用指定的方法

image-20210310012841780

image-20210310012915997

image-20210310012951705

package reflection;
//动态的创建对象，通过反射
import  java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Test9 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        //获得class对象
        Class c1 = Class.forName("reflection.Users");

        //构造一个对象
       // Users users = (Users) c1.newInstance();
        //System.out.println(users);

        //通过构造器创建对象
        Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        Users users2 = (Users) constructor.newInstance("lwm", 001, 18);
        System.out.println(users2);

        //通过反射调用普通方法
        Users users3 =(Users) c1.newInstance();
        //通过反射获取一个方法
        Method setName = c1.getDeclaredMethod("setName", String.class);
        System.out.println("原来的name："+users3.getName());

        //invoke:激活的意思 |用法（对象，“方法的值”）
        setName.invoke(users3,"ilucwm");
        System.out.println("改后的"+users3.getName());


        //通过反射操作属性
        System.out.println("================");
        Users users4 = (Users) c1.newInstance();
        Field name = c1.getDeclaredField("name");
        //不能直接操作私有属性，我们需要关闭程序的安全检测，属性或方法的setAccessible(true)
        name.setAccessible(true);//
        name.set(users4,"cwm");
        System.out.println(users4.getName());

    }
}

三个方法调用的时间比较

package reflection;

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

public class Test10 {

    public static void main(String[] args) throws Exception {
        test1();
        test2();
        test3();
    }
    //普通方式调用
    public static  void test1() {
        Users users = new Users();
        long starTime=System.currentTimeMillis();//获取开始时的时间

        for (int i = 0; i < 1000000000; i++) {
            users.getName();
        }
        long endTime=System.currentTimeMillis();//获取结束时的时间
        System.out.println("普通方式执行10亿次："+(endTime-starTime)+"ms");
    }

    //反射方式调用
    public static  void test2() throws Exception {
        Users users = new Users();
        long starTime=System.currentTimeMillis();//获取开始时的时间
        Class c1 = users.getClass();
        Method getName = c1.getMethod("getName");
        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(users,null);
        }
        long endTime=System.currentTimeMillis();//获取结束时的时间
        System.out.println("反射方式调用执行10亿次："+(endTime-starTime)+"ms");
    }

    //反射方式调用  关闭检测
    public static  void test3() throws Exception {
        Users users = new Users();
        long starTime=System.currentTimeMillis();//获取开始时的时间
        Class c1 = users.getClass();
        Method getName = c1.getMethod("getName");
        getName.setAccessible(true);
        for (int i = 0; i < 1000000000; i++) {
            getName.invoke(users,null);
        }
        long endTime=System.currentTimeMillis();//获取结束时的时间
        System.out.println("反射方式调用  关闭检测 调用执行10亿次："+(endTime-starTime)+"ms");
    }
}

9、反射操作泛型

image-20210310205419702

package reflection;

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
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,Users>map, List<Users> list){
        System.out.println("test01");
    }

    public Map<String,Users> 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);
                }
            }
        }

        method=Test11.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);
            }
        }

    }

}

10、反射操作注解

ORM

什么时ORM？

Object relationship Mapping -->对象关系映射

image-20210316150230027

image-20210316150302618

package reflection;

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

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

        //通过反射获得注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        //获得注解value的值
        Tablechen tableChen = (Tablechen)c1.getAnnotation(Tablechen.class);
        String value = tableChen.value();
        System.out.println(value);

        //获得类指定的注解
        Field f = c1.getDeclaredField  ("name");
        Filedchen filedchen = f.getAnnotation(Filedchen.class);
        System.out.println(filedchen);


    }


}
@Tablechen("db_student")
class  Student2{
    @Filedchen(columnName = "db_id",type = "int",length = 10)
    private  int id;
    @Filedchen(columnName = "db_age",type = "int",length = 10)
    private  int age;
    @Filedchen(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 Tablechen{
    String value();
}
//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface  Filedchen{
    String columnName();
    String type();
    int length();
}
舍肯
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java注解与反射原理说明
08-26
Java注解（Annotation）是Java语言提供的一种元数据机制，允许程序员在代码中嵌入信息，这些信息可以被编译器、JVM或其他工具在编译时或运行时读取和处理。注解的主要用途包括代码的自我描述、编译器检查、运行时的...
黑马程序员——关于注解
u010268469的专栏
07-25 524
----------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ---------------------- 一、 什么是注解？注解的作用是什么？ １、注解是一个很重要的知识点，在很多常用的框架，如jpa、Spring1.5和hibernate，structs2的一部分都是基于注解的。它也是一个jdk1.5的新特性。 ２
java注解--史上最清晰,讲解最全!!!
weixin_46273997的博客
02-03 918
java注解--史上最清晰,讲解最全!!!前言一、注解是什么及其本质？(1)注解的本质(2)注解的分类(3)注解的作用1.可以用于生成文档2.进行编译检查3.二、自定义注解1.怎样自定义注解?2.读入数据总结 前言 在学习注解前,先来认识一下注释,我们都知道注释是是用来说明代码的,不会经过编译,注释的主要目的是方便程序员阅读! 同样,注解也是用来说明代码的,只不过注解是方便计算机阅读; 一、注解是什么及其本质？ (1)注解的本质 简单来说,注解是JDK1.5之后引入的新特性,用来标注程序的,提供与程序有
Java 注解和反射
最新发布
kezhou的博客
05-22 719
注解是 JDK 5.0 引入的新技术。注解是不是程序本身，但可以对程序做出解释；可以被其他程序（比如编译器）读取。注解是以 “@注解名” 在代码中存在，还可以添加一些参数，例如 @SuppressWarnings(value=“ubchecked”)。可以加在 package、class、method、field 等上面，相当于给他们添加额外的信息；我么可以通过反射机制编程实现对这些元数据的访问。使用@interface自定义注解时，自动继承了接口。@interface用来声明一个注解；
JAVA注解与反射：看这篇文章就够了
林夕
07-17 974
Java注解又称Java标注，是在 JDK5 时引入的新特性，注解（也被称为元数据）。Java注解它提供了一种安全的类似注释的机制，用来将任何的信息或元数据（metadata）与程序元素（类、方法、成员变量等）进行关联。Java注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。// 元注解public @interface 注解名称{// 属性列表//自定义注解//注解可以显示赋值， 如果没有默认值，我们就必须给注解赋值//注解参数的顺序随意。
注解和反射总结
Cristo_Li的博客
04-22 492
文章目录一、注解二、使用步骤1.引入库2.读入数据总结 一、注解 Annotation：@+注释名 不是程序本身，但可以对程序作出解释 可以被其他程序（比如：编译器等）读取 相当于添加了额外的辅助信息，可以通过反射机制编程实现对被注解标注的元数据的访问 举例：@SuppressWarning(“all”)：抑制编译时一些无关紧要的警告信息 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib
java注解与反射
Imzhipo的博客
03-14 447
java注释与反射
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
java基础之注解和反射
08-05
java基础之注解和反射
Java使用注解和反射简化编程的方法示例
08-25
Java使用注解和反射简化编程的方法示例 Java中的注解和反射机制可以简化编程的方式，提高编程效率。下面将通过实例形式，分析Java使用注解和反射简化编程的相关操作技巧。 Java中的注解是一种meta信息，提供了...
java注解与反射的基本使用（这一篇就够了！）
12-21
Java注解（Annotation）是Java语言的一个重要特性，它允许我们在代码中添加元数据，这些元数据可以被编译器或其他工具读取并执行相应的处理。注解与普通的注释不同，注释只是给人阅读的，而注解则是机器可读的，能够...
java——反射与注解
Why_does_it_work的博客
06-24 5785
我们可以通过Java的元注解来自定义注解。Java的元注解包括@Retention、@Target、@Inherited和@Documented。其中，@Retention用于指定注解的生命周期，@Target用于指定注解可以应用于哪些元素，@Inherited用于指定子类是否继承注解，@Documented用于指定注解是否出现在Java文档中。上述代码定义了一个名为MyAnnotation的注解，它有两个属性：name和age。
Java中的注解和反射
m0_70990872的博客
07-16 537
Java中的注解和反射
Java：注解和反射
希望有点用
05-21 2362
文章目录 学习视频来自于：秦疆（遇见狂神说）Bilibili地址 他的自学网站：kuangstudy 唯有热爱，能抵岁月漫长
java 反射和注解
weixin_41765786的博客
07-19 1198
示例12】自定义注解}//如果只有一个配置参数，一般命名为value}@MyAnnoation(id=5,name="张三",scoreArr={78,89,34})}}}定义注解的关键字是@interface自定义注解中可以定义多个配置参数，不是成员方法,不是成员变量；说明参数的名称，以及参数值的类型如果只有一个配置参数，一般命名为value如果配置参数是value，并且只有一个配置参数，value可以省略。...
反射与注解（详细）
qq_43377329的博客
03-26 2712
文章目录一、注解Annotation1、什么是注解2、内置注解3、元注解4、自定义注解二、反射机制**1、静态vs动态语言**动态语言静态语言2、java反射机制概述3、java反射机制研究及应用**反射机制提供的功能**优点缺点反射相关主要APIclass类class的常用方法获取class类的实例哪些类型有class对象?4、java内存分析static关键字类的加载过程类的加载和ClassLoader的理解什么时候会发生类的初始化？类加载器的作用双亲委派机制ClassLoader源码分析获取类加载器的
注解与反射
记录学习历程
05-18 549
注解（Annotation）是从JDK5.0开始引入的技术，以在代码中存在，例如：Annotation可以像修饰符一样被使用，可用于修饰包、类、构造器、成员变量、参数、局部变量的声明，还可添加一些参数值注解也可以看做是一种注释，通过使用Annotation，程序员可以在不改变原有逻辑的情况下，在源文件中嵌入一些补充信息。但是，注解，不同于单行注释和多行注释在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE/Android中注解占据了更重要的角色，例如用来配置应用程序的任
JAVA-注解和反射
码说芯语的博客
03-16 493
1、什么是注解？ Annotation是从JDK5.0开始引入的新技术 Annotation的作用： 不是程序本身，可以对程序作出解释（这一点和注释（comment）类似） 可以被其他程序（比如：编译器等）读取 Annotation的格式： 注解是以“@注释名”在代码中存在的，还可以添加一些参数值，列如：@SuppressWarnings(value=“unchecked”). Annotation在哪里使用？ 可以附加在package,class,method,field等上面，相当于给他们添加了额外的
反射和注解
welcomword的博客
08-01 650
反射和注解 1. 概述 1.1 注解 注解（Annotation）和反射（reflection）是许多Java框架的底层，例如Mybatis，SpringBoot等。 注解（Annotation），“注”，即注释（comment），这是方便我们理解所产生的注解名；“解”，即注解的真正意义，它由程序来进行解析 Annotation是JDK5.0开始引入的一个新技术 Annotation的作用 它不是程序，但可以对程序作出解释（和注释Comment类似） 可以被其它程序（例如：编译器等）读取 Annot
Java注解与反射机制详解
"Java中关于注解和反射机制的内容" 在Java编程中，注解（Annotation）和反射机制是两个非常重要的特性，它们极大地扩展了Java语言的功能和灵活性。 ### 注解 #### 1.1 注解简介 注解是自Java 5版本引入的一种元...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值