【知了堂学习笔记】JAVA反射及注解--轻松学会反射

java的反射

反射是java的重要机制，java语言的动态性与它有着莫大的关系。
通过反射可以获得获得类、属性、构造方法、方法、注解的信息
也可以利用反射机制动态操作这些内容，可以调用构造函数、操作属性、调用方法

用反射操作类中内容的步骤：
1.获取Class对象
2.得到对应实例
3.操作实例

注：Class：该对象并不是class，它是一个类的原模板，储存了类的所有信息，一维数组和二维数组不是同一个类，对象创建自动加载Class类。
同一类对象创建的模板是一致的，都是它所属类的模板。

获取Class的方法有（返回对象是Class）：
1.类名.class
2.对象名.getclass()
3.Class.forName(path) --> path是java类所属路径
举个例子：

/**
* 演示说明Class
* @author Administrator
*
*/
public class Test {
public static void main(String[] args) throws ClassNotFoundException {
Class cls=Class.forName("com.zlt.test1.Test");//用Class.forName获取Class
System.out.println("打印Class的名字: "+cls.getSimpleName());
String a = "aaa";
String b = "bbb";
System.out.println("同一类创建对象的Class: " + a.getClass()+" "+b.getClass());
String aa[]= {};
String bb[][]= {};
System.out.println("一维数组和二维的Class: "+ aa.getClass() +"   "+ bb.getClass());
System.out.println("String的Class"+String.class);
}
}

运行结果：

用反射对class的操作：

1.获得类的相关信息
注：操作类的信息室，用带有Declared的方法能访问私有属性，方法，否则不能访问私有方法
类返回Class
属性返回Field
方法返回Method
构造函数返回Constructor
注解返回Annotation
操作方法基本一致：

package com.zlt.test1;

import java.lang.reflect.*;

/**
* 用反射操作类
* @author Administrator
*
*/
public class OpterClass {
public static void main(String[] args) throws Exception {
Class cls=Class.forName("com.zlt.test1.AAA"); //1.得到类
//获得类信息
String name=cls.getName();//获取包名+类名
String fullName=cls.getSimpleName();//获取类名

//获得属性,返回Field类型
Field f=cls.getDeclaredField("str1");//获取指定属性,能访问私有的
System.out.println(f.getName());

Field fid[]=cls.getFields();//获取属性，私有的访问不到
for(Field ff:fid) {
System.out.println(ff.getName());
}

//获取方法
Method method=cls.getDeclaredMethod("Print", String.class);//  方法名,参数类型列表 --> 没有参数就无须添加
Method []methods=cls.getDeclaredMethods();//获取全部方法，任何访问级别
System.out.println(method.getName());

//获取构造函数
Constructor cons=cls.getConstructor(); //不需要跟方法名，直接给参数即可，也是参数的模板Class类
System.out.println(cons.getName());

}
}

class AAA{
public String str1="aaa";
private String str2="bbb";
public AAA() {
System.out.println("无参构造");
}
public AAA(String aaa) {
this.str1=aaa;
}
public void Print(String a) {
System.out.println("print");
}
}

注：（1）在获取属性，方法，构造函数时，如果要访问私有的，需使用带Declared的get方法
（2）在获取指定方法时，要传参，分别是方法名和参数的模板类（类名.calss）,如果没有参数则只需要方法名
（3）获取构造方法时，直接以模板类（类名.calss）作为参数即可
（4）如果直接获取所有属性、方法、构造函数，则返回对应类型的数组

2.操作属性，方法，构造函数

package com.zlt.test1;

import java.lang.reflect.*;

public class OpterClass2 {
public static void main(String[] args) throws Exception {
Class cls=BBB.class;//获取Class对象
Constructor<BBB> cons1=cls.getConstructor();//获取无参构造
Constructor<BBB> cons2=cls.getConstructor(String.class);//获取有参构造

//调用构造函数
BBB b1=cons1.newInstance();
BBB b2=cons2.newInstance("新新参数");

//获取方法
Method m1=cls.getDeclaredMethod("Print");//无参方法
Method m2=cls.getDeclaredMethod("Print",String.class);//有参方法

//使用方法
m1.invoke(b1);//执行b1对象的无参方法
m2.invoke(b1,"aaa");//执行b1对象的有参方法
m1.invoke(b2);//执行b2对象的无参方法
m2.invoke(b2,"aaa");//执行b2对象的有参方法

//获取属性
Field f=cls.getDeclaredField("name");

//操作属性
f.setAccessible(true);//操作私有属性要关闭安全检查
f.set(b1, "new b1");//设置b1的name属性
f.set(b2, "new b2");//设置b2的name属性
m1.invoke(b1);
m1.invoke(b2);
}
}

class BBB{
private String name="aaa";
public BBB() {
System.out.println("无参构造");
}
public BBB(String name) {
this.name=name;
System.out.println("有参构造");
}
public void Print() {
System.out.println(this.name);
System.out.println("调用无参方法");
}
public void Print(String a) {
System.out.println("调用有参构造方法");
}
}

结果如下：

注：（1）操作属性时，如果要访问私有属性，要关闭安全检查 -------- setAccessible(true)
（2）使用类的方法一般用构造函数newInstances创建对象操作，成员方法的使用都与对象离不开关系
（3）注意获得方法和使用方法传递的参数的区别

3.操作注解
步骤：
（1）先获得Class对象
（2）获得对应类、属性、方法…的注解，返回对应注解的类型
（3）获取注解的值

案例：把类映射成sql语句

先定义两个注解

package com.zlt.fluance;
/**
* 表名信息
*/
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Table {
String data();//属于哪个数据库
String name();//表名
}

package com.zlt.fluance;

/**
* 表的每一列
*/
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
String name();//列名
String type();//数据类型
int length() default 1;//长度
String[] key() default "";//约束
}

用反射操作注解

package com.zlt.fluance;

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

public class CreateTable {

public String Create(Class cls) {
String sql="";//sql语句
Table table=(Table)cls.getAnnotation(Table.class);//获得类的注解
String tableOfData=table.data();//表所在的数据库
String tableName=table.name();//表名

if(tableOfData!=null) sql+="use "+tableOfData+"\r";
sql+="create table "+tableName +" (\n\t";

Field[] f=cls.getDeclaredFields();
for(int i=0;i<f.length;i++) {//遍历属性
Field field=f[i];
Column cloumn=field.getAnnotation(Column.class);//获得属性的注解
String keys="";

for(int k=0;k<cloumn.key().length;k++) {//添加约束
keys+=" "+cloumn.key()[k];
}
String row="";//属性
if(i==(f.length-1))
row=cloumn.name()+" "+cloumn.type()+"("+cloumn.length()+")"+keys+"\r";
else
row=cloumn.name()+" "+cloumn.type()+"("+cloumn.length()+")"+keys+",\r\t";
sql+=row;
}
sql+=");";
return sql;
}
}

函数调用

package com.zlt.fluance;
/**
* 调用封装的函数
* 把类映射出对应的sql语句
* @author Administrator
*
*/
public class Test {
public static void main(String[] args) {
CreateTable ct=new CreateTable();
String sql=ct.Create(Student.class);
System.out.println(sql);
}
}

结果：

注：注解的使用遵循开头的三步走战略

总结：（1）反射操作的核心是Class对象，反射就是不断操作这个对象，再通过它的API来操作信息。
（2）反射会降低程序运行效率

（3）反射能大大提高程序开发效率，在企业常被使用，希望大家能掌握。