Java注解与反射 入门篇
课程主线：注解->自定义注解->反射->Class类->类加载机制->反射的实际应用
参考文献：https://www.bilibili.com/video/BV1p4411P7V3，Typora0.9.98
源码地址：https://gitee.com/tqh_520/demo/tree/master/demo1_SE1/src/main/java/study/annotationReflect/kuangshen
1 注解（java.annotation）
1.1 注解简介
- annotation是JDK5.0开始引入的技术；
- annotation作用：它不是程序，但可以被其他程序(如编译器)读取；
- 注解格式：@注解名，还可以添加一些参数值，如：@SuppressWarnings(value="unchecked")；
- 使用范围：package，class，method，field等，通过反射机制来实现对这些元数据的访问；
1.2 内置注解
- @Override定义在Java.lang.Override中，只适用于方法，表示声明重写超类中的方法；
- @Deprecated定义在Java.lang.Deprecated中，用于方法/属性/类，表示不鼓励使用这样的元素
- @SuppressWarnings定义在Java.lang.SuppressWarnings中，用来抑制编译时的警告信息
1.3 元注解
-
元注解的作用就是负责注解其他注解，Java定义了4个meta-annotation类型
-
这些类型和他们所支持的类在java.lang.annotation包中，
@Target：描述注解使用范围（package，class，method，field），如：@Target(value={ElementType.METHOD, ElementType.TYPE})
@Retention：表示在什么级别保存该注解信息，用于描述注解的生命周期：source < class < runtime
@Document：说明该注解将被包含在javadoc中
@Inherited：说明子类可以继承父类中的该注解
1.4 自定义注解
-
@interface用来声明一个注解，自动继承了java.lang.annotation.Annotation接口
格式： @interface 注解名 { 定义的内容 }
-
注解里面的方法实际上是声明的配置参数，方法名称即为参数名称，参数类型只能是基本类型(Class,String,enum)，
定义格式：参数类型 + 参数名();
-如：String name(); -
带默认值定义格式： 参数类型 + 参数名() default 默认值;
-如：int age() default -1; String[] books() default {"java入门","oracle数据库"}; -
只有一个值情况下，建议用value命名，使用时候可以不显示的写参数名
-如： String value(); ->使用时@XXX( 值 ) -
注解可以显示赋值，参数赋值顺序不影响，没有默认值的必须赋值
1.4.1 自定义注解案例
public class MyAnnotation1 {
//注解可以显示赋值，参数顺序不影响，没有默认值的必须赋值
@Annotation1( age=25, name="name1" )
public void test() {
}
@Annotation2( "name2" )
public void test2() {
}
}
@Target(value = {ElementType.METHOD, ElementType.TYPE} )
@Retention(value = RetentionPolicy.RUNTIME )
@Documented
@Inherited
@interface Annotation1 {
String name(); //注解的参数： 参数类型 + 参数名();
int age() default -1; //带默认值的注解参数：参数类型 + 参数名() + default 初始值;
String[] books() default {"java入门","oracle数据库"};
}
@Target(value = {ElementType.METHOD, ElementType.TYPE} )
@Retention(value = RetentionPolicy.RUNTIME )
@Documented
@Inherited
@interface Annotation2 {
String value(); //只有一个值情况下，建议用value命名，使用时候可以不显示的写参数名
}
2 反射(java.Reflection)
2.1 反射机制概述
-
动态语言：运行时可以改变其结构的语言，例如新函数/对象/代码块可以被引进或改变删除，即运行时可以改变自身结构：
动态语言： Object-C，C#，JavaScript，PHP，Python ，
例如JavaScript： var a = "alert(9+6);"; eval(a); -
静态语言：运行时结构不可改变。如：java，C，C++；
-
Java可以算是”准动态语言“，利用反射机制可以获得类似动态语言的特性，使其动态创建对象和编译更加灵活，也增加了不安全性和拉低性能
-
反射机制是"准动态"的关键，它允许程序在运行时借助RelectionAPI取得类的任何内部信息并能直接操作其对象的内部属性及方法
-
如：Class c = Class.forName("java.lang.String");
-
加载完类之后，堆内存的方法区就产生一个Class类型的对象(一个类有且只有一个Class对象)，该对象包含了完整的类结构信息，该对象像一面镜子透过它可以看到类结构，形象称之为反射；
-
正常方式：引入需要的包类名称 -> 通过new实例化 ->取得实例化对象；
-
反射方式：实例化对象 -> getClass()方法 -> 取得完整的包类名称;
-
2.2 理解Class类并获取Class实例
-
Class类，Object中定义了如下方法：public final native Class<?> getClass()
- Class本身也是一个类，Class对象只能由系统创建，一个加载的类在JVM中有且只有一个Class实例，通过Class可以完整得到类中所有被加载的结构
- Class是Reflection的根源
-
Class类常用方法
节选部分常用方法名 说明 static Class forName(String name) 返回指定类名name对应的Class对象 Object newInstance() 调用缺省构造函数，返回Class对象的一个实例 String getName() 返回此Class对象所表示的实体（类、接口、数组类或者void）的名称 Class getSuperClass 返回当前Class对象的父类Class对象 Class[] getinterfaces() 获取当前Class对象的接口 ClassLoader getClassLoader() 返回该类的加载器 Constructor[] getConstructors() 返回一个包含某些Constructor对象的数组 Method getMothed(String name,Class… T) 返回一个Method对象，此对象形参类型为param Type Fied[] getDeclaredFields() 返回Field对象的一个数组 -
获取Class类的实例
- 通过类的class属性获取，该法最安全性能最高，例：Class classa = Person.class;
- 调用已知实例的getClass()方法获取，例：Class classa = persion.getClass();
- 通过Class类的静态方法forName()获取，可能会抛异常ClassNotFoundException，例：Class classa = Class.forName(kuangshen.Person);
- 内置基本数据类型可以直接用类名.Type，例如：Class classa = Integer.TYPE;
- 利用ClassLoader
-
哪些类型有Class对象
类型 Class对象 class：外部类，成员(成员内部类,静态内部类)，局部内部类，匿名内部类 class java.lang.Object class java.lang.Object interface：接口 interface java.lang.Comparable []：数组 class [Ljava.lang.String; enum：枚举 class java.lang.annotation.ElementType annotation：注解@interface interface java.lang.Override primitive type：基本数据类型 class java.lang.Integer void void Class class java.lang.Class
2.2.1 案例：获取class对象方式
/**
* 演示 Class 类的创建方式有哪些
* 准备工作：新建Person类(private String name;)，有参/无参构造，重写toString
*/
public class Reflection2 {
public static void main(String[] args) throws ClassNotFoundException {
Person person1 = new Person("张三");
System.out.println("这个人是: "+person1);
//方式一: 通过具体类的class属性获取
Class c1 = Person.class;
System.out.println("方式一通过具体类的class属性获取："+ c1.hashCode());
//方式二: 通过实例的getClass()获取
Class c2 = person1.getClass();
System.out.println("方式二通过实例的getClass()获取："+ c2.hashCode());
//方式三: 通过Class的静态方法forName()获取
Class c3 = Class.forName("study.annotationReflect.kuangshen.Person");
System.out.println("方式三通过Class的静态方法forName()获取："+ c3.hashCode());
//方式四: 基本类型的包装类有"TYPE"属性
Class c4 = Integer.TYPE;
System.out.println("方式四基本类型.TYPE获取："+ c4);
}
}
//输出结果结论：各方式创建的class对象hashcode一致(同一个对象)，说明有且只有一个Class对象
2.2.2 案例：各类型的class对象
/**
* 所有类型的Class对象
* idea中alt可以竖着复制
*/
public class Reflection3 {
public static void main(String[] args) {
Class c1 = Object.class; //类 class java.lang.Object
Class c2 = Comparable.class; //接口 interface java.lang.Comparable
Class c3 = String[].class; //一维数组 class [Ljava.lang.String;
Class c4 = String[][].class; //二维数组 class [[Ljava.lang.String;
Class c5 = Override.class; //注解 interface java.lang.Override
Class c6 = ElementType.class; //枚举 class java.lang.annotation.ElementType
Class c7 = Integer.class; //基本类型 class java.lang.Integer
Class c8 = void.class; //void void
Class c9 = Class.class; //Class class java.lang.Class
System.out.println( (new int[10]).getClass().hashCode() +" "+ (new int[100]).getClass().hashCode() );
//元素类型与维度一样也是同一个class
}
}
2.3 类的加载
2.3.1 java内存简易分析
-
堆：存放new的对象和数组，可以被所有的线程共享
-
栈：存放基本变量类型(会包含这个基本类型的具体数值)
? 引用对象的变量(存放的是这个引用在堆内存的具体地址)
-
方法区：可以被所有线程共享
? 包含了所有的class和static变量
2.3.2 类的加载与ClassLoader的理解
- 类的加载(Load)：类加载器将类的class字节码文件读入内存，并将静态数据转换成方法区的运行时数据结构，然后生成java.lang.Class对象
- 类的链接(Link)：将类的二进制数据合并到JRE中
验证：确保类信息符合JVM规范，没有安全方面问题
准备：正式为类变量(static)分配内存并设置类变量默认初始化值的阶段，这些内存都在方法区中分配
解析：虚拟机常量池内的符号引用(常量名)替换为直接引用(地址)的过程 - 类的初始化(Initialize)：JVM负责对类进行初始化
- 执行类构造器< clinit>()方法的过程。类构造器< clinit>()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的而非构造该类对象的）；
- 当初始化一个类的时候，若其父类还未初始化，则先触发父类的初始化；
- 虚拟机会保证一个类的< clinit>()方法在多线程环境中被正确加锁和同步；
2.3.3 案例：类加载
/**
* 测试类的加载顺序
*/
public class Reflection4 {
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
//分析：
//1.加载到内存时会产生一个类对应class对象；
//2.链接，m=0;
//3.() {System.out.println("A类的静态代码初始化"); m=300; m=100;}
2.3.4 分析类初始化
什么时候会发生类初始化？
-
类的主动引用（一定会发生类的初始化）
- 虚拟机启用，先初始化main方法所在的类
- new一个类的对象
- 调用类的静态成员（除了final常量）和静态方法
- 使用java.lang.reflect包的方法对类进行反射调用
- 当初始化一个类时若父类没有被初始化则会先初始化它的父类
-
类的被动引用（一定不会发生类的初始化）
- 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：通过子类引用父类的静态变量不会导致子类初始化
-
通过数组定义类引用，不会触发此类的初始化
- 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）
2.3.5 案例：类初始化是否引用测试
/**
* 测试类的初始化顺序
*/
public class Reflection5 {
static {
System.out.println( "main类被加载" );
}
public static void main(String[] args) throws ClassNotFoundException {
//new会发生主动加载，且会先加载父类
Son son = new Son(); //out: main类被加载 -> 父类被加载 -> 子类被加载
//反射也会产生主动加载
Class.forName("study.annotationReflect.kuangshen.Son"); //out: main类被加载 -> 父类被加载 -> 子类被加载
//通过子类引用父类的静态变量不会导致子类初始化
System.out.println( Son.b ); //out: main类被加载 -> 父类被加载 -> 2
//数组定义类引用不会触发此类的初始化
Son[] sons = new Son[10]; //out: main类被加载
//引用常量不会触发此类的初始化
System.out.println( Son.M ); //out: 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;
}
2.4 类加载器的作用
-
类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中的类数据的访问入口。JVM规范定义了如下类型的类的加载器：
-
引导类加载器(Bootstap Classloader)：
c++编写的，是JVM自带的类加载器，负责java平台核心库java.*（rt.jar），用来装载核心类库，该加载器无法直接获取；
c++编写，加载java核心库 java.*,构造ExtClassLoader和AppClassLoader。由于引导类加载器涉及到虚拟机本地实现细节，开发者无法直接获取到启动类加载器的引用，所以不允许直接通过引用进行操作；
-
扩展类加载器(Extension Classloader)：
负责jre/lib/ext目录下的jar包或-D java.ext.dirs指定目录下的jar包装入工作库；
-
系统类加载器(System/App Classloader)：
负责java -classpath或-D java.class.path所指的目录下的类与jar包装入工作，是最常用的加载器；
-
用户自定义类加载器(CustomClassLoader):
由Java实现。我们可以自定义类加载器，并可以加载指定路径下的class文件；
-
-
Bootstap Classloader <=> Extension Classloader <=> System Classloader <=> 自定义类加载器 （自左向右尝试加载类，自右向左检查类是否已装载）
-
类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间，不过JVM垃圾回收机制可以收回这些Class对象。
2.4.1 案例：类加载器
/**
* 演示类加载器
*/
public class ClassLoader6 {
public static void main(String[] args) throws ClassNotFoundException {
//获取系统类的加载器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
System.out.println("获取系统类的加载器："+ systemClassLoader); //out: sun.misc.Launcher$AppClassLoader@18b4aac2
//获取系统类加载器的父类加载器，即：扩展类加载器
ClassLoader parent = systemClassLoader.getParent();
System.out.println("扩展类加载器："+ parent); //out: sun.misc.Launcher$ExtClassLoader@5b2133b1
//获取扩展类加载器的父类加载器，即：根加载器
ClassLoader parent1 = parent.getParent();
System.out.println("获取扩展类加载器的父类加载器 -->根加载器："+ parent1); //out-> null
//测试当前类时那个加载器加载的
ClassLoader classLoader = Class.forName("study.annotationReflect.kuangshen.Reflection1").getClassLoader();
System.out.println("获取当前类时那个加载器加载的："+ classLoader); //out: sun.misc.Launcher$AppClassLoader@18b4aac2
//JDK内置类是哪个加载器加载
classLoader = Class.forName("java.lang.Object").getClassLoader();
System.out.println("获取JDK内置类是哪个加载器加载的："+ classLoader); //out: null
//系统类加载器可以加载的路径
System.out.println("可加载的路径："+ System.getProperty("java.class.path")); //out->jre\lib\..;now\class\;maven..
}
}
2.4.2 双亲委派机制(重点)
-
双亲委派机制：当类加载器需要加载某一个.class字节码文件时，则首先会把这个任务委托给他的上级类加载器，递归这个操作，如果上级没有加载该.class文件，自己才会去加载这个.class。
-
双亲委派的作用：
①防止加载同一个.class。通过委托去询问上级是否已经加载过该.class，如果加载过了，则不需要重新加载。保证了数据安全。
②保证核心.class不被篡改。通过委托的方式，保证核心.class不被篡改，即使被篡改也不会被加载，即使被加载也不会是同一个class对象，因为不同的加载器加载同一个.class也不是同一个Class对象。这样则保证了Class的执行安全。
2.5 反射运用
2.5.1 获取类的运行时结构
/**
* 测试获取类的运行时结构
* 准备工作：User类(private String name;private int id;public String section;) extends Man(private sex)，有参/无参构造，重写String
* 带Declared的表示获取包括非public的全部属性/方法
*/
public class Reflection8 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, NoSuchFieldException {
Class c1 = Class.forName("study.annotationReflect.kuangshen.User");
//获取类名
System.out.println("getName()获取完整类名："+ c1.getName());
System.out.println("getSimpleName()获取类名："+ c1.getSimpleName());
//获取类的属性
Field[] fields = c1.getFields(); //getFields只能获取公有属性
System.out.println("getFields只能获取公有属性：");
for(Field field : fields)
System.out.println(field);
fields = c1.getDeclaredFields(); //getDeclaredFields获取全部属性
System.out.println("getDeclaredFields获取所有属性");
for(Field field : fields)
System.out.println(field );
System.out.println("getField(xx)获取指定属性，若该属性私有则抛异常："+ c1.getField("section"));
System.out.println("getDeclaredField(xx)获取指定属性："+ c1.getDeclaredField("name"));
//类似的还有获取方法，带Declared的表示获取全部
Method[] methods = c1.getMethods(); //获取本类及其父类的全部public方法
System.out.println("getMethods()获取本类及其父类的全部public方法");
for(Method method : methods)
System.out.println(method);
methods = c1.getDeclaredMethods(); //获取本类所有方法
System.out.println("getDeclaredMethods()获取本类所有方法");
for(Method method : methods)
System.out.println(method);
Method method = c1.getMethod("getName");
Method method1 = c1.getMethod("setName", String.class);
System.out.println(method +" "+ method1);
//获得构造器
Constructor[] constructors = c1.getConstructors(); //getConstructors()获取本类public构造
System.out.println("getConstructors()获取本类public构造");
for(Constructor constructor : constructors)
System.out.println(constructor);
methods = c1.getDeclaredMethods(); //获取本类所有构造
System.out.println("getDeclaredMethods()获取本类所有构造");
for(Constructor constructor : constructors)
System.out.println(constructor);
Constructor constructor = c1.getConstructor(String.class, int.class, String.class);
System.out.println("getConstructor(..)获取指定构造器："+ constructor);
}
}
2.5.2 动态创建对象执行方法
- 创建类的对象：
- 调用Class对象的newInstance()方法，类必须有一个无参构造器，类的构造器访问权限需足够
- 调用Class对象的有参构造器：(1)通过Class类的getDeclaredConstructor(Class ... paramterTypes)取得本类的指定形参构造器；(2)向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数；(3)通过Constructor实例化对象；
- 调用指定方法/属性：
- getMethod(String methodName, Class ..parameterTypes)方法取得该对象，并设置操作时所需参数类型；
- 之后使用Object invoke(Object targetObj, Object[] args)进行调用，并向方法中传递要设置targetObj对象的参数信息
- 激活方法invoke，格式：Object invoke(Object obj, Object[] args)
- Object对应原方法的返回值，若原方法无返回则返回null；
- 若原方法为静态方法，形参Object obj可为null；
- 若原方法形参列表为空，则Object[] args为null；
- 若原方法声明为private，则需在调用之前显示关闭权限检查setAccessible(true)；
- 关闭权限检查，格式：XX.setAccessible(true); //true表示关闭权限检测，false为开启
- Method，Field，Constructor对象都有setAccessible()方法；
- 参数值为true，则指示反射的对象在使用时取消java语言访问检查。此可提高反射效率
/**
* 测试动态创建对象执行方法
* 新建User类(private String name;private int id;public String section;)，有参/无参构造，重写toString
* invoke激活：invoke(对象, []方法的值)
*/
public class Relection9 {
public static void main(String[] args) throws IllegalAccessException, NoSuchFieldException, InvocationTargetException, NoSuchMethodException, InstantiationException {
User user = new User(20014, "TQH", 27);
Class c1 = user.getClass();
//通过newInstance构造一个对象
User user1 = (User) c1.newInstance(); //本质是调用无参构造，若无参不存在则抛异常
System.out.println("通过无参构造器创建对象："+ user1);
//通过有参构造器创建一个对象
Constructor constructor = c1.getDeclaredConstructor(int.class, String.class, int.class);
User user2 = (User) constructor.newInstance(20014, "TQH", 27);
System.out.println("通过有参构造器创建对象："+ user2);
//通过反射调用普通方法
User user3 = (User) c1.newInstance();
Method setName = c1.getDeclaredMethod("setName", String.class);
setName.invoke(user3, "tqh3");
Field id = c1.getDeclaredField("id");
id.setAccessible(true); //true:关闭权限检查，否则不能直接操作private属性或方法
id.set(user3, 123);
System.out.println("通过反射操作普通方法/属性："+ user3);
}
}
//通过无参构造器创建对象：User{name='null', id=0, section=null}
//通过有参构造器创建对象：User{name='tqh2', id=222, section=222}
//通过反射操作方法/属性：User{name='tqh3', id=123, section=null}
2.5.3 性能对比
/**
* 测试各种方式调用下的性能情况
* 消耗时间对比：普通调用 <<< 关闭权限检查反射调用 < 反射方式调用
*/
public class Relection10 {
public static void main(String[] args) throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
int count = 2000000000;
User user = new User();
//普通方式调用性能
long startTime = System.currentTimeMillis();
for(int i=0; i2.6 反射操作泛型
-
java采用泛型擦除的机制引入泛型，java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换问题，但是一旦编译完成则所有和泛型有关的类型全部擦除。
-
为了通过反射操作泛型，java新增了ParameterizedType，GenericArrayType，TypeVariable，WildcardType 来代表不能被归一到Class类中的类型但又和原始类型齐名的类型
-
ParameterizedType：表示一种参数化类型，比如Collection< String>
-
GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型
-
TypeVariable：是各种类型变量的公共父接口
-
WildcardType：代表一种通配符类型的表达式
-
/**
* 测试反射操作泛型
*/
public class Relection11 {
public static void main(String[] args) throws NoSuchMethodException {
Method method = Relection11.class.getMethod("test01", Map.class, List.class);
Type[] genericParameterTypes = method.getGenericParameterTypes();
for (Type generiParameterType : genericParameterTypes) {
System.out.println(generiParameterType);
if (generiParameterType instanceof ParameterizedType) {
Type[] actualTypeArguments = ((ParameterizedType) generiParameterType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments)
System.out.println(actualTypeArgument);
}
}
method = Relection11.class.getMethod("test02", null);
Type genericReturnType = method.getGenericReturnType();
if (genericReturnType instanceof ParameterizedType) {
Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
for (Type actualTypeArgument : actualTypeArguments)
System.out.println(actualTypeArgument);
}
}
public void test01(Map map, List list) {
System.out.println("test01");
}
public Map test02() {
System.out.println("test02");
return null;
}
}
//java.util.Map
//class java.lang.String
//class study.annotationReflect.kuangshen.User
//java.util.List
//class study.annotationReflect.kuangshen.User
//class java.lang.String
//class study.annotationReflect.kuangshen.User
2.7 获取注解信息
/** 测试反射获取注解信息
*/
public class Test12 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
Class c1 = Class.forName("se.reflection.kuangshen.Student");
//通过反射获得注解
Annotation[] annotations = c1.getDeclaredAnnotations();
for(Annotation annotation : annotations)
System.out.println(annotation); //out-> @se.reflection.kuangshen.tableAnnotation(value=t_student)
//获得注解的value的值
TableAnnotation tableAnnotation = (TableAnnotation) c1.getAnnotation(TableAnnotation.class);
String value = tableAnnotation.value();
System.out.println(value); //out-> t_student
//获得类指定注解
Field field = c1.getDeclaredField("id");
FieldAnnotation fieldAnnotation = field.getAnnotation(FieldAnnotation.class);
System.out.println(fieldAnnotation.columName() +"，"+ fieldAnnotation.type() +"，"+ fieldAnnotation.length());
//out->c_id，int，10
}
}
@Target(value = {ElementType.TYPE})
@Retention(value = RetentionPolicy.RUNTIME )
@interface TableAnnotation {
String value();
}
@Target(value = {ElementType.FIELD})
@Retention(value = RetentionPolicy.RUNTIME )
@interface FieldAnnotation {
String columName();
String type();
int length();
}
@TableAnnotation(value="t_student")
@Data
class Student {
@FieldAnnotation(columName = "c_id", type = "int", length = 10)
private int id;
@FieldAnnotation(columName = "c_name", type = "varchar", length = 10)
private String name;
@FieldAnnotation(columName = "c_age", type = "varchar", length = 10)
private String age;
}