------- android培训、java培训、期待与您交流! ----------
Class类
平常的java类是通过一些固定的支架(方法,成员变量等)搭建来的,搭建完成后它就具备了描述一类事物的特性。
而这些支架也属于事物,它也能够被类描述。所以java中就提供了Class类进行描述。
Class类所描述的事物是:java类在编译完成后,会生成class文件存在硬盘上。也就是
字节码。把字节码(保存了该类的基本信息)加载到内存中来。返回的类型是Class,当然
Class就具备了描述该类固定支架(方法,成员变量等)的特性。得到字节码的方法3种:
类名.class 例如,System.class
对象.getClass() 例如,new Date().getClass();
Class.forName(),例如,Class.forName("java.util.Date");
1,如果字节码已经在内存中,直接拿过来就哦了。
2,如果字节码不在内存中,需要从硬盘上把字节码加载到内存中去。
分析Class类。
package reflect;
public class ReflectTest {
public static void main(String[] args) throws ClassNotFoundException {
String abc = "afd";
Class cls1 = abc.getClass();
Class cls2 = String.class;
Class cls3 = Class.forName("java.lang.String");
// 虚拟机上做出该类一份字节码,其他要用就直接拿了。所以打印结果都为true
System.out.println(cls1 == cls2);
System.out.println(cls1 == cls3);
// 判断是否是基本数据类型的字节码isPrimitive()。false
System.out.println(cls1.isPrimitive());
// 基本类型的字节码和对应的封装类的字节码是不相同的。false、
System.out.println(int.class == Integer.class);
// TYPE常量代表包装类型所包装的基本类型的字节码。true
System.out.println(int.class == Integer.TYPE);
// 数组的字节码类型,不是原始类型false。
System.out.println(int[].class.isPrimitive());
// 数组的字节码类型,判断一个Class类型是否为数组用isArray()。true
System.out.println(int[].class.isArray());
// Class类型,判断基本数据类型:isPrimitive();判断数组类型:isArray();
// 总之:只要是在源程序中出的类型,都有各自的Class
}
}
反射的概念。
反射就是把Java类中的各种成分映射成相应的java类。
Constructor类
Constructor类代表某个类中的一个构造方法。
//得到构造方法: 通过构造函数参数列表的类型,来确定获取的具体构造类。
Constructor<String> strCon = String.class.getConstructor(StringBuffer.class);
// new String(new StringBuffer("abc"));
//创建实例对象:
// 1,在对strCon进行实例化对象的时候,需要指定参数对象。
String str2 = strCon.newInstance(new StringBuffer("abc"));
System.out.println(str2.charAt(2));
// 2,Class类提供了一个便利,有newInstance方法。直接可以创建对象。省去了获取Constructor再去创建对象。
// 反射的缺点:反射比较消耗性能占用时间,进行反射以后把得出的结果存在缓存起来。为后面尽可能的减少反射的使用量。
String s = String.class.newInstance();
}
Field类
package reflect;
import java.lang.reflect.Field;
public class FieldDemo {
public static void main(String[] args) throws SecurityException, NoSuchFieldException, InstantiationException, IllegalAccessException {
ReflectPoint p = new ReflectPoint(3,5);
// 字段通过字段名字区分。它不代表某个特定对象上面的值。而是告诉程序员,这个叫y的变量已经给你取到了。封装成了一个类。
// 类上的变量,不是对象上的变量。不包括私有的。
Field fieldY = p.getClass().getField("y");
// 从特定对象上取值。这个异常说明了,成员是私有的不让访问。
// Exception in thread "main" java.lang.NoSuchFieldException: y
// at java.lang.Class.getField(Class.java:1520)
// at reflect.FieldDemo.main(FieldDemo.java:10)
System.out.println(fieldY.get(p));
// 获取所有申明的变量。包括private类型。
Field fieldX = p.getClass().getDeclaredField("x");
// java.lang.IllegalAccessException: Class reflect.FieldDemo can not access a member of class reflect.ReflectPoint with modifiers "private"
// 上面异常的出现说明了,没有获取私有变量值的权限。
// 如果想要获取的话,需要进行暴力反射。
fieldX.setAccessible(true);
System.out.println(fieldX.get(p));
// Class c = String.class;
// String s = (String) c.newInstance();
//
// String s1 = String.class.newInstance();
}
}
将一个对象上所有的String类型的值中含有a的,进行替换。
private static void changeValue(ReflectPoint p) throws IllegalArgumentException, IllegalAccessException {
// 获取ReflectPoint中所有申明的字段。
Field[] fs = p.getClass().getDeclaredFields();
// 遍历字段。
for(Field f:fs){
// getType获取Field的类型,用==好,因为字节码只有一份。如果是String类型的话,就进行操作。
if(f.getType()==String.class){
String oldValue = (String)f.get(p);
String newValue = oldValue.replace("b", "a");
f.set(p,newValue);
System.out.println(newValue);
}
}
}
}
反射的作用:你给我一个对象我能把他里面的值都改掉。例如Spring框架中用的就是这个技术。你给我一个类,我就能用你给的资源来做些事情。。
Method类
// 通过方法名字,和参数列表来确定方法。导包的时候看到com...这种包是内部用的(不要导),看到java...这就是外部用的。
String str = "abc";
Method methodCharAt = String.class.getMethod("charAt", int.class);
// 已知Method,调用谁的Method并且还要给它传参数。
Character ch = (Character) methodCharAt.invoke(str, 2);
System.out.println(ch);
// 静态方法的调用,因为静态方法不需要对象。第一个参数应该是null。所以:
// Character ch2 = (Character) methodCharAt.invoke(null, 2);
String className= args[0];
invokeMain(className);
}
// 专家模式:只要类中有这个私有的数据,对这个数据的操作只能是我这个类的方法。
// 谁享有数据,谁就对这个数据有操作的权利。
调用其他类的main方法。
为什么要用反射的方式调用main。
main的参数是String数组,数组里面可以装类名字符串。
获取这这些类的名字。通过反射的原理可以获得各个类中的main方法。
分别执行这几个类。
private static void invokeMain(String className) throws Exception {
Method main = Class.forName(className).getMethod("main", String[].class);
// main是静态,所以第一个参数是空的。
// java.lang.IllegalArgumentException: wrong number of arguments jdk1.4特点,给进去一个数组会将数组拆掉,拆掉后的值作为参数造成的。导致参数变多了。
main.invoke(null, new Object[]{new String[]{"1","2","3"}});
// main.invoke(null, (Object)new String[]{"1","2","3"});
}
数组的反射。
package reflect;
import java.lang.reflect.Array;
import java.util.Arrays;
public class ArrayReflectDemo {
public static void main(String[] args) {
int[] a = new int[3];
int[] a2 = new int[4];
int[][] a3 = new int[2][3];
String[] a4 = new String[3];
// 数组class是否相同:1.数据类型2数组的维数
System.out.println(a.getClass() == a2.getClass());
// 数组的父类是Object
System.out.println(a4.getClass().getSuperclass().getName());
//
Object aObj1 = a;
Object aObj2 = a2;
// 因为a是一维数组,里面装的是int型变量,不是Object子类。不行。
// Object[] obj1=a;
// 二维数组,数组里面套数组。内层数组(一维数组)相当于是Object。可以
Object[] aobj3 = a3;
// String数组里面装的是String类型的变量。可以
Object[] aobj4 = a4;
System.out.println(Arrays.asList(a));
System.out.println(Arrays.asList(a4));
// 数组的反射。
printObjcet(a4);
}
private static void printObjcet(Object obj) {
Class clazz = obj.getClass();
if(clazz.isArray()){
// 反射
int len = Array.getLength(obj);
for(int i=0;i<len;i++){
System.out.println(Array.get(obj, i));
}
}
}
}