首页 > 其他分享 >注解与反射

注解与反射

时间：2023-10-23 20:03:52浏览次数：33  
标签：反射 name System class println 注解 Class out

注解与反射

笔记整理于@bilibili遇见狂神说

注解(Annotation)

什么是注解

可被程序读取的注释

注解的格式

@Override
@Deprecated

内置注解

//在java.lang.Override中定义,表示重写
@Override

//在java.lang.Deprecated中定义,表示已过时
@Deprecated

//镇压警告
@SuppressWarnings

元注解

解释其他注解的注解

//描述注解的使用范围
@Target

//表示需要在什么级别保存该注释信息
//SOURCE<CLASS<RUNTIME
//源码<编译<运行
@Retention

//说明该注解将被包含在javadoc中
@Document

//说明子类可以继承父类中的该注解
@Inherited

自定义注解

使用@interface自定义注解,自动继承java.lang.annotation.Annotation接口

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation{
	String name() default "";
	String[] schools() default {"安工大","铜陵一中"}
}

String name()不是方法,是参数类型+参数名

如果只有一个值可以使用value进行命名
注解默认值的名字是value,可以直接写值

反射(Reflection)

什么是反射

正常情况:引入需要的包类名称->通过new实例化->取得实例化对象

反射:实例化对象->getClass()方法->得到完整的包类名称

允许程序在执行迄今取得任何类的内部信息
并能直接操作任意对象内部的属性和方法

Class类

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

获取Class类的方法

已知类的全类名

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

已知具体的类,通过类的class属性获取,安全,可靠

Class clazz = Person.class;

已知某个类的实例

Class clazz = person.getClass();

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

ClassLoader..

总结:

package org.example;


//测试class类的创建方式有哪些
public class Test {
    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("org.example.Student");
        System.out.println(c2.hashCode());
        //方式三：通过类名.class获得
        Class<?> c3 = Student.class;
        System.out.println(c3.hashCode());
        //方式四：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="老师";
    }
}

哪些类可以有class对象

package org.example;


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

    }
}

获得类的信息

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("org.example.User");

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

        //获得类的属性
        c1.getFields();//只能获得public属性
        Field[] fields = c1.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);
        }

        //获得指定属性值
        Field name = c1.getDeclaredField("name");
        System.out.println(name);

        //获得类的方法
        Method[] methods = c1.getMethods();//获得本类以及父类的全部public方法
        for (Method method : methods) {
            System.out.println(method);
        }
        methods = c1.getDeclaredMethods();//获得本类的全部方法，包括私有
        for (Method method : methods) {
            System.out.println(method);
        }

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

        //获得指定的构造器
        Constructor[] constructors = c1.getConstructors();//public
        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);

    }
}

反射操作对象


package org.example;


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, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        Class<?> c1 = Class.forName("org.example.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("wfj",001,18);
        System.out.println(user1);
        //通过反射调用普通方法
        User user2 = (User)c1.newInstance();
        Method setName = c1.getDeclaredMethod("setName", String.class);
        setName.invoke(user2,"wfj");
        System.out.println(user2.getName());
        //通过反射操作属性
        User user3 = (User) c1.newInstance();
        Field name = c1.getDeclaredField("name");

        //安全检测关闭，使用私有属性
        name.setAccessible(true);

        name.set(user3,"wfj");
        System.out.println(user3.getName());
    }
}

setAccessible()方法性能比较高

具体：普通方法>关闭权限检测的反射>开启权限检测的反射方法

反射操作注解

ORM对象关系映射

类和表结构对应
属性和字段对应
对象和记录对应

利用注解和反射完成类和表结构的映射关系


package org.example;

import java.lang.annotation.*;

public class Test12 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class<?> c1 = Class.forName("org.example.Student2");

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

        //获得类指定注解
        java.lang.reflect.Field f = c1.getDeclaredField("name");
        Field annotation1 = f.getAnnotation(Field.class);
        System.out.println(annotation1.columnName());
        System.out.println(annotation1.length());
        System.out.println(annotation1.type());
    }
}


@Table("db_student")
class Student2{
    @Field(columnName = "db_id",type = "int",length = 10)
    private int id;
    @Field(columnName = "db_age",type = "int",length = 10)
    private int age;
    @Field(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 void setName(String name) {
        this.name = name;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public int getAge() {
        return age;
    }

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


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


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

标签：反射,name,System,class,println,注解,Class,out
From： https://www.cnblogs.com/akaxedx/p/17779091.html

相关文章

  • mybatis的一级缓存和事务注解失效导致的查询结果缺失
    事情是这样的，测试发现有个查询接口，第一次调的时候没能返回数据，第二次调就可以正常返回。这个接口的功能是查询用户的现有福利数据。具体点的逻辑是1，查询数据库，mybatis，xml里面写的关联查询，主表和子表关联。2，判断查询结果，如果没有子表部分的信息，则按照业务逻辑生成子表数......
  • Java 自定义脱敏注解实现
    自定义注解packagecom.yunmeng.iot.common.desensitization.annotation;importcom.fasterxml.jackson.annotation.JacksonAnnotationsInside;importcom.fasterxml.jackson.databind.annotation.JsonSerialize;importcom.yunmeng.iot.common.desensitization.enums.Secr......
  • 5、单元测试、反射、注解、动态代理
    单元测试、反射、注解、动态代理一、单元测试1.1Junit单元测试所谓单元测试，就是针对最小的功能单元，编写测试代码对其进行正确性测试。我们想想，咱们之前是怎么进行测试的呢？比如说我们写了一个学生管理系统，有添加学生、修改学生、删除学生、查询学生等这些功能。要对这些功能......
  • Java反射详解
    目录一、概述1、框架2、反射好处：二、获取字节码class对象的方法1、第一阶段——Source源代码阶段2、第二阶段——Class类对象阶段3、第三阶段——Runtime运行时阶段4、代码演示结论：三、Class对象功能概述1、获取成员变量Field[]getFields()（获取所有公共成员变量）FieldgetField(Str......
  • Spring-IOC构造注入，以及以基于注解的DI
    .Spring核心：IOCAOPIOC：控制反转：就是对对象控制权的转移，从程序代码本身反转到外部的容器中，通过外部容器对象的创建，属性的赋值，依赖的管理。IOC的具体实现:依赖注入（DI）：1.创建项目，导入架包2.定义类3.创建Spring的配置文件,编写bean4.在测试类中测试......
  • 【问题记录】自定义注解处理程序 AbstractProcessor，就是不生效，执行没效果
    1  前言最近在看注解处理程序，也想打包的时候，生成一点自己的东西，写了一个 AbstractProcessor，奶奶的花了两个早上，一直想不明白为什么不生效：唉，仅记录哈。......
  • [LC96] 不同的二叉搜索树 注解
    本文基于https://leetcode.cn/problems/unique-binary-search-trees/solutions/550154/96-bu-tong-de-er-cha-sou-suo-shu-dong-ta-vn6x/个人感觉博主部分内容讲得跳跃性较强记录如下正文首先是dp数组的定义,我觉得应该直接说明的是,dp[i]意味着有i个节点的搜索树的数量同......
  • SpringBoot 注解小记
    用于入口类的注解SpringBootApplication标识该类是入口ComponentScan表示扫描入口类同级和所有子包下的Component我们也可以使用ComponentScan("Com.XXXX")自定义扫描路径用于类的注解@Component,@Service,@Repository,@Controller四个注解用于类上，后三个实质上都是Compon......
  • Java(Spring) 通过反射classforName获取对象实例导致@Autowired注入失效
    使用策略模式多态获取具体的策略问题描述：classforName在代码中使用反射获取对象实例后，对象实例中通过@Autowrite注解注入的属性值为null（注入失败），导致带反射获取的对象实例调用方法时出现空指针等情况。问题原因：通过反射获取对象实例相当于“new”了一个对象，所以这个对象并没有被......
  • @Autowired注解在实现类还是接口
    @Autowired注解在实现类还是接口首先要清楚@Service是注解在实现类上的，@Service告诉Spring容器，注册一个实例化的类对象，当@Service注解在接口上，是无法对接口实例化的。@ServicepublicclassxxxImplimplementsxxxService@Autowired本质上注入的也是实现类，但是是根据接口byTy......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99