JAVA----反射与注解入门学习

最新推荐文章于 2023-08-28 21:04:58 发布
最新推荐文章于 2023-08-28 21:04:58 发布
阅读量260 收藏
点赞数
分类专栏： JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qwrdxer/article/details/107703496
版权

写在最前面

这篇笔记是看秦老师的 注解和反射 视频写的, 建议去看视频学习， 能掌握更多的内容

B站链接在此:

视频链接https://www.bilibili.com/video/BV1p4411P7V3

主页链接https://space.bilibili.com/95256449

在学习注解之前，只知道@Test 的 Junit 包 , 发现后面要学习的Spring 等框架需要用到, 就来补一课
下面的内容可以作为笔记参考，直接看文档可能观感不佳, 视频中的大部分代码都有写，适合边看视频边实际操作，一共两个小时也不算太长。

注解

注解入门

什么是注解

image-20200730103754446

内置注解

image-20200730105008727

@Override 重写父类方法

    @Override
    public String toString() {
        return super.toString();
    }

@Deprecated 表示, 不推荐使用 , 但是可以使用 ，或者存在更好的方法 , 在IDEA中使用这个元素时有删除线提醒

image-20200730110449162

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

image-20200730110939293

image-20200730111102861

元注解

image-20200730111246408

元注解作用是 注解其他的注解 元注解有以下几种:

  1. @Target 指定注解的使用范围
  2. @Retention 描述注解的生命周期
    • SOURCE: 在源文件中有效
    • CLASS : 在类文件中有效
    • RUNTIME: 在运行时有效
  3. @Documented 说明注解将被包含在javadoc中
  4. @Inherited 说明子类可以继承父类中的该注解

详细说明如下:

注解声明

@Target(value = {ElementType.METHOD,ElementType.TYPE})//指定作用域为 方法(METHOD) 或者 类(TYPE)
@Retention(value = RetentionPolicy.RUNTIME) //表示注解在什么时候有效
public @interface MyAnnotation{
		// 具体的内容 , 在下面的自定义注解中解释
        }

@Target

**例子: **

@Target(value = {ElementType.METHOD,ElementType.TYPE})

通过设置value的值, 可以指定该注解的作用范围 ，各种值如下:

    /** Class, interface (including annotation type), or enum declaration */
    TYPE,    //类 接口 等

    /** Field declaration (includes enum constants) */
    FIELD,  

    /** Method declaration */
    METHOD,   //方法

    /** Formal parameter declaration */
    PARAMETER,   // 参数

    /** Constructor declaration */
    CONSTRUCTOR,  // 构造器

    /** Local variable declaration */
    LOCAL_VARIABLE,  // 本地变量

    /** Annotation type declaration */
    ANNOTATION_TYPE,  //注解

    /** Package declaration */
    PACKAGE,   //包

    /**
     * Type parameter declaration
     *
     * @since 1.8
     */
    TYPE_PARAMETER,

    /**
     * Use of a type
     *
     * @since 1.8
     */
    TYPE_USE

@Retention

使用举例：

@Retention(value = RetentionPolicy.RUNTIME) //设置作用时间为运行时

同样是通过设置value的值来指定生命周期 ， 值如下

    /**
     * Annotations are to be discarded by the compiler.
     */
    SOURCE, 

    /**
     * Annotations are to be recorded in the class file by the compiler
     * but need not be retained by the VM at run time.  This is the default
     * behavior.
     */
    CLASS,

    /**
     * Annotations are to be recorded in the class file by the compiler and
     * retained by the VM at run time, so they may be read reflectively.
     *
     * @see java.lang.reflect.AnnotatedElement
     */
    RUNTIME

**注:生命周期大小 runtime>class>sources **

自定义注解

image-20200730114009118

自定义注解 使用public @ interface 来声明

  1. 自定义注解中的每一个方法 实际上是声明的配置参数 ，在使用该注解的时候需要指定该参数的值, 不然会报错
  2. 方法的名称就是参数的名称

image-20200730114602715

image-20200730115022689

可以通过default来声明参数的默认值 ，这样调用时 可以不指定参数 ，也可以显示的赋值

image-20200730114910826

规范： 如果参数成员只有一个 ，推荐名为value

反射机制

image-20200730115640692

Java反射机制概述

在了解反射之前可以先理解一下静态和动态语言

  1. 动态语言是可以在运势是改变其结构的语言 ( 边编译边执行)。
  2. 动态语言在运行时无法改变结构 ( 一次编译 ，永久运行)。
  3. java通过引入反射的机制, 使得自身具有了一定的动态性。

image-20200730122039082

反射

  1. 借助反射的API 可以获取类的任何内部信息 , 并且能够直接操作任意对象的内部属性以及方法。
  2. 类加载后 , 在堆内存的方法区中就产生了一个Class类型的对象( 一个类只有一个Class对象), 这个类就包含了完整的类的结构信息
  3. 如下图的最后流程图 , 通过反射的机制 , 可以创建一个对象, 通过对象 获取类 ,

image-20200730122412169

反射机制研究和应用

image-20200730124223007

反射优点和缺点：

在实现了动态创建对象和编译的时候 , 损失了一部分性能

image-20200730124320189

代码测试

package com.qwrdxer.reflection;

public class Test01 {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的class对象
            //可能找不到类, 需要抛出异常
        Class c1=Class.forName("com.qwrdxer.reflection.User");
    }
}

//定义一个实体类

class User{
    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() {
        final StringBuilder sb = new StringBuilder("{");
        sb.append("\"name\":\"")
                .append(name).append('\"');
        sb.append(",\"id\":")
                .append(id);
        sb.append(",\"age\":")
                .append(age);
        sb.append('}');
        return sb.toString();
    }

}

通过Class c1=Class.forName(“com.qwrdxer.reflection.User”); 来加载class对象 ，可以获取这个类的所有内部信息

image-20200730125234509

理解Class类并获取Class实例

image-20200730125513337

常用的方法:

image-20200730125639981

获取Class类的实例方法

image-20200730125724405

具有Class对象 的类型

image-20200730130305268

        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

在数组中 , 只要元素类型 和维度一样，class一样

类的加载与ClassLoader

image-20200730131015021

类的加载过程

image-20200730131038923

类的加载与ClassLoader理解

image-20200730131114309

测试代码

package com.qwrdxer.reflection;

public class Test05 {
    public static void main(String[] args) {
        A a=new A();
        System.out.println(A.m);
    }
}

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

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

运行结果

image-20200730132356572

分析

  1. 首先将类加载到方法区 ，在堆中, 生成class对象

  2. 链接 ，结束后m=0

  3. 初始化

    • System.out.println(“A类静态代码块初始化”);
      m=200;
    • m=100;

什么时候发生类的初始化

image-20200730133240154

代码如下

package com.qwrdxer.reflection;

public class Test06 {
    static {
        System.out.println("Main类  加载");

    }

    public static void main(String[] args) throws ClassNotFoundException {
        //1. 主动引用
        Son son=new Son();
        //输出结果:
        //Main类  加载
        //父类   加载
        //子类    加载

        //2. 反射 也会产生主动引用
        Class.forName("com.qwrdxer.reflection.Test06");
        //输出结果:
        //Main类  加载
        //父类   加载
        //子类    加载


        //不会产生类的引用的方法
        System.out.println(Son.b);//父类静态变量
        Son[] array=new Son[4];//创建数组
        System.out.println(Son.M);//常量
    }
}

class Father{
    static int b=2;
    static {
        System.out.println("父类   加载");
    }
}
class Son extends Father{
    static {
        System.out.println("子类    加载");
    }
    static  int m=100;
    static final int M=1;
}

类加载器的作用

image-20200730134934211

image-20200730135501212

image-20200730135813904

根加载器是C++编写的,无法直接获取 返回null

package com.qwrdxer.reflection;

public class Test07 {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取系统类的加载器
        ClassLoader systemClassLoader=ClassLoader.getSystemClassLoader();
        //获取系统类加载器的父类加载器 --> 扩展类加载器
        ClassLoader parent =systemClassLoader.getParent();

        //获取扩展类加载器的父类加载器---> 根加载器(**根加载器是C++编写的,无法直接获取 返回null**)
        ClassLoader parent1=parent.getParent();

        //测试当前类加载器是由哪个加载器加载的
        ClassLoader classLoader=Class.forName("com.qwrdxer.reflection.Test07").getClassLoader();
        System.out.println(classLoader);
            //sun.misc.Launcher$AppClassLoader@18b4aac2

        //测试JDK内置的类是谁加载的
        classLoader =Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader);
            //null
        
        //获取系统类加载器可以加载的路径
        for(String s:System.getProperty("java.class.path").split(";")){
            System.out.println(s);
        }
		 //C:\Program Files\Java\jdk1.8.0_251\jre\lib\charsets.jar
        //C:\Program Files\Java\jdk1.8.0_251\jre\lib\deploy.jar
        //C:\Program Files\Java\jdk1.8.0_251\jre\lib\ext\access-bridge-64.jar
        //C:\Program Files\Java\jdk1.8.0_251\jre\lib\ext\cldrdata.jar
        //C:\Program Files\Java\jdk1.8.0_251\jre\lib\ext\dnsns.jar
        //C:\Program Files\Java\jdk1.8.0_251\jre\lib\ext\jaccess.jar
        //C:\Program Files\Java\jdk1.8.0_251\jre\lib\ext\jfxrt.jar
        //C:\Program Files\Java\jdk1.8.0_251\jre\lib\ext\localedata.jar
        //C:\Program Files\Java\jdk1.8.0_251\jre\lib\ext\nashorn.jar
        //C:\Program Files\Java\jdk1.8.0_251\jre\lib\ext\sunec.jar
        //C:\Program Files\Java\jdk1.8.0_251\jre\lib\ext\sunjce_provider.jar
        //C:\Program Files\Java\jdk1.8.0_251\jre\lib\ext\sunmscapi.jar
        //C:\Program Files\Java\jdk1.8.0_251\jre\lib\ext\sunpkcs11.jar
        //C:\Program Files\Java\jdk1.8.0_251\jre\lib\ext\zipfs.jar
        //C:\Program Files\Java\jdk1.8.0_251\jre\lib\javaws.jar
        //C:\Program Files\Java\jdk1.8.0_251\jre\lib\jce.jar
        //C:\Program Files\Java\jdk1.8.0_251\jre\lib\jfr.jar
        //C:\Program Files\Java\jdk1.8.0_251\jre\lib\jfxswt.jar
        //C:\Program Files\Java\jdk1.8.0_251\jre\lib\jsse.jar
        //C:\Program Files\Java\jdk1.8.0_251\jre\lib\management-agent.jar
        //C:\Program Files\Java\jdk1.8.0_251\jre\lib\plugin.jar
        //C:\Program Files\Java\jdk1.8.0_251\jre\lib\resources.jar
        //C:\Program Files\Java\jdk1.8.0_251\jre\lib\rt.jar
        //E:\平时写的代码\Java\注解和反射\out\production\注解和反射
        //G:\develop\IntelliJ IDEA 2019.3.3\lib\idea_rt.jar
    }
}

获取运行时类的完整结构

image-20200730145217172

package com.qwrdxer.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.qwrdxer.reflection.User");
        System.out.println(c1.getName());//获取包名+类名
        System.out.println(c1.getSimpleName());//获得类名


        //获得类的属性
        //Field[] fields = c1.getFields();  只能找到public的属性
        Field[] fields = c1.getDeclaredFields(); // 能找到全部属性
        for (Field field : fields) {
            System.out.println(field);
        }
            //获得指定属性的值
        Field name = c1.getDeclaredField("name");

        //获得类的方法
        Method[] methods = c1.getMethods();//获得本类和父类的全部public方法
        for (Method method : methods) {
            System.out.println(method);
        }
        Method[] declaredMethods = 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);

        //获得构造器
        Constructor[] constructors = c1.getConstructors();
        Constructor[] declaredConstructors = c1.getDeclaredConstructors();

            //获得指定的构造器
        Constructor constructor = c1.getConstructor(String.class,int.class,int.class);
    }
}

调用运行时类的指定结构

image-20200730185335908

通过反射动态创建对象( 无参)

package com.qwrdxer.reflection;

//通过反射动态创建对象
public class Test09 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        Class c1=Class.forName("com.qwrdxer.reflection.User");

        //创建对象
        User user=(User)c1.newInstance();//本质是调用了类的无参构造器
        System.out.println(user.toString());
    }

}

有参构造器

        //通过构造器创建对象
        Constructor constructor = c1.getConstructor(String.class, int.class, int.class);
        User user2 = (User)constructor.newInstance("test", 001, 18);

通过反射调用普通方法

image-20200730191228185

        //通过反射调用普通方法
        User user3=(User)c1.newInstance();
            //通过反射获取方法
        Method setName=c1.getMethod("setName", String.class);
            //invoke 激活  第一个参数为对象 ，第二个参数为要传递的参数值
        setName.invoke(user3,"qwrdxer");
        System.out.println(user3.toString());

image-20200730191254020

通过反射操作属性

        //通过反射操作属性
        User user4=(User)c1.newInstance();
        Field name = c1.getDeclaredField("name");
            //如果属性是私有的, 需要显示的设置可以访问(关闭程序的安全检测)
        name.setAccessible(true);
            //使用set方法设置
        name.set(user4,"qwrdxer2");
        System.out.println(user4);

setAccessible 性能分析

image-20200730191423792

package com.qwrdxer.reflection;

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

public class test10 {
    public static void main(String[] args) throws NoSuchMethodException, ClassNotFoundException, InvocationTargetException, IllegalAccessException {
     User user=new User();
     long startTime =System.currentTimeMillis();
     for(int i=0;i<10000000;i++){
         user.getAge();
     }
     long endTime =System.currentTimeMillis();
     System.out.println("使用普通方式执行方法："+(endTime-startTime)+"ms");

     //反射的方式
        Class c1=Class.forName("com.qwrdxer.reflection.User");
        Method getName=c1.getMethod("getName");
        User user2=new User();
        long startTime2 =System.currentTimeMillis();
        for(int i=0;i<10000000;i++){
            getName.invoke(user2,null);
        }
        long endTime2 =System.currentTimeMillis();
        System.out.println("使用反射方式执行方法："+(endTime2-startTime2)+"ms");

      //反射方式 , 关闭检测
        Class c2=Class.forName("com.qwrdxer.reflection.User");
        Method getName2=c2.getMethod("getName");
        User user3=new User();
        getName2.setAccessible(true);//关闭检测
        long startTime3 =System.currentTimeMillis();
        for(int i=0;i<10000000;i++){
            getName2.invoke(user3,null);
        }
        long endTime3 =System.currentTimeMillis();
        System.out.println("使用反射方式(关闭检测)执行方法："+(endTime3-startTime3)+"ms");
    }
}

image-20200730192335791

获取泛型信息

image-20200730192422570

代码如下

package com.qwrdxer.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 test01 = Test11.class.getMethod("test01", Map.class, List.class);
        Type[] genericParameterTypes = test01.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);
                }
            }

        }
    }
}

输出:
#java.util.Map<java.lang.String, com.qwrdxer.reflection.User>
class java.lang.String
class com.qwrdxer.reflection.User
#java.util.List<com.qwrdxer.reflection.User>
class com.qwrdxer.reflection.User

反射操作注解

image-20200730225529696

package com.qwrdxer.reflection;

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

//练习反射操作注解
public class Test13 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class<?> aClass = Class.forName("com.qwrdxer.reflection.Student2");

        //通过反射获得注解
        Annotation[] annotations = aClass.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }

        //获得注解中Value的值
        Tableau annotation = aClass.getAnnotation(Tableau.class);
        String value = annotation.value();
        System.out.println(value);

        //获得类指定的注解
        Field[] fields = aClass.getDeclaredFields();
        for (Field field : fields) {
            Fieldau annotation1 = field.getAnnotation(Fieldau.class);
            System.out.println(annotation1.columnName());
            System.out.println(annotation1.length());
            System.out.println(annotation1.type());
        }
//        Field name = aClass.getDeclaredField("name");
//        Fieldau annotation1 = name.getAnnotation(Fieldau.class);
//        System.out.println(annotation1.type());
//        System.out.println(annotation1.length());
//        System.out.println(annotation1.columnName());
    }
}
@Tableau("db_student")
class Student2{
    @Fieldau(columnName = "db_id",type = "int",length = 10)
    private int id;
    @Fieldau(columnName = "db_age",type = "int",length = 10)
    private int age;
    @Fieldau(columnName = "db_name",type = "String",length = 10)
    private String name;

    public Student2(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    public Student2() {
    }

    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 new StringJoiner(", ", Student2.class.getSimpleName() + "[", "]")
                .add("id=" + id)
                .add("age=" + age)
                .add("name='" + name + "'")
                .toString();
    }
}


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

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

etId(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 new StringJoiner(", ", Student2.class.getSimpleName() + "[", "]")
            .add("id=" + id)
            .add("age=" + age)
            .add("name='" + name + "'")
            .toString();
}

}

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

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Fieldau{
String columnName();
String type();
int length();
}
qwrdxer
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java-annotation:Java注解入门教程
07-08
Java注解是Java编程语言中的一个重要特性，它提供了一种元数据的方式，使得开发者可以在代码中添加额外的信息，这些信息可以被编译器或者运行时环境用来进行代码分析、验证或者自动化处理。本教程将带你深入理解Java...
Java基础语法测试-基础数据类型-注解-数组-inet-反射-oop-Java代码实现
最新发布
03-09
内容概要：通过带着读者编写Java基础语法测试代码，理解基础数据类型-注解-数组-inet-反射-oop-Java代码实现过程和测试代码 适合人群：初学java语法入门测试代码 能学到什么：①注解、数组、数据类型、inet、method...
反射和注解
lsplook的博客
08-28 154
java.lang.Class 表示类的类型。一个Class类对象就代表了某个类的字节码对象。获取到这个类的字节码对象后该类中所有的内容都会被知道，然后就可以对这个类中的内容进行操作。Class类是Java 反射机制的起源和入口 ，用于获取与类相关的各种信息，提供了获取类信息的相关方法，Class类继承自Object类。java中提供的对反射支持的类都在java.lang.reflet包中。java.lang.reflect.Field 表示类中属性的属性对象。类中每一个属性对应一个属性对象。
注解与反射
记录学习历程
05-18 526
注解（Annotation）是从JDK5.0开始引入的技术，以在代码中存在，例如：Annotation可以像修饰符一样被使用，可用于修饰包、类、构造器、成员变量、参数、局部变量的声明，还可添加一些参数值注解也可以看做是一种注释，通过使用Annotation，程序员可以在不改变原有逻辑的情况下，在源文件中嵌入一些补充信息。但是，注解，不同于单行注释和多行注释在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE/Android中注解占据了更重要的角色，例如用来配置应用程序的任
注解和反射知识总结(纯干货,附代码举例)
Nohara Rin
03-16 1411
注解和反射知识总结(纯干货,附代码举例) 注解 Annotation是从JDK5.0开始引入的技术 Annotation的作用： 不是程序本身，可以对程序作出解释。（这一点和注释（comment）没什么区别） 可以被其他程序（比如：编译器等）读取 Annotation的格式： 注解是以"@注释名"在代码中存在的，还可以添加一些别的参考值，例如：@SuppressWarnings(value=“unchecked”). Annotation在哪里使用？ 可以附加在package，class，method，fi
注解的作用
weixin_30533797的博客
06-25 198
编译检查 Annotation具有“让编译器进行编译检查的作用”。 例如，@SuppressWarnings, @Deprecated和@Override都具有编译检查作用。 在反射中使用Annotation 在反射的Class, Method, Field等函数中，有许多于Annotation相关的接口。 这也意味着，我们可以在反射中解析并使用Annotation。 根据Annotation生...
枚举类和注解小结（自用小结笔记）
Giapeace的博客
10-29 212
枚举类和注解枚举类的使用注解 枚举类的使用 1.枚举类的说明 枚举类的理解：当一个类的对象是有限个，确定的时候，我们称此类为枚举类。 当需要定义一组常量时，强烈建议使用枚举类。 如果枚举类中只有一个对象，则可以作为单例模式的实现方式。 2.如何自定义枚举类，步骤： 方式一：jdk5.0之前自定义枚举类 方式二：jdk5.0，可以使用enum关键字定义枚举类 //自定义枚举类 class Season{ //1.声明Season对象的属性:private final 来修饰 priva
java-SE基础学习资料及介绍
01-19
2. **类与对象**：Java是一种面向对象的语言，学习如何定义类，创建对象，以及理解类的属性（字段）和方法。了解构造函数、访问修饰符（public, private, protected, default）的作用，以及封装的概念。 3. **继承...
java-inicial:入门Java
03-31
12. **反射与注解**：反射允许在运行时检查类、接口、字段和方法的信息，而注解提供了元数据，可以用于代码分析、编译时检查或运行时行为的定制。 13. **JavaFX和Swing**：对于图形用户界面（GUI）开发，Java提供了...
java-course：Java入门
02-10
课程可能还会涵盖泛型、反射、注解等进阶主题，并通过实践项目来巩固所学知识。 总之，"Java入门"是一个全面介绍Java编程语言的基础课程，涵盖了从基础语法到核心概念的各个方面，对于想要踏入Java开发领域的初学者...
反射与注解
danfengw的博客
08-09 670
目录反射 注解反射java反射：可以获取正在运行的Java对象，调用该对象的属性、方法、构造器。 实现反射的类： Class类：它表示正在运行的Java应用程序中的类和接口 Field类：提供有关类或接口的属性信息，以及对它的动态访问权限 Constructor：提供关于类的单个构造器的信息以及对它的访问权限 Method:提供关于类或接口中某个方法信息 反射的使用：package c
Java中如何创建自定义的注解
IT老兵的驿站
04-24 3109
前言 关于Java的注解，我一直在用，没有太搞明白它的原理，至于如何自定义一个注解，就更不明白了。其实参考的这篇文章，之前看过一遍，当时以为看懂了，但是最近在工作中去印证的时候，发现对注解还是不理解，所以这两天又再看了一遍，感觉这下又懂了一些。 本文针对着原文的段落进行备注和记录笔记。 正文 This comprehensive look at annotations in Java ...
junit,反射,注解
weixin_42252237的博客
12-21 155
junit,反射,注解 1.Junit单元测试 1、测试的分类 A.黑盒测试:不需要写代码 B.白盒测试:需要编写代码(Junit单元测试属于白盒) 2、Junit单元测试的步骤 A.定义测试类(包名称: xxx.xxx.test , 类名称： 需要测试名称Test) B.定义测试方法(可以独立运行,名称:test测试的方法名称,返回值和参数列表空) C.给方法加注解 @Test D.添加Jun...
M2(学习)-08-Java自定义注解的创建
FROZENcj的博客
02-23 155
自定义注解
反射与注解的使用
tbdp6411的专栏
07-10 889
作用：注解是附加在代码中的一些信息，用于编译、运行时解析和使用，起到说明配置作用  主要学习两方面1 元注解，2 自定义注解  一、元注解  包括：1.@Target, 　2.@Retention 　3.@Documented, 4.@Inherited 几种 1 @Target    作用：用于描述注解的使用范围（即 注解是描述：包、类、字段、方法、参数、接口等）
反射和注解的知识
qq_43697752的博客
02-16 133
反射 反射的理论 类的加载过程 类加载器 反射机制 获取Class类的对象 射获取的各种方法和属性 注解（annotation） 什么注解？ 注解不是程序本身，可以对程序作出解释 可以被其它程序读取 有一定的的约束功能 常见内置注解 @Override：用于修饰此方法覆盖了父类的方法; @Deprecated：用于修饰已经过时的方法; @SuppressWarnnings:用于通知java编译...
Mybatis-Plus最新教程
11-14
Mybatis-Plus的核心原理在于通过扫描实体类并利用反射技术获取实体类信息，这些信息被用于构建数据库操作的相关元数据。 1. **依赖配置** 在项目中引入Mybatis-Plus，首先需要在`pom.xml`或`build.gradle`中添加...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值