反射
java的动态机制，用于在运行期间检查对象的类型，检查对象的类结构（属性，方法等），还可以动态加载类，动态创建对象，动态访问属性和方法等。
反射是Java 的API.
public void print(Object obj){
//动态反射API，动态检查obj引用的对象类型
Class cls=obj.getClass();
System.out.println(obj);
}
经典面试题目：Eclipse中快捷菜单用了什么技术实现的？
答案：反射技术，反射API
解耦
解除耦合性：降低/解除 两端代码（两个组件）之间的耦合关系
利用反射API，可以实现一个组件与未来的一个组件的松散耦合.甚至可以不在不知道
类名不知道方法名的情况下实现调用关系
反射的功能
1.动态加载类
2.动态创建对象
3.动态调用属性和方法
public class ReflectDemo01 {
public static void main(String[] args) {
print(1);
print("1");
print('1');
}
public static void print(Object obj){
//动态检查obj对象的类型
//getClass方法在Object类上定义，被所有对象继承，全部对象都有的方法
Class cls=obj.getClass();
/*
* Class提供了更加详尽的类型详细信息
* 检查方法：检查属性，检查方法，检查构造器.....
* 动态检查Integer等类型的属性
*/
//Declared:声明的 Field:字段，属性
System.out.println("属性:------------------------");
Field[] fields=cls.getDeclaredFields();
for(Field field:fields){
System.out.println(field);
}
System.out.println("方法:------------------------");
//获取当前类型上声明的所有方法信息
Method[] methods=cls.getDeclaredMethods();
for(Method method:methods){
System.out.println(method);
}
System.out.println(cls);
System.out.println(obj);
}
}
利用反射API动态加载类到方法区：
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
Scanner in=new Scanner(System.in);
System.out.println("输入类名:");
String className=in.nextLine();
/*
* 动态加载类到方法区，如果类名错误则抛出“类没有找到的运行异常”
*/
Class cls=Class.forName(className);
System.out.println(cls);
//进一步检查类的详细信息....
Field[] file=cls.getDeclaredFields();
for(Field f:file){
System.out.println(f);
}
System.out.println("-----------------------");
Method[] method=cls.getMethods();
for(Method m:method){
System.out.println(m);
}
/**
* 利用反射API动态创建对象
*/
Object obj=cls.newInstance();
System.out.println(obj);
}
}
执行一个类的全部以test为开头的方法，这些方法都是非静态方法，方法没有返回值，没有参数
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
//动态加载类
Scanner in=new Scanner(System.in);
System.out.println("输入类名：");
String className=in.nextLine();
Class cls=Class.forName(className);
//动态创建对象
Object obj=cls.newInstance();
//动态检查类中的全部方法信息
Method [] methods=cls.getDeclaredMethods();
for(Method m:methods){
//System.out.println(m);
/*
* method 代表一个方法的相关信息
* method.getName() 返回方法名
*/
String name=m.getName();
//System.out.println(name);
if(name.startsWith("test")){
System.out.println("test开头:"+m);
/*
* Access 访问
* Accessble可访问
* 可以打破封装，访问不可见的方法
*/
m.setAccessible(true);
/*
* method.invoke() 方法用于在对象上调用(invoke)当前
* method对应的方法，必须传递包含方法的对象作为参数。
*/
Object val=m.invoke(obj,1);
System.out.println(val);
}
}
}
利用反射动态调用方法：
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
Scanner in=new Scanner(System.in);
System.out.println("输入类名：");
String className=in.nextLine();
System.out.println("方法名：");
String methodName=in.nextLine();
System.out.println("参数类型：");
String typeName=in.nextLine();
System.out.println("参数值：");
String paramValue=in.nextLine();
//动态加载类
Class cls=Class.forName(className);
//参数类型转换
Class type=null; //方法的参数类型
Object param=null;//调用方法时的实际参数
if(typeName.equals("int")){
//java中int的类型表示为：int.class
type=int.class;
param=Integer.parseInt(paramValue);
}else if(typeName.equals("double")){
type=double.class;
param=Double.parseDouble(paramValue);
}else if(typeName.equals("String")){
type=String.class;
param=paramValue;
}
//找到一个被执行的方法信息
Method method=cls.getDeclaredMethod(methodName,type);
//method.setAccessible(true);
System.out.println(method);
//动态创建对象
Object obj=cls.newInstance();
/*
* 执行方法
* obj代表包含方法的对象
* param代表执行方法的时候的实际参数
* param的数据类型要与type一致
*/
Object value=method.invoke(obj, param);
System.out.print(value);
}
利用反射获取属性的值：
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException {
Scanner in=new Scanner(System.in);
System.out.println("类名：");
String className=in.nextLine();
System.out.println("属性名：");
String name=in.nextLine();
Class cls=Class.forName(className);
//动态创建对象
Object obj=cls.newInstance();
//在类上查找指定的类信息
Field fld=cls.getDeclaredField(name);
//获取对象obj上的fld属性信息
Object value=fld.get(obj);
//输出属性的值
System.out.println(value);
}
获取字符串的char[] value属性
因为属性value是私有的，所以采用反射API访问：
public static void main(String[] args) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
String s="落霞与孤鹜齐飞，秋水共长天一色。";
//找到属性信息
Class cls=String.class;
Field fld=cls.getDeclaredField("value");
fld.setAccessible(true);
char [] chs=(char[])fld.get(s);
for(char c:chs){
System.out.println(c);
}
// chs[1]='好';
// System.out.println(s);
}
运行结果：
利用反射API动态设置对象的属性：
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException, InstantiationException, IllegalAccessException {
Scanner in=new Scanner(System.in);
System.out.println("类名:");
String className=in.nextLine();
System.out.println("属性：");
String name=in.nextLine();
System.out.println("值：");
String value=in.nextLine();
Class cls=Class.forName(className);
Field fld=cls.getDeclaredField(name);
Object obj=cls.newInstance();
//设置obj对象的fld属性值为value
fld.set(obj,value);
System.out.println(obj);
}
demo:
public class TestCase { public void testHello(){ System.out.println("hello world!"); } private void testKitty(){ System.out.println("hello kitty!"); } public void demo(){ System.out.println("demo"); } }
public class Foo { public int age=3; private String name; private int salary; private String gender; public Foo(){ } @Override public String toString() { return "Foo [age=" + age + ", name=" + name + ", salary=" + salary + ", gender=" + gender + "]"; } public Foo(int age, String name, int salary, String gender) { super(); this.age = age; this.name = name; this.salary = salary; this.gender = gender; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((gender == null) ? 0 : gender.hashCode()); result = prime * result + ((name == null) ? 0 : name.hashCode()); result = prime * result + salary; return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Foo other = (Foo) obj; if (age != other.age) return false; if (gender == null) { if (other.gender != null) return false; } else if (!gender.equals(other.gender)) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; if (salary != other.salary) return false; return true; } 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; } public int getSalary() { return salary; } public void setSalary(int salary) { this.salary = salary; } public String getGender() { return gender; } public void setGender(String gender) { this.gender = gender; } }
public class Goo { private int test(int a){ return a+1; } public String demo(String s){ return s+""; } public double demo(double d){ return d+1; } }
public class Person { String name; String sex; @Override public String toString() { return "Person [name=" + name + ", sex=" + sex + "]"; } }