注解与反射（全）

最新推荐文章于 2024-08-22 18:47:19 发布

小白皮卡丘

最新推荐文章于 2024-08-22 18:47:19 发布

阅读量55

点赞数

文章标签： java spring 数据库

本文链接：https://blog.csdn.net/weixin_48449322/article/details/131406002

版权

注射与反射

1. 注解—Annotation

内置注解：
- @Override 重写的注解
- @Deprecated 不推荐程序员使用，但是可以使用，或者存在更好的方式
- @SuppressWarnings(“all”) 用来抑制编译时的警告信息

元注解：

负责注解其他注解
@Target：被描述的注解可以用到什么地方
@Retention：表示需要在什么级别保存该注释信息，用于描述注解的生命周期
@Documented：是否生成文档注释
@Inherited：说明子类可以继承父类中的该注解

package annotation;

import java.lang.annotation.*;

public class Test01 {
    @MyAnnotation
    public void test(){

    }
}
//定义一个注解
//Target 表示我们的
@Target(value = {ElementType.METHOD,ElementType.TYPE})
//Retention 表示我们的注解在什么地方还有效
//  runtime > class > source
@Retention(value = RetentionPolicy.RUNTIME)    
//Documented 表示是否将我们的注解生成JAVAdoc中文档
@Documented
//Inherited 子类可以继承父类的注解
@Inherited
@interface MyAnnotation{
}

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

package annotation;

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

//自定义注解
public class Test02 {
    @MyAnnotation2(name = "a",age = 18)
    public void test1(){}
    @MyAnnotation3("value")//默认值单一为value时，可以省略value=
    public void test2(){}
}


@Target(value = {ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
    //注解的参数:参数类型+参数名（）
    String name() default "";//默认为空
    int age() default 0;
    int id() default -1;//如果默认值为-1，代表不存在，indexof:如果找不到就返回-1
    String[] school() default {};

}
@Target(value = {ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
    String value();//默认值单一为value时，可以省略value=
}

2. 反射机制—Reflection

Reflection（反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部消息，并直接操作任意对象的内部属性及方法。
Class c = Class.forName(“java.lang.String”)
- 正常方式：【引入需要的包类名称】–》【通过new实例化】–》【取得实例化对象】
- 反射方式：【实例化对象】–》【getClass()方法】–》【得到完整的包类名称】
反射相关的主要API：
- java.lang.Class:代表一个类
- java.lang.reflect.Method:代表类的方法
- java.lang.reflect.Field:代表类的成员变量
- java.lang.reflect.Constructor：代表类的构造器
主要功能
- Class.forName(xxx.xx.xx)返回的是一个类
- Class.forName(xxx.xx.xx)的作用是要求JVM查找并加载指定的类
- 也就是说JVM会执行该类的静态代码段

package Reflection;

//什么叫反射
public class test02 {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的Class对象
        Class c1 = Class.forName("Reflection.User");
        Class c2 = Class.forName("Reflection.User");
        Class c3 = Class.forName("Reflection.User");
        Class c4 = Class.forName("Reflection.User");
        System.out.println(c1);
        //一个类在内存中只有一个Clss对象
        //一个类被加载后，类的整个结构都会被封装在Class对象中
        System.out.println(c1.hashCode());
        System.out.println(c2.hashCode());
        System.out.println(c3.hashCode());
        System.out.println(c4.hashCode());
    }
}
//实体类:pojo,entity
class User{
    private String name;
    private int id;
    private int age;

    public User() {
    }

    public User(String name, int id, int age) {
        this.name = name;
        this.id = id;
        this.age = 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 "User{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", age=" + age +
                '}';
    }
}

2.1 获取Class类的实例

package Reflection;

//测试Class类的创建方式有哪些
public class test03 {
    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("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);

        //获得父类类型
        Class c5 = c1.getSuperclass();
        System.out.println(c5);
    }
}

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

结果：

这个人是：学生
668386784
668386784
668386784
int
class Reflection.Person

2.2 所有类型的Class对象

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.getClass().hashCode());
        System.out.println(b.getClass().hashCode());
    }
}

2…3 类加载内存分析

类的加载过程：

类的加载（Load）：类加载器完成将类的class文件读入内存并创建java.lang.Class对象操作。
类的链接（Link）：将类的二进制数据合并进JRE，在合并的过程中可以对类进行校验，检查其是否存在安全问题，是否符合JVM语法规范，接着为类变量（static）分配内存和设置默认初始值，这些内存在方法区中进行分配。最后在虚拟机中将常量名替换为引用地址。
类的初始化（Initialize）： JVM对类进行初始化，过程中执行类构造器的方法，此方法是编译期自动收集类中的变量赋值动作和静态代码合并而成的，且虚拟机会保证类构造器的方法会在多线程中被正确的加锁和同步。且在初始化过程中，如果发现类的父类还没有被初始化，则会优先初始化其父类。

package 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 = 300;
    }
    static int m=100;

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

结果：

A类静态代码块初始化
A类的无参构造初始化
100

在这里插入图片描述

2.4 分析类初始化

类的主动引用（一定会发送类的初始化）
- 当虚拟机启动，先初始化main方法所在的类
- new一个类的对象
- 调用类的静态成员（除了final常量）和静态方法
- 使用java.lang.reflect包的方法对类进行反射调用
- 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类

package Reflection;

//测试类什么时候会初始化
public class test06 {
    static {
        System.out.println("主类被加载");
    }
    public static void main(String[] args) throws ClassNotFoundException {
        //1.主动引用
        Son son = new Son();//由于父类没有初始化，输出顺序【主类->父类->子类son】
        //2.反射也会主动引用
        Class.forName("Reflection.test06");
    }
}
class Father{
    static {
        System.out.println("父类被加载");
    }
}

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

结果：

主类被加载
父类被加载
子类被加载

类的被动引用（不会发生类的初始化）
- 当访问一个静态域时，只有真正声明这个域的类才会被初始化
- 通过数组定义类的引用，不会触发此类的初始化
- 引用常量不会触发此类的初始化

package Reflection;

//测试类什么时候会初始化
public class test06 {
    static {
        System.out.println("主类被加载");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        //不会产生类的引用方法
        System.out.println(Son.b);//1.子类不会被加载
        /*
        主类被加载
		父类被加载
		2
        */
        Son[] array = new Son[5];//2.没有任何类被加载
        /*
        主类被加载
        */
        System.out.println(Son.M);//3.常量不会引起父类和子类的初始化
        /*
        主类被加载
        1
        */
    }

}
class Father{
    static int b=2;
    static {
        System.out.println("父类被加载");
    }
}

class Son extends Father{
    static {
        System.out.println("子类被加载");
    }
}

2.5 类加载器的作用

类加载器的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口
类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象
JVM规范定义了如下类型的类的加载器
- 引导类加载器（Bootstap Classloader）：用C++编写的，是JVM自带的类加载器，负责java平台核心库，用来装载核心类库。该加载器无法直接获取
- 扩展类加载器（Extension Classloader）：负责jre/lib/ext目录下的jar包或指定目录下的jar包装入工作库
- 系统类加载器（S有stem Classloader）：负责java-classpath或java.class.path所指的目录下的类与jar包装入工作，是最常用的加载器

package Reflection;

public class test07 {
    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("Reflection.test07").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"));
    }
}

jdk.internal.loader.ClassLoaders$AppClassLoader@2f0e140b

jdk.internal.loader.ClassLoaders$PlatformClassLoader@7ef20235

null

jdk.internal.loader.ClassLoaders$AppClassLoader@2f0e140b

null

D:\study\out\production\study;D:\study\src\com\lib\commons-io-2.13.0.jar

2.6 获取运行时类的完整结构

通过反射获取运行时类的完整结构：Field、Method、Constructor、Superclass、Interface、Annotation

package 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 c2 = Class.forName("Reflection.User");
        User user = new User();
        Class c1 = user.getClass();
        //获得类的名字
        System.out.println(c1.getName());           //获得包名+类名
        System.out.println(c1.getSimpleName());     //获得类名
        //获得类的属性
        Field[] fields = c1.getFields();        //只能找到public属性
        for (Field field : fields) {
            System.out.println(field);
        }
        Field[] declaredFields = c1.getDeclaredFields();    //可以找到全部的属性
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        System.out.println("=================================");
        //获得指定属性的值
        System.out.println(c1.getDeclaredField("name"));
        //获得类的方法
        Method[] methods = c1.getMethods();//获得本类及其父类的全部public方法
        for (Method method : methods) {
            System.out.println("公开的方法："+method);
        }
        Method[] declaredMethods = c1.getDeclaredMethods();//获得本类的所有方法
        for (Method declaredMethod : declaredMethods) {
            System.out.println("所有的方法："+declaredMethod);
        }
        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();
        for (Constructor constructor : constructors) {
            System.out.println("#public方法#"+constructor);
        }
        Constructor[] declaredConstructors = c1.getDeclaredConstructors();
        for (Constructor declaredConstructor : declaredConstructors) {
            System.out.println("#全部方法#"+declaredConstructor);
        }

        //获得指定的构造器
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        System.out.println("指定的构造器"+declaredConstructor);
    }
}

结果：

Reflection.User
User
private java.lang.String Reflection.User.name
private int Reflection.User.id
private int Reflection.User.age
=================================
private java.lang.String Reflection.User.name
公开的方法：public java.lang.String Reflection.User.getName()
公开的方法：public java.lang.String Reflection.User.toString()
公开的方法：public void Reflection.User.setName(java.lang.String)
公开的方法：public int Reflection.User.getId()
公开的方法：public void Reflection.User.setId(int)
公开的方法：public int Reflection.User.getAge()
公开的方法：public void Reflection.User.setAge(int)
公开的方法：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 final native void java.lang.Object.wait(long) 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 Reflection.User.getName()
所有的方法：public java.lang.String Reflection.User.toString()
所有的方法：public void Reflection.User.setName(java.lang.String)
所有的方法：public int Reflection.User.getId()
所有的方法：public void Reflection.User.setId(int)
所有的方法：public int Reflection.User.getAge()
所有的方法：public void Reflection.User.setAge(int)
===============================================
public java.lang.String Reflection.User.getName()
public void Reflection.User.setName(java.lang.String)
=================================================
#public方法#public Reflection.User()
#public方法#public Reflection.User(java.lang.String,int,int)
#全部方法#public Reflection.User()
#全部方法#public Reflection.User(java.lang.String,int,int)
指定的构造器public Reflection.User(java.lang.String,int,int)

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

3.1 有了Class对象，能做什么

创建类的对象：调用Class对象的newInstance（）方法
- 类必须有一个无参数的构造器
- 类的构造器的访问权限需要足够
思考？难道没有无参构造器就不能创建对象了吗？只要在操作的时候明确的调用类中的构造器，并将参数传递进去之后，才可以实例化操作
步骤如下：
1. 通过Class类的getDeclaredConstructor（Class 。。。 parameterTypes）取得本类的指定形参类型的构造器
2. 向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需要的各个参数
3. 通过Constructor实例化对象
setAccessible详解
- Method和Field、Constructor对象都有setAccessible（）方法
- setAccessible作用是启动和禁用访问安全检查的开关
- 参数值为true则指示反射的对象在使用时应取消java语言的访问检查
- 参数值为false则指示反射的对象应该实施java语言访问检查

package Reflection;

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对象
        Class c1 = Class.forName("Reflection.User");
        //1.构造一个对象
        User user = (User) c1.newInstance();//本质是调用了类的无参构造器
        System.out.println(user);

        //2.通过构造器创建对象
        Constructor declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
        Object shang = declaredConstructor.newInstance("shang", 18, 18);
        System.out.println(shang);

        //3.通过反射调用普通方法
        User user2 = (User) c1.newInstance();//本质是调用了类的无参构造器
        //通过反射获取方法
        Method setName = c1.getDeclaredMethod("setName", String.class);
        //invoke:激活的意思---（对象，“方法的值”）
        setName.invoke(user2,"zhi");
        System.out.println(user2.getName());

        //4.通过反射操作属性
        User user3 = (User) c1.newInstance();
        Field name = c1.getDeclaredField("name");
        //不能直接操作私有属性，我们需要关闭程序的安全检测，属性或者的方法的setAccessible设置为ture
        name.setAccessible(true);
        name.set(user3,"ru");
        System.out.println(user3.getName());
    }
}

3.2 性能对比

package Reflection;

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

//分析性能问题
public class text10 {
    //普通方法调用
    public static void t1(){
        User user = new User();
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            user.getName();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("普通方法执行10亿次："+(endTime-startTime)+"ms");
    }
    //反射方法调用
    public static void t2() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user = new User();
        Class c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName", null);

        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            getName.invoke(user,null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射方法执行10亿次："+(endTime-startTime)+"ms");
    }

    //反射方法调用,关闭检测
    public static void t3() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        User user = new User();
        Class c1 = user.getClass();
        Method getName = c1.getDeclaredMethod("getName", null);

        getName.setAccessible(true);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            getName.invoke(user,null);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射方法关闭检测执行10亿次："+(endTime-startTime)+"ms");
    }

    public static void main(String[] args) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException {
        t1();
        t2();
        t3();
    }
}

普通方法执行10亿次：0ms
反射方法执行10亿次：516ms
反射方法关闭检测执行10亿次：313ms

4 反射操作泛型

java采用泛型擦除的机制来引入泛型，java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换问题。但是，一旦编译完成，所有和泛型有关的类型全部擦除
为了通过反射操作这些类型，java新增了ParameterizedType、GenericArrayType、TypeVariable和WidcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型
ParameterizedType：表示一种参数化类型
GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型
TypeVariable：是各种类型变量的公共父接口
WidcardType：代表一种通配符类型表达式

package 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 text11 {

    public void t1(Map<String,User> map, List<User> list){
        System.out.println("t1");
    }
    public Map<String,User> t2(){
        System.out.println("t2");
        return null;
    }

    public static void main(String[] args) throws NoSuchMethodException {
        Method method = text11.class.getMethod("t1", Map.class, List.class);
        //getGenericParameterTypes()获得泛型的参数类型【Map、List】
        Type[] genericParameterTypes = method.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println("#"+genericParameterType);//打印泛型信息
            //ParameterizedType我们得到的参数类型是否是结构化【参数化】类型
            if (genericParameterType instanceof ParameterizedType){
                //如果是参数化类型，我们就强制转换--并且获得类型的参数信息getActualTypeArguments()
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);//打印泛型的参数信息
                }
            }
        }
        Method method2 = text11.class.getMethod("t2",null);
        Type genericReturnType = method2.getGenericReturnType();
        //如果是参数化类型，我们就强制转换--并且获得类型的参数信息getActualTypeArguments()
        if (genericReturnType instanceof ParameterizedType) {
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println("!"+actualTypeArgument);//打印泛型的参数信息
            }
        }
    }
}

#java.util.Map<java.lang.String, Reflection.User>
class java.lang.String
class Reflection.User
#java.util.List<Reflection.User>
class Reflection.User
!class java.lang.String
!class Reflection.User

5. 反射操作注解

getAnnotations
getAnnotation

L：ORM

了解ORM：Object relationship Mapping–> 对象关系映射

在这里插入图片描述

package Reflection;

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

//练习反射操作注解
public class text12 {
    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的值,强转
        Tableshang annotation = (Tableshang) c1.getAnnotation(Tableshang.class);
        String value = annotation.value();
        System.out.println("获得注解的value的值:"+value);

        //获得类指定的注解
        Field name = c1.getDeclaredField("name");
        Fieldshang annotation1 = name.getAnnotation(Fieldshang.class);
        System.out.println("获得name类指定的注解:"+annotation1.columName());
        System.out.println("获得name类指定的注解:"+annotation1.lenght());
        System.out.println("获得name类指定的注解:"+annotation1.type());
    }
}
@Tableshang("db_student")
class Student2{
    @Fieldshang(columName = "db_id",type = "int",lenght = 10)
    private int id;
    @Fieldshang(columName = "db_age",type = "int",lenght = 10)
    private int age;
    @Fieldshang(columName = "db_name",type = "varchar",lenght = 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 Tableshang{
    String value();
}

//属性的注解（3个）
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Fieldshang{
    String columName();
    String type();
    int lenght();
}