一、反射
《java核心技术》
官方套话：能够分析类能力的程序成为反射。
又通过网上搜索有这句话：反射指程序可以访问、检测和修改它本身状态或行为的一种能力。
反射是用来干什么的呢？
“明明我自己能直接new一个对象，为什么它要绕一个圈子，先拿到Class对象，再调用Class对象的方法来创建对象呢，这不是多余吗？”
说不出来，大体作用就是方便，以前只在JDBC用过，看了这边文章后发现springMVC也用。。。。。。我学个寂寞
https://www.cnblogs.com/Java3y/p/12320363.html
说说你对 Java 中反射的理解
Java中的反射首先是能够获取到Java中要反射类的字节码，获取字节码有三种方法，
- Class.forName(className)
- 类名.class。
- obj.getClass()
然后将字节码中的方法，变量，构造函数等映射成相应的Method、Filed、Constructor等类，这些类提供了丰富的方法可以被我们所使用。
1、反射机制
反射是一种功能强大且复杂的机制，反射机制可以用来：
- 在运行时分析类的能力
- 在运行时查看对象
- 实现通用的数组操作代码
- 利用Method对象，这个对象很像C++中的函数指针
这个method对象找了很多资料，还是没太搞明白
2、Class类
获取Class类对象的三种方法：
- 常用的有getClass()方法将返回一个Class类型的实例，getName()方法将返回类的名字。
- 可以调用静态方法forName()获取类名对应的Class对象。
- 如果T是任意java类型（或者void关键字），T.class将代表匹配的类对象。
1 package Reflect; 2 3 public class Person {}
Student和Teacher都是Person类的子类
package Reflect; public class test { public static void main(String[] args) throws ClassNotFoundException { Person student = new Student(); Person teacher = new Teacher(); Object obj=new Object(); System.out.println(student.getClass()); System.out.println(teacher.getClass()); System.out.println(obj.getClass()); // class Reflect.Student // class Reflect.Teacher // class java.lang.Object System.out.println(student.getClass().getName()); System.out.println(teacher.getClass().getName()); System.out.println(obj.getClass().getName()); // Reflect.Student // Reflect.Teacher // java.lang.Object Class c1=Class.forName("Reflect.Person"); System.out.println(c1); // class Reflect.Person Class c2= Person.class; System.out.println(c2); // class Reflect.Person
Class c3=int.class;
System.out.println(c3);
// int,注意，一个Class对象实际上表示的是一个类型，而这个类型未必一定是一种类，比如这里的int不是类，但int.class是一个Class类型的对象
}
}
获取类对象可以搭配newInstance动态的创建一个类的实例！（调用的是类的默认无参构造器，如果没有会抛出异常）
3、检查类的结构
在java.lang.reflect包中有三个类Field，Method，Constructor分别用于描述类的域，方法，构造器。这三个类都有一个getName的方法，用来返回项目的名称。
常用的方法有：
Field类：getType() ：返回描述域所属类型的Class对象
getModifiers()：返回一个整形数值，用不同的位开关描述public和static这样的修饰符使用情况
Method类：getReturnType()：方法的返回类型
getParameterTypes()：参数的类型
Constructors类：getParameterTypes()：参数的类型
Class类：getFileds()，getMethods()和getConstructors()返回类提供的public域，方法，构造器，其中包括超类的公有成员
getDeclareFields()，getDeclareMethods()，getDeclareConstructors()将返回类中声明的全部域，方法和构造器，其中包括私有和受保护，但不包括超类成员
package Reflect;
import sun.management.MethodInfo;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Scanner;
public class ClassConstruct {
public static void main(String[] args) {
String name;
if (args.length > 0){
name=args[0];
}else {
Scanner in = new Scanner(System.in);
System.out.println("输入类名(eg:java.util.Date)");
name=in.next();
}
try {
Class c1=Class.forName(name);
Class superc1=c1.getSuperclass();//获得父类的对象
String modifiers= Modifier.toString(c1.getModifiers());//返回一个整形数值，用不同的位开关描述public和static这样的修饰符使用状况
if (modifiers.length()>0){
System.out.print(modifiers+" ");
}
System.out.print("class："+name);
if (superc1 !=null && superc1 !=Object.class ){
System.out.print(" extends "+superc1.getName());
}
System.out.print("n{n");
printConstructors(c1);//打印出c1的构造器
System.out.println();
printMethods(c1);//打印出c1的方法
System.out.println();
printFields(c1);//打印出c1的域
}catch (ClassNotFoundException e){
e.printStackTrace();
}
System.out.println("}");
System.exit(0);
}
/**
* 打印出c1类的全部构造器
* @param c1
*/
private static void printConstructors(Class c1) {
Constructor[] constructors=c1.getDeclaredConstructors();//返回类的全部构造器
for (Constructor c:constructors) {
String name=c.getName();
System.out.print(" ");
String modifiers=Modifier.toString(c.getModifiers());
if (modifiers.length()>0){
System.out.print(modifiers+" ");
}
System.out.print(name+" (");
//打印参数类型
Class[] paramTypes=c.getExceptionTypes();
for (int i=0;i<paramTypes.length;i++){
if (i>0){
System.out.print(paramTypes[i].getName());
}
}
System.out.print(" );");
}
}
/**
* 打印出c1类的全部方法
* @param c1
*/
private static void printMethods(Class c1) {
Method[] methods=c1.getDeclaredMethods();
for (Method m:methods){
Class retType=m.getReturnType();//方法的返回类型
String name=m.getName();//获得方法名
System.out.print(" ");
//打印public或static，返回类型和方法名
String modifiers=Modifier.toString(m.getModifiers());
if (modifiers.length()>0){
System.out.print(modifiers+" ");
}
System.out.print(retType.getName()+" "+name+" (");
//打印参数类型
Class[] paramType=m.getParameterTypes();
for (int i = 0; i <paramType.length ; i++) {
if (i>0){
System.out.print(",");
}
System.out.print(paramType[i].getName());
}
System.out.println(");");
}
}
/**
* 打印出c1类的全部域
* @param c1
*/
private static void printFields(Class c1) {
Field[] fields=c1.getDeclaredFields();
for (Field f:fields) {
Class type=f.getType();//得到域的类型
String name=f.getName();
System.out.print(" ");
String modifiers=Modifier.toString(f.getModifiers());
if (modifiers.length()>0){
System.out.print(modifiers+" ");
}
System.out.println(type.getName()+ " "+name+" ;");
}
}
}
控制台输入一个类：eg：java.lang.Double，输出：
public final class：java.lang.Double extends java.lang.Number { public java.lang.Double ( ); public java.lang.Double ( ); public boolean equals (java.lang.Object); public static java.lang.String toString (double); public java.lang.String toString (); public int hashCode (); public static int hashCode (double); public static double min (double,double); public static double max (double,double); public static native long doubleToRawLongBits (double); public static long doubleToLongBits (double); public static native double longBitsToDouble (long); public volatile int compareTo (java.lang.Object); public int compareTo (java.lang.Double); public byte byteValue (); public short shortValue (); public int intValue (); public long longValue (); public float floatValue (); public double doubleValue (); public static java.lang.Double valueOf (java.lang.String); public static java.lang.Double valueOf (double); public static java.lang.String toHexString (double); public static int compare (double,double); public static boolean isNaN (double); public boolean isNaN (); public static boolean isFinite (double); public static boolean isInfinite (double); public boolean isInfinite (); public static double sum (double,double); public static double parseDouble (java.lang.String); public static final double POSITIVE_INFINITY ; public static final double NEGATIVE_INFINITY ; public static final double NaN ; public static final double MAX_VALUE ; public static final double MIN_NORMAL ; public static final double MIN_VALUE ; public static final int MAX_EXPONENT ; public static final int MIN_EXPONENT ; public static final int SIZE ; public static final int BYTES ; public static final java.lang.Class TYPE ; private final double value ; private static final long serialVersionUID ; } Process finished with exit code 0
在运行时使用反射分析对象
查看对象域的关键方法是Field类中的get方法，如果f是Field类型的对象，obj是某个包含f域的类的抽象，f.get(obj)将返回一个对象，其值为obj域的当前值。
public class Person { public String name; public int val; public Person(String name,int val){ this.name=name; this.val=val; } }
public class ReflectTest { public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException { Person person=new Person("Curry",1000); Class c1=person.getClass(); Field f=c1.getDeclaredField("val");//获取它对象的某个域 Object v=f.get(person);// System.out.println(v);
//1000 } }
这里Person类中如果域的访问权限是private，则将会出错
Exception in thread "main" java.lang.IllegalAccessException: Class Reflect.ReflectTest can not access a member of class Reflect.Person with modifiers "private" at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:102) at java.lang.reflect.AccessibleObject.slowCheckMemberAccess(AccessibleObject.java:296) at java.lang.reflect.AccessibleObject.checkAccess(AccessibleObject.java:288) at java.lang.reflect.Field.get(Field.java:390) at Reflect.ReflectTest.main(ReflectTest.java:10)
get()方法只能得到可访问域的值，除非拥有权限，否则java的安全机制只允许查看任意对象有哪些域，而不允许读取他们的值。
反射机制的默认行为受限于java的访问控制，然而如果一个java程序没有受到安全管理器的控制，就可以覆盖访问控制。为了达成目的，需要调用Field，Method或Constructors对象的setAccessible()
public class ReflectTest { public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException { Person person=new Person("Curry",1000); Class c1=person.getClass(); Field f=c1.getDeclaredField("val"); f.setAccessible(true); Object v=f.get(person); System.out.println(v);
//1000 } }
发现现在可以访问了
f.set(person,1900); 设置新值
4、反射机制的动态代理
摘自于https://www.cnblogs.com/lzq198754/p/5780331.html
public interface Subject { public String say(String name, int age); } class RealSubject implements Subject { public String say(String name, int age) { return name + " " + age; } }
//如果想要完成动态代理，首先需要定义一个InvocationHandler接口的子类，已完成代理的具体操作。 class MyInvocationHandler implements InvocationHandler { private Object obj = null; public Object bind(Object obj) { this.obj = obj; return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this); } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object temp = method.invoke(this.obj, args); return temp; } }
public class ProxyTest { public static void main(String[] args) throws Exception { MyInvocationHandler demo = new MyInvocationHandler(); Subject sub = (Subject) demo.bind(new RealSubject()); String info = sub.say("Rollen", 20); System.out.println(info);
//Rollen 20
} }
二、泛型
内容来源于网络如有侵权请私信删除
文章来源: 博客园
- 还没有人评论，欢迎说说您的想法！
客服
