注解和反射

注解和反射

1.注解

1.什么是注解

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

annotation的作用：

不是程序本身，可以对程序作出解释。(这一点和注释(comment)没什么区别)

​ 可以被其他程序(比如：编译器等)读取。

annotation的格式：

​ 注解是以“@注释名”在代码中存在的，还可以添加一些参数值，

例如： @SuppressWarnings(value = "unchecked")

annotation在哪里使用？

​ 可以附加在package、class、method、field等上面，相当于给他们添加一些额外的辅助信息，

​ 我们可以通过反射机制编程实现对这些元数据的访问。

2.内置注解

image-20220306090519318

package com.jihu;

import java.util.ArrayList;
import java.util.List;
//什么是注解
public class Demo01 extends  Object {

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

    //@Deprecated   不推荐程序员使用，但是可以使用，或者存在更好的方式
    @Deprecated
    public static  void test(){
        System.out.println("Deprecated");
    }
    @SuppressWarnings("all")  //加上这个注解  list这就不会报警告了
    public void test2(){
        List list = new ArrayList<>();
    }

    public static void main(String[] args) {
        test();
    }

}

3.元注解

image-20220306092245500

package com.jihu;
import java.lang.annotation.*;

//测试元注解
@Myannotation
public class Demo02 {

    public void test(){

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

//Retention  表示我们的注解在什么地方还有效
//runtime>class>sources
@Retention(RetentionPolicy.RUNTIME)

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

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

}

4.自定义注解

image-20220306093732605

package com.jihu;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//自定义注解
public class Demo03 {
    //注解可以显示赋值，   如果没有默认值，我们就必须给注解赋值
//    @Myannotation2(name = "jihu")
    @Myannotation2(age = 18)
    public void test(){ }

    @Myannotaion3("jihu")
    public void test1(){}
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface Myannotation2{
    //注解的参数：  参数类型 +  参数名 ()
    String name() default "";
    int age() ;
    int id() default  -1;  //如果默认值为-1，代表不存在
    String[] schools() default {"西北工业大学","清华大学"};

}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface Myannotaion3{
    String value(); //当这个参数名是value时  上面可以省略注解的参数名
}

2.反射机制

1.反射概述

image-20220306095920593

image-20220306100046075

2.获得反射对象

image-20220306100411688

image-20220306100457118

image-20220306100517404

package com.jihu.reflection;
//什么叫反射
public class Demo01 extends  Object {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的class对象
        Class c1 = Class.forName("com.jihu.reflection.User");
        System.out.println(c1);

        Class c2 = Class.forName("com.jihu.reflection.User");
        Class c3 = Class.forName("com.jihu.reflection.User");
        Class c4 = Class.forName("com.jihu.reflection.User");
        //一个类在内存中只有一个class对象     因为他们的hashcode值相同
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
        System.out.println(c4.hashCode());

    }
}
//实体类
class User{
    private String name;
    private Integer age;

    public User() {
    }

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
输出结果：
class com.jihu.reflection.User
2083562754
2083562754
2083562754

image-20220306101557584

3.得到Class类的几种方式

image-20220306102031333

class类的常用方法

image-20220306102055035

image-20220306102345602

package com.jihu.reflection;
//测试class类的创建方式有哪些
public class Demo02 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println("这个人是："+person);

        //方式一：通过对象获得
        Class c1 = person.getClass();
        System.out.println(c1.hashCode());
        //方式二：forname获得
        Class c2 = Class.forName("com.jihu.reflection.Student");
        System.out.println(c2.hashCode());
        //方式三： 通过类名.class获得
        Class<Student> c3 = Student.class;
        System.out.println(c3.hashCode());
        //方式四： 基本内置类型的包装类都有一个Type属性
        Class<Integer> c4 = Integer.TYPE;
        System.out.println(c4.hashCode());
        //获得父类 类型
        Class c5 = c1.getSuperclass();
        System.out.println(c5);
        
        Class<? super Student> c6 = c3.getSuperclass();
        System.out.println(c6);

    }
}

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 Teacher extends Person{
    public Teacher(){
        this.name = "老师";
    }
}

输出结果
这个人是：Person{name='学生'}
1239731077
1239731077
1239731077
1766822961
class com.jihu.reflection.Person
class com.jihu.reflection.Person

4.所有类型的Class对象

image-20220306113138033

package com.jihu.reflection;

import java.lang.annotation.ElementType;

//所有类型的Class
public class Demo03 {
    public static void main(String[] args) {
        Class c1 = Object.class;  //类
        Class c2 = Comparable.class;  //接口
        Class c3 = String[].class; //一维数组
        Class c4 = String[][].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.getClass().hashCode());
        System.out.println(b.getClass().hashCode());

    }
}
输出结果：
class java.lang.Object
interface java.lang.Comparable
class [Ljava.lang.String;
class [[Ljava.lang.String;
interface java.lang.Override
class java.lang.annotation.ElementType
class java.lang.Integer
void
class java.lang.Class
2083562754
2083562754

5.类加载内存分析

image-20220306115631298

image-20220306115654779

image-20220306115719353

package com.jihu.reflection;

public class Test05 {
    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类的无参构造初始化");
    }

}
输出结果：
A类静态代码块初始化
A类的无参构造初始化
100

image-20220306115844468

6.分析类初始化

image-20220306132624052

package com.jihu.reflection;

public class Demo05 {
    static {
        System.out.println("Main类被加载");
    }
    public static void main(String[] args) throws ClassNotFoundException {
        //1. 主动引用
        //Son son = new Son();

        //反射也会产生主动引用
        Class.forName("com.jihu.reflection.Son");
                /*
                Main类被加载
                父类被加载
                子类被加载
                 */
        //2.被动引用
        //不会产生类的引用的方法
       // System.out.println(Son.b);
           /* 输出结果：    Main类被加载
                         父类被加载
                         子类被加载 */
        //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类被加载
父类被加载
子类被加载

7.类加载器

image-20220306142517468

image-20220306142716599

package com.jihu.reflection;
public class Demo06 {
    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++)
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);

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

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

        //如何获得系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));
    }
}
输出结果：
jdk.internal.loader.ClassLoaders$AppClassLoader@2437c6dc
jdk.internal.loader.ClassLoaders$PlatformClassLoader@7c30a502
null
jdk.internal.loader.ClassLoaders$AppClassLoader@2437c6dc
null
D:\workface1\annotationandreflect\out\production\demo01

8.获取类的运行时结果

image-20220306144407561

package com.jihu.reflection;

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

//获得类的信息
public class Demo07 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("com.jihu.reflection.User");
        //或者
        /*User user = new User();
        Class c1 = user.getClass();*/
        //获得类的名字
        System.out.println(c1.getName());  //获得包名 + 类名
        System.out.println(c1.getSimpleName()); //类名

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

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

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

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

        //获得指定方法
        //重载
        System.out.println("------");
        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(); //获得全部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);
        System.out.println("指定:"+declaredConstructor);

    }
}
输出结果：
com.jihu.reflection.User
User
--------
private java.lang.String com.jihu.reflection.User.name
private java.lang.Integer com.jihu.reflection.User.age
private java.lang.Integer com.jihu.reflection.User.age
=======
正常的：public java.lang.String com.jihu.reflection.User.getName()
正常的：public java.lang.String com.jihu.reflection.User.toString()
正常的：public void com.jihu.reflection.User.setName(java.lang.String)
正常的：public java.lang.Integer com.jihu.reflection.User.getAge()
正常的：public void com.jihu.reflection.User.setAge(java.lang.Integer)
正常的：public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
正常的：public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
正常的：public final void java.lang.Object.wait() throws java.lang.InterruptedException
正常的：public boolean java.lang.Object.equals(java.lang.Object)
正常的：public native int java.lang.Object.hashCode()
正常的：public final native java.lang.Class java.lang.Object.getClass()
正常的：public final native void java.lang.Object.notify()
正常的：public final native void java.lang.Object.notifyAll()
--------
public java.lang.String com.jihu.reflection.User.getName()
public java.lang.String com.jihu.reflection.User.toString()
private void com.jihu.reflection.User.test()
public void com.jihu.reflection.User.setName(java.lang.String)
public java.lang.Integer com.jihu.reflection.User.getAge()
public void com.jihu.reflection.User.setAge(java.lang.Integer)
------
public java.lang.String com.jihu.reflection.User.getName()
public void com.jihu.reflection.User.setName(java.lang.String)
------
--public com.jihu.reflection.User()
--public com.jihu.reflection.User(java.lang.String,java.lang.Integer)
++public com.jihu.reflection.User()
++public com.jihu.reflection.User(java.lang.String,java.lang.Integer)

9.动态创建对象执行方法

image-20220306155325910

image-20220306155325910

10.获取泛型信息(了解)

image-20220306160749806

11.获取注解信息(练习)

image-20220306172954852

package com.jihu.reflection;
import java.lang.annotation.*;
import java.lang.reflect.Field;

//联系反射操作注解
public class Demo10 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        Class c1 = Class.forName("com.jihu.reflection.Student2");  //通过反射获得一个class对象

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

        //获得类指定的注解
        System.out.println("-------------");
        Field name = c1.getDeclaredField("id");
        FiledKuang annotation = name.getAnnotation(FiledKuang.class);
        System.out.println(annotation.ColumnName());
        System.out.println(annotation.type());
        System.out.println(annotation.length());

    }
}

@TableKuang("db_student")
class Student2{
    @FiledKuang(ColumnName = "db_id",type = "int",length = 10)
    private int id;
    @FiledKuang(ColumnName = "db_age",type = "int",length = 10)
    private int age;
    @FiledKuang(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 TableKuang{
    String value();
}

//属性的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FiledKuang{
    String ColumnName();
    String type();
    int length();
}
输出结果
@com.jihu.reflection.TableKuang(value="db_student")
db_student
-------------
db_id
int
10
posted @   爲誰心殇  阅读(22)  评论(0)  编辑  收藏  举报
相关博文：
· Java基础
· Java基础常见知识&面试题总结(中)
· JAVA注解和反射
· Java注解和反射
· 注解和反射
阅读排行：
· DeepSeek 开源周回顾「GitHub 热点速览」
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 单线程的Redis速度为什么快？
>
点击右上角即可分享
微信分享提示
AI FOR CODE 大赛

目录导航