因为要开始学习Java框架,所以特地简单的学习了一下Java的反射,只是一些基础的使用并没有涉及比较深层次的东西,比较适合小白.....
一.先进行准备工作:
在这里我定义了2个接口:MyInterface MyInterface2
1个实体类: Person
由实体类继承了两个接口;
两个接口:
package cn.skh.reflect;
public interface MyInterface {
void interfaceMethod() ;
}
package cn.skh.reflect;
public interface MyInterface2 {
void Interface02() ;
}
实体类:
package cn.skh.reflect;
public class Person implements MyInterface,MyInterface2{
private int age;
private String name;
private int id;
@Override
public void interfaceMethod() {
System.out.println("Interface Method.....");
}
public static void staticMethod() {
System.out.println("This is Static Method......");
}
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 getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Person(int age, String name, int id) {
this.age = age;
this.name = name;
this.id = id;
}
public Person(int id) {
this.id = id;
}
public Person() {
}
private Person(String name) {
this.name = name;
}
private void privateMethod() {
System.out.println("This is a privateMethid...");
}
private void privateMethod2(String name) {
System.out.println("privateMethod...."+name);
}
@Override
public void Interface02() {
System.out.println("This is a Interface02 Method......");
}
}
二、反射Demo
1.demo01:通过反射获取类的基本信息: 更具体的说明都写在了代码的注释里面,这里就不在叙述。
tips:你会发现在下面的代码中,不管是获取方法还是属性都会有两个方法 区别就是Declared的有无,在这里说明一下,有它只能获取当前的属性,不管是私有还是公有都可以。如果没有这个declared那么只能得到公有属性,但他的范围变大了,不仅可以得到当前类的,也可以获取父类的和所继承的接口的方法,但只能是public
package cn.skh.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectDemo01 {
//通过反射获取类
public static void demo01() {
//获取反射对象(反射入口):Class ,1 Class.forName(全类名) 2 类名.class 3 对象.getClass()
//1 Class.forName("全类名")
try {
Class<?> perClazz = Class.forName("cn.skh.reflect.Person") ;
System.out.println(perClazz);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
// 2 类名.class
Class<?> perClazz2 = Person.class ;
System.out.println(perClazz2);
// 3 对象.getClass()
Person per = new Person();
Class<?> perClazz3 = per.getClass() ;
System.out.println(perClazz3);
}
//获取公共方法
public static void demo02() {
//Class入口
Class<?> perClazz = null ;
try {
perClazz = Class.forName("cn.skh.reflect.Person") ;
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//获取所有的 公共的方法(1.本类 以及 父类、接口中的所有方法 2.符合访问修饰符规律)
Method[] methods = perClazz.getMethods();
for(Method method:methods) {
System.out.println(method);
}
System.out.println("==========");
//获取当前类的所有方法(1.只能是当前类 2.忽略访问修饰符限制)
Method[] declaredMethods = perClazz.getDeclaredMethods();
for(Method declaredMethod:declaredMethods) {
System.out.println(declaredMethod);
}
}
//获取所有的接口
public static void demo03() {
Class<?> perClazz = null ;
try {
perClazz = Class.forName("cn.skh.reflect.Person") ;
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Class<?>[] interfaces = perClazz.getInterfaces() ;
for(Class<?> inter:interfaces) {
System.out.println(inter);
}
}
//获取所有的父类
public static void demo04() {
Class<?> perClazz = null ;
try {
perClazz = Class.forName("cn.skh.reflect.Person") ;
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Class<?> superclass = perClazz.getSuperclass() ;
System.out.println(superclass);
}
//获取所有的构造方法
public static void demo05() {
Class<?> perClazz = null ;
try {
perClazz = Class.forName("cn.skh.reflect.Person") ;
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Constructor<?>[] constructors = perClazz.getConstructors() ;
for(Constructor<?> constructor:constructors) {
System.out.println(constructor);
}
}
//获取所有的公共属性
public static void demo06() {
Class<?> perClazz = null ;
try {
perClazz = Class.forName("cn.skh.reflect.Person") ;
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//公共属性
Field[] fields = perClazz.getFields() ;
for(Field field:fields) {
System.out.println(field);
}
System.out.println("====");
//所有属性 (属性的 :公共属性\所有属性的区别 同“方法”)
Field[] declaredFields = perClazz.getDeclaredFields() ;
for(Field declaredField:declaredFields) {
System.out.println(declaredField);
}
}
//获取当前反射所代表类(接口) 的对象(实例)
public static void demo07() throws InstantiationException, IllegalAccessException {
Class<?> perClazz = null ;
try {
perClazz = Class.forName("cn.skh.reflect.Person") ;
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Object instance = perClazz.newInstance() ;
Person per = (Person)instance ;
per.Interface02();
}
public static void main(String[] args) throws InstantiationException, IllegalAccessException {
// demo01();
// demo02();
// demo03();
// demo04();
// demo05();
// demo06();
demo07();
}
}
2.demo02: 通过反射获取对象实例 并操作对象
tips: 在这里需要注意的是,如果操作私有的方法或者属性,必须要暂时代开权限 才可以对私有的变量进行赋值 或者调用私有的方法:
package cn.skh.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
/*
* 获取对象实例 并操作对象
*/
public class ReflectDemo02 {
public static void demo01() throws InstantiationException, IllegalAccessException {
Class<?> perClazz = null ;
try {
perClazz = Class.forName("cn.skh.reflect.Person") ;
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Person p = (Person) perClazz.newInstance();
p.setName("skh");
p.setAge(18);
p.setId(1);
System.out.println(p.getName());
}
//操作属性
public static void demo02() throws InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException {
Class<?> perClazz = null ;
try {
perClazz = Class.forName("cn.skh.reflect.Person") ;
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Person p = (Person) perClazz.newInstance();
Field namefield = perClazz.getDeclaredField("name");
//只能设置public 可以修改权限
namefield.setAccessible(true);//此时私有变量也可以使用
namefield.set(p, "zxx");//等价于语句 p.setName("zxx"); 只能操作公有变量
System.out.println(p.getName());
System.out.println("======================");
Method method = perClazz.getDeclaredMethod("privateMethod2", String.class);//第一个为方法名 第二个为方法的参数类型的class入口 没有就是null
//因为我这个方法也是私有的 所以也要设置权限才可以调用
method.setAccessible(true);
method.invoke(p, "skh");//调用方法用invoke skh为给方法传入的参数
}
//操作构造方法
public static void demo03() throws InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
Class<?> perClazz = null ;
try {
perClazz = Class.forName("cn.skh.reflect.Person") ;
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
Person p = (Person) perClazz.newInstance();
//得到本类所有的构造方法
Constructor<?>[] constructors = perClazz.getDeclaredConstructors();
//获取指定的构造方法
Constructor<?> constructor = perClazz.getConstructor(int.class);//无参构造的话就不需要了反射入口
//在这里我们得到了构造方法 有构造方法可产生对象
Person p1 = (Person) constructor.newInstance(1);
//操作私有构造方法
Constructor<?> constructor2 = perClazz.getDeclaredConstructor(String.class);
//注意 这里也要放开权限 因为是私有的构造方法
constructor2.setAccessible(true);
Person p2 = (Person) constructor2.newInstance("skh");
System.out.println(p+"--"+p1+"--"+p2);
}
//反射可以 越过泛型检查
//虽然可以通过反射 访问private等访问修饰符不允许访问的属性/方法,也可以忽略掉泛型的约束;但实际开发 不建议这样使用,因此可能造成程序的混乱。
public static void demo04() throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {
ArrayList<Integer> list = new ArrayList<>() ;
list.add(123) ;
list.add(3) ;
list.add(2) ;
// list.add("zs") ;
Class<?> listClazz = list.getClass() ;
Method method = listClazz.getMethod("add", Object.class) ;
method.invoke(list , "zs...") ;
System.out.println(list);
}
public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException {
//demo01();
//demo02();
//demo03();
demo04();
}
}
就先说这些吧,应该够用了.......