注解和反射

最新推荐文章于 2024-07-19 17:37:28 发布
最新推荐文章于 2024-07-19 17:37:28 发布
阅读量142 收藏
点赞数
分类专栏： JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52041663/article/details/120088780
版权

注解

什么是注解

  • 属于java.annotation包 Annotation是从JDK1.5开始引入的新技术，注解既可以对程序员解释又可以对程序解释

注解与注释的区别

  • 注释：对程序员解释代码信息
  • 注解：对程序和程序员解释代码信息

注解的作用

  1. 注解并不是程序本身，却可以对程序作出解释（与注释(comment)类似）
  2. 可以被其他程序（编译器）读取

注解的格式

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

注解的应用

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

  • @Overrlde：定义在java.lang.Override中，此注解只适用于修饰方法，表示一个方法声明打算重写超类中的另一个方法声明

  • @Deprecated：定义在java.lang.Deprecated中.此注解可以用于修饰方法，属性，类。表示不鼓励使用这样的元素.通常是因为它很危险或者存在更好的选择

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

    • @SuppressWarnings(“all”)抑制所有类型的警告信息
    • @SuppressWarnings(“unchecked”)抑制单类型的警告信息
    • @SuppressWarnings(value={“unchecked”,“deprecation”})抑制多类型的警告信息
public class Test01 {
	public static void main(String[] args) {
		/**
		 * 知识点：内置注解
		 * 含义：Java给我们提供的注解
		 */

	}
}
class A{
	public void method01() {

	}
}
class B extends A{
	@Override	//表示重写父类方法的注解
	public void method01() {

	}

	@Deprecated	//表示过时（弃用）方法的注解
	public void method02(){

	}

	@SuppressWarnings("all")	//镇压所有警告的注解
	public void method03(){
		String str;
		ArrayList list = new ArrayList();
	}

	@SuppressWarnings("unchecked")	//镇压单类型警告的注解
	public void method04(){
		String str;
		ArrayList list = new ArrayList();
		list.add(123);
		list.add("aaa");
	}
}
元注解
  • 元注解的作用：负责注解其他注解，Java定义了4个标准的meta-annotation类型，他们被用来提供对其他annotation类型作说明 这些类型和它们所支持的类在java.lang.annotation包中可以找到 （@Target，@Retention，@Documented，@Inherited )
  1. @Target：用于描述注解的使用范围(即:被描述的注解可以用在什么地方）
  2. @Retention：表示需要要在什么级别保存该注择信息，用于描述注解的生命周期 (SOURCE < CLASS < RUNTIME)
  3. @Document：说明该注解将被包含在javadoc中
  4. @lnherited：说明子类可以继承父类中的该注解
自定义注解

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

分析：

  • @interface用来声明一个注解，格式：public @interface注解名{定义内容} ，其中的每一个方法实际上是声明了一个配置参数.方法的名称就是参数的名称.
  • 返回值类型就是参数的类型（返回值只能是基本类型、Class、String、enum）
  • 可以通过default来声明参数的默认值
  • 如果只有一个参数成员，一般参数名为value()
@Target({ElementType.TYPE,ElementType.METHOD})	//元注解：标识注解的注解
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
	String str01();
	String str02() default "123";
//	String value();
	String[] value();
}

//@MyAnnotation("123")	//注解中只有一个属性，且名称为value时，可只写值，不写键
//@MyAnnotation({"112233","123"})	//属性为数组，String[] value();传参时要传输组
@MyAnnotation(str01="aaa",value={"ccc"})	//有多个属性时，必须同时写上键与值；若属性有默认值，也可不传值
public class Test01 {

}

反射

Java的反射机制

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

反射的基本使用

反射-获取Class文件对象

配置文件

classpath.properties

classPath=com.dream.reflex01.Student	//类的全路径名

DSClassPath.properties

classPath=com.dream.reflex02.LocalDataSource,com.dream.reflex02.NetworkDataSource,com.dream.reflex02.OtherDataSource	//类的全路径名

DSName.properties

name=本地,网络,其他

public static void main(String[] args) throws Exception {
    /**
    * 需求：获取字节码文件对象
    */
    //获取方式1
    Class<?> c1 = Student.class;

    //获取方式2
    Student stu = new Student();
    Class<?> c2 = stu.getClass();

    //获取方式3
    Properties p = new Properties();
    p.load(Test01.class.getClassLoader().getResourceAsStream("classpath.properties"));
    String classPath = p.getProperty("classPath");
    Class<?> c3 = Class.forName(classPath);

    System.out.println(c1 == c2);   //true
    System.out.println(c1 == c3);   //true

}
反射-操作构造方法

学生类

public class Student extends A{
	
	public String name;
	private char sex;
	private int age;
	private String classId;
	private String id;
	
	public Student() {
	}
	
	private Student(String classId, String id) {
		this.classId = classId;
		this.id = id;
	}

	public Student(String name, char sex, int age, String classId, String id) {
		this.name = name;
		this.sex = sex;
		this.age = age;
		this.classId = classId;
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public char getSex() {
		return sex;
	}

	public void setSex(char sex) {
		this.sex = sex;
	}

	public int getAge() {
		return age;
	}

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

	public String getClassId() {
		return classId;
	}

	public void setClassId(String classId) {
		this.classId = classId;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}
	
	public void eat() {
		System.out.println(this.name + "吃饭饭");
		sleep();
	}
	
	private void sleep() {
		System.out.println(this.name + "睡觉觉");
	}
	
	@Override
	public String toString() {
		return name + "\t" + sex + "\t" + age + "\t" + classId + "\t" + id;
	}
}

测试类

public static void main(String[] args) throws Exception {
    /**
    * 需求：利用反射机制操作构造方法（在反射中，构造方法、成员方法和成员变量都被当成对象），实例方法即是成员方法。
    */
    //获取Student类的字节码文件对象
    Properties p = new Properties();
    p.load(Test02.class.getClassLoader().getResourceAsStream("classpath.properties"));
    String classPath = p.getProperty("classPath");
    Class<?> c = Class.forName(classPath);

    //获取该类的 public 构造方法
    //Constructor<?>[] constructors = c.getConstructors();
    //for (Constructor<?> constructor : constructors) {
    //    System.out.println(constructor);
    //}

    //获取该类的所有构造方法
    //Constructor<?>[] declaredConstructors = c.getDeclaredConstructors();
    //for (Constructor<?> declaredConstructor : declaredConstructors) {
    //	  System.out.println(declaredConstructor);
    //}

    //利用无参构造创建 Student 对象（1）
    //Student stu = (Student) c.newInstance();
    //System.out.println(stu);
    //利用无参构造创建 Student 对象（2）
    //Constructor<?> constructor = c.getConstructor();
    //Student stu = (Student) constructor.newInstance();
    //System.out.println(stu);

    //利用有参构造创建 Student 对象
    Constructor<?> constructor = c.getDeclaredConstructor(String.class, char.class, int.class, String.class, String.class);
    constructor.setAccessible(true);
    Student stu = (Student) constructor.newInstance("张三", '男', 21, "2107","001");
    System.out.println(stu);

}
反射-操作属性
public static void main(String[] args) throws Exception {
    /**
    * 需求：利用反射机制操作属性
    */
    //获取Student的字节码文件对象
    Properties p = new Properties();
    p.load(Test03.class.getClassLoader().getResourceAsStream("classpath.properties"));
    String classPath = p.getProperty("classPath");
    Class<?> c = Class.forName(classPath);

    //获取本类和父类中公有属性的对象
    //Field[] fields = c.getFields();
    //for (Field field : fields) {
    //    System.out.println(field);
    //}

    //获取本类所有属性的对象
    //Field[] declaredFields = c.getDeclaredFields();
    //for (Field declaredField : declaredFields) {
    //    System.out.println(declaredField);
    //}

    Student stu = new Student("张三", '男', 21, "2017", "001");
    //设置非私有化属性
    Field name = c.getField("name");
    name.set(stu,"李四");

    //设置私有化属性
    Field age = c.getDeclaredField("age");
    age.setAccessible(true);    //设置修改权限
    age.set(stu,23);

    System.out.println(stu);
}
反射-操作方法
public static void main(String[] args) throws Exception {
    /**
    * 需求：利用反射机制操作方法
    */
    //获取Student的字节码文件对象
    Properties p = new Properties();
    p.load(Test03.class.getClassLoader().getResourceAsStream("classpath.properties"));
    String classPath = p.getProperty("classPath");
    Class<?> c = Class.forName(classPath);

    //获取该类及父类的公有方法的对象
    //Method[] methods = c.getMethods();
    //for (Method method : methods) {
    //    System.out.println(method);
    //}

    //获取该类所有方法的对象
    //Method[] declaredMethods = c.getDeclaredMethods();
    //for (Method declaredMethod : declaredMethods) {
    //    System.out.println(declaredMethod);
    //}

    Student stu = new Student("张三", '男', 21, "2107", "001");
    //调用公有方法
    Method setAge = c.getMethod("setAge", int.class);
    setAge.invoke(stu,23);

    //调用私有方法
    Method sleep = c.getDeclaredMethod("sleep");
    sleep.setAccessible(true);
    sleep.invoke(stu);

    System.out.println(stu);
}
反射-操作数组
public static void main(String[] args) {
    /**
    * 需求：利用反射机制操作数组
    */
    //创建String类型的数组
    String[] ss = (String[]) Array.newInstance(String.class,5);

    System.out.println("利用反射来获取数组长度：" + Array.getLength(ss));

    //利用反射设置数组元素
    Array.set(ss,0,"张三");
    Array.set(ss,1,"李四");
    Array.set(ss,2,"王五");
    Array.set(ss,3,"赵六");
    Array.set(ss,4,"虞姬");

    //利用反射遍历数组元素
    for (int i = 0; i < Array.getLength(ss); i++) {
        System.out.println(Array.get(ss,i));
    }
}
反射-操作泛型
public static void main(String[] args) throws Exception {
    /**
    * 需求：利用反射机制操作泛型
    */
    //获取Test06的字节码文件对象
    Class<?> c = Class.forName("com.dream.reflex01.Test06");

    //获取method01的方法对象
    Method method01 = c.getMethod("method01", ArrayList.class, HashMap.class);
    method01.setAccessible(true);
    Type[] genericParameterTypes = method01.getGenericParameterTypes();//获取参数类型
    for (Type t : genericParameterTypes) {
        ParameterizedType type = (ParameterizedType) t;
        //获取参数的泛型的类型
        Type[] actualTypeArguments = type.getActualTypeArguments();
        for (Type typeArgument : actualTypeArguments) {
            System.out.println(typeArgument);
        }
    }

    System.out.println("-----------");

    //获取method02方法对象
    Method method02 = c.getMethod("method02");
    method02.setAccessible(true);
    Type genericReturnType = method02.getGenericReturnType();
    ParameterizedType parameterizedType = (ParameterizedType) genericReturnType;
    //获取返回值的泛型类型
    Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
    for (Type type : actualTypeArguments) {
        System.out.println(type);
    }

}

public static void method01(ArrayList<String> list, HashMap<String,Integer> map){

}

public static HashMap<String,Integer> method02(){
    return null;
}

案例

业务与逻辑分离的思想

测试类

public class Test01 {
    /**
     * 需求: 业务与逻辑分离的思想
     */
    public static void main(String[] args) throws Exception {
        Scanner scan = new Scanner(System.in);
        printName();
        System.out.println("请选择数据源：");
        int num = scan.nextInt();

        DataSource dataSource = getDataSource(num);
        dataSource.getData();

        scan.close();
    }

    public static DataSource getDataSource(int num) throws Exception {
        Properties p = new Properties();
        p.load(Test01.class.getClassLoader().getResourceAsStream("DSClassPath.properties"));
        String classPath = p.getProperty("classPath");
        String[] split = classPath.split(",");

        //根据路径创建对象
        Class<?> c = Class.forName(split[num - 1]);
        DataSource dataSource = (DataSource) c.newInstance();
        return dataSource;
    }


    public static void printName() throws Exception {
        Properties p = new Properties();
        p.load(Test01.class.getClassLoader().getResourceAsStream("DSName.properties"));
        String name = p.getProperty("name");
        String[] split = name.split(",");

        StringBuffer sb = new StringBuffer();
        int num = 1;
        for (String s : split) {
            sb.append(num);
            sb.append("-");
            sb.append(s);
            sb.append("  ");
            num++;
        }
        System.out.println(sb);
    }
}

抽象类

public abstract class DataSource {

    public abstract void getData();
}

数据类

public class LocalDataSource extends DataSource {
    @Override
    public void getData() {
        System.out.println("获取本地数据...");
    }
}

public class NetworkDataSource extends DataSource {
    @Override
    public void getData() {
        System.out.println("获取网络数据...");
    }
}


public class OtherDataSource extends  DataSource{
    @Override
    public void getData() {
        System.out.println("其他数据...");
    }
}
反射 + 注解

测试类

public class Test01 {
    public static void main(String[] args) {
        /**
         * 知识点：反射 + 注解 的案例
         */
        Student stu = new Student("张三", '男', 21);

        //获取类上的注解数据
        Class<?> c = stu.getClass();
        TableInfo annotation = c.getAnnotation(TableInfo.class);
        String tableName = annotation.tableName();
        System.out.println(tableName);

        //获取属性上的注解数据
        Field[] declaredFields = c.getDeclaredFields();
        for (Field field : declaredFields) {
            FieldInfo fieldInfo = field.getAnnotation(FieldInfo.class);
            String name = fieldInfo.name();
            String type = fieldInfo.type();
            int length = fieldInfo.length();
            System.out.println(name + "--" + type + "--" + length);
        }

    }
}

自定义注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TableInfo {

    String tableName();
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface FieldInfo {

    String name();
    String type();
    int length();

}

学生类

@TableInfo(tableName = "db_student")
public class Student{

	@FieldInfo(name = "stu_name",type = "varchar",length = 32)
	private String name;
	@FieldInfo(name = "stu_sex",type = "varchar",length = 32)
	private char sex;
	@FieldInfo(name = "stu_age",type = "int",length = 3)
	private int age;
	
	public Student() {
	}

	public Student(String name, char sex, int age) {
		this.name = name;
		this.sex = sex;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public char getSex() {
		return sex;
	}

	public void setSex(char sex) {
		this.sex = sex;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
	public void eat() {
		System.out.println(this.name + "吃饭饭");
		sleep();
	}
	
	private void sleep() {
		System.out.println(this.name + "睡觉觉");
	}
	
	@Override
	public String toString() {
		return name + "\t" + sex + "\t" + age;
	}
}
我记得说过
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java注解和反射原理_Java中的注解和反射
weixin_35803802的博客
02-16 1182
最近又回顾了一下 Java 中的注解和反射知识点，注解在日常开发中使用很多，但是反射比较少。值得注意的是 Java 的各种框架底层源码中大量使用了注解和反射，阅读源码，这些是基本功，面试中这部分内容也经常问到。这里面概念不多，内容略微有些枯燥，但是通过一些简单的例子，能让我们明白一些基本概念和 API 的使用。所以，说到底，这篇博客只能算是一个简单的笔记，希望对你有帮助。 以前也写过枚举类和注解...
Java：注解和反射
希望有点用
05-21 2335
文章目录 学习视频来自于：秦疆（遇见狂神说）Bilibili地址 他的自学网站：kuangstudy 唯有热爱，能抵岁月漫长
Java注解和反射的理解
何义竏
07-02 391
Java注解与反射*注解定义*注解声明元注解自定义注解：@Traget@Retention内置三大注解：@Override@Deprecated@SuppressWarnings注解类型元素*注解应用场景*SOURCEIDE语法检查：APT注解处理器：CLASSRUNTIME反射什么是反射和什么是反射Class获取class对象判断是否为某个类的实例创建实例获取构造器信息获取类的成员变量调用方法利用反射创建数组反射获取泛型真实类型TypeVariableParameterizedTypeGenericArr
头歌java 实训 答案 代码 java入门
热门推荐
个人博客地址https://sun98k.github.io/
12-06 17万+
头歌java实训参考答案，文章附带目录，谢谢大家的支持。祝大家实训满分。
ASP.NET面试题
我地地盘
09-13 1026
面试 一般会叫你填两个表 1个是你的详细信息表 1个是面试题答卷 两个都要注意反正面是否都有内容不要遗漏，如果考你机试一般也有两种，就是程序连接数据库或一些基本的算法（二分查找，递归等），公司一般都是测试你的基本功是否扎实，如果你基本功好就游刃有余不必紧张！ asp.net面试题 1.new有几种用法 第一种:new Class(); 第二种:覆盖方法 public new XXXX(){} 第三
Java基础——注解和反射——注解自定义与反射具体使用实例
Arrake的博客
08-12 587
1.注解 1.1、什么是注解？ 注解就是源代码的元数据，通熟的讲就是代码中的标签。注解就有如下的特点： 注解是一个附属品，依赖于其他元素（包、类、方法、属性等等）存在。 注解本身没有作用，在恰当的时候由外部程序进行解析才会发生作用。 1.2、注解有哪些？ 按来源分 JDK 自带注解，例如：@Override, @Deprecated, @SuppressWornings 。 第三方注解。 自定义注解。 按生命周期划分 SOURCE：只存在于源代码中，编译成 class 文件就不存在了。 Cla
android 注解和反射 (入门以及使用)
高级开发者进阶ing... QaQ
08-16 921
先来看一看今天的效果: 代码效果: 效果不重要,重要的是代码: 注解 官方解释: 从JDK5开始,Java增加对元数据的支持，也就是注解，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记，这些标记可以在编译，类加载，运行时被读取，并执行相应的处理。通过注解开发人员可以在不改变原有代码和逻辑的情况下在源代码中嵌入补充信息。 百度百科 定义一个注解: public @interface SZJ{ } 元注解: 元注解是用来标示当前注解是干什么用的,什么时候用,常用的有2个 @Target E
Java进阶——注解和反射
万里顾一程的博客
03-26 5896
文章目录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增加对元数据的支持，也就是注解，注解与注释是有一定区别的，可以把注解理解为代码里的特殊标记， 注解的作
注解和反射(狂神) 笔记
weixin_43905212的博客
12-14 1347
视频链接 p1 什么是注解：不是程序本身，可以对程序作出解释，但是区别于注释，注解可以写入参数，通过反射机制来获取所注解信息的访问。 p2 元注解：用来注解其他注解，有4个标准的meta-annotation：@Target、@Retention、@Documented、@Inherited，前两个常用。 Target需要传入ElementType数组作为value表示使用范围，其中ElementType是一个枚举类enum，包括类、域、方法、参数等。 Retention表示注解在什么地方有效，SO
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
java基础之注解和反射
08-05
java基础之注解和反射
注解和反射机制的学习笔记
03-05
在Java编程语言中，注解（Annotation）和反射（Reflection）是两个强大的工具，它们极大地扩展了代码的灵活性和动态性。这篇学习笔记将深入探讨这两个主题，帮助开发者更好地理解和运用它们。 首先，我们来了解注解...
java注解和反射的12个demo.zip
04-28
Java注解和反射是Java编程中的重要特性，它们极大地增强了代码的灵活性和可维护性。在Java中，注解（Annotation）是一种元数据，它提供了将信息附加到代码（类、方法、变量等）的方式，而反射则允许我们在运行时检查...
Java使用注解和反射简化编程的方法示例
08-25
例如，在调用大量方法时，可以使用反射和注解简化编程。 下面是一个使用注解和反射简化编程的实例。首先，定义一个注解testAnnoation10： ```java @Documented @Retention(RetentionPolicy.RUNTIME) @Target...
Java内存模型
最新发布
weixin_44267758的博客
07-19 303
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 558
JVM-垃圾回收与内存分配
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 839
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
【Java算法】前缀和 下
2302_79806056的博客
07-18 885
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
如何通过注解和反射获取借接口名
07-16
要通过注解和反射获取接口名，首先需要定义一个注解，并将其应用到接口上。然后使用反射机制来获取接口上的注解信息。 下面是一个示例代码： ```java // 定义一个注解 @Retention(RetentionPolicy.RUNTIME) @...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值