反射(个人理解):已知一个对象,可以通过反射方法获得对象的类类型,通过调用类类型来获得该类类型里面封装的方法、成员变量、构造函数等
一、Class类
(1)在面向对象的世界里,万事万物皆对象
java语言中,静态的成员(属于类)、普通的数据类型不是对象。(对象是new一个类实例化得到的)
类是对象,类是java.lang.Class类的实例对象
实例化Class类的实例对象有三种方法,如下代码所示
class Foo{
public void printfoo(){
System.out.println("foo");
}
}
public class ClassDemo {
public static void main(String[] args) {
//Foo的实例化表示
Foo f1=new Foo();
//Foo这个类也是一个实例对象,是Class的实例对象,如何表示?
//任何一个类都是Class的实例对象,这个实例对象有三种表达方式
//第一种表达方式----> 已经知道该类的对象,通过getClass方法
Class c1=f1.getClass();
//第二种表达方式----> 任何一个类都有一个隐含的静态成员变量class
Class c2=Foo.class;
/*
官网c1 c2 表示了Foo类的类类型。万事万物皆对象,类也是对象,是Class类的实例对象,这个对象我们称之为该类的类类型
*/
//true---->不管c1或c2都代表了Foo类的类类型,一个类只可能是Class类的一个实例对象
System.out.println(c1==c2);
//第三种表达方式
Class c3=null;
try {
c3=Class.forName("Foo");//写法:Class.forName("类所在的包(不用写src).类名")
System.out.println(c3);//输出 class Foo
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//true
System.out.println(c2==c3);
}
}
二、动态加载类
编译时刻加载类是静态加载类,运行时刻加载类是动态加载类
Class.forName(“类的全称”)不仅代表了类的类类型,还代表了动态加载类
new创建对象是静态加载类,如果没有实现类,就new类的对象,会在编译的时候就报错。
通过动态加载类创建对象:
Class c1=Class.forName("包名.类名");
c1.newInstance();
Dynamic.java
package Reflection;
public class Dynamic {
public static void main(String[] args1) {
System.out.println(new Word().getClass().getName());
if("Word".equals(args1[0])){//与运行时输入的参数作比较
try {
Office OF= (Office) Class.forName("Reflection."+args1[0]).newInstance();
OF.start();
} catch (Exception e) {
e.printStackTrace();
}
}
if("Excel".equals(args1[0])){
try {
Office OF= (Office) Class.forName("Reflection."+args1[0]).newInstance();
OF.start();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
Office.java
package Reflection;
public interface Office {
public void start();
}
Excel.java
package Reflection;
public class Excel implements Office{
public void start(){
System.out.println("excel.....start");
}
}
Word.java
package Reflection;
public class Word implements Office{
public void start(){
System.out.println("word.....start");
}
}
实现Office接口,使Word和Excel都实现这个接口,在调用方法的时候就可以使用Office来接受Word和Excel的对象。
基本的数据类型、基本数据类型的封装类、void关键字都有类类型
package Reflection;
public class ClassDemo {
public static void main(String[] args) {
Class c1=int.class;
Class c2=double.class;
Class c3=Double.class;
Class c4=void.class;
Class c5=String.class;
Class c6=Character.class;
System.out.println(c3.getName());//java.lang.Double
System.out.println(c5.getName());//getName()返回类的全称,包含包名 java.lang.String
System.out.println(c5.getSimpleName());//getSimpleName()只返回类名,没有包名 String
System.out.println(c6.getSimpleName());//Character
}
}
三、获取类信息(方法、成员变量、构造函数)
1、方法也是对象。java.lang.reflect.Method类封装了方法的信息
2、成员变量也是对象。java.lang.reflect.Filed封装了关于成员变量的信息和操作
3、构造函数也是对象。java.lang.reflect.Constructor封装了关于构造函数的信息和操作
GetMethods.java里包含了获取类的方法、成员变量和构造函数的信息的方法
package Reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Field;
public class GetMethods {
public static void printMethodsMessage(Object o){
//要获取类的信息,首先要获取类的类类型
Class c1=o.getClass();//传递的是哪个子类的对象,c1就是该类的类类型
//获取类的名称
System.out.println("类的名称是:"+c1.getName());
/*
Method类,是方法对象。一个方法就是一个Method类的对象
getMethods()获取的是所有的public方法,包括从父类继承而来的
getDeclaredMethods()获取的是该类自己声明的所有方法,不问访问权限
*/
Method[] ms=c1.getMethods();
for(int i=0;i<ms.length;i++){
//得到方法的返回值类型的类类型
Class c=ms[i].getReturnType();
System.out.println(c.getName()+" ");
//得到方法的名称
System.out.print(ms[i].getName()+"(");
//获得每个方法的参数类型的名称
Class[] Parameter=ms[i].getParameterTypes();
for(Class clas1:Parameter){
System.out.print(clas1.getName()+",");
}
System.out.println(")");
}
}
public static void printFieldMessage(Object c1) {
//Field类封装了类的成员变量的信息
//getFields()获取的是类里面所有的public的成员变量
//getDeclaredFields()获取的是类里面自己定义的所有成员变量,包括private的
//Field[] f=c1.getFields();
Class n=c1.getClass();
Field[] f1= n.getDeclaredFields();
for(Field f:f1){
//得到成员变量的类型的类类型
Class cs=f.getType();
String s1=cs.getName();
//得到成员变量的名称
String s2=f.getName();
System.out.println(s1+".."+s2);
}
}
public static void printConMessage(Object c1){
//构造函数也是对象
// java.lang.reflect.Constructor中封装了构造函数的信息
//getDeclaredConstructors()获取的是类定义的所有的构造函数
// getConstructors()获取的是类里面所有的public的构造函数
Class c=c1.getClass();
//Constructor[] cs=c.getConstructors();
Constructor[] cs1=c.getDeclaredConstructors();
for(Constructor cc:cs1){
System.out.print(cc.getName()+"(");
//获取构造函数的参数列表,得到的是参数列表的类类型
Class[] tt=cc.getParameterTypes();
for(Class cl:tt){
System.out.print(cl.getName()+",");
}
System.out.println(")");
}
}
}
classDemo.java里是调用方法
package Reflection;
public class ClassDemo {
public static void main(String[] args) {
String s1="hh";
GetMethods.printMethodsMessage(s1);
GetMethods.printFieldMessage(s1);
GetMethods.printConMessage(s1);
}
}
四、方法反射
(1)如何获取某个方法
方法的名称和方法的参数列表才能唯一决定某个方法
(2)方法反射的操作
method.invoke(对象,参数列表)
package Reflection;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class MethodReflect {
public static void main(String[] args) {
//要获取print(int,int)方法,要获取一个方法实际上就是要获取一个类的信息,获取类的信息首先要获取类的类类型
A a=new A();
Class c=a.getClass();
//getDeclaredMethod(“方法名称”,class<存放参数的class>)获取该类自己声明的所有方法
try {
Method m=c.getDeclaredMethod("print", int.class, int.class);
//一般的调用方法a.print(10,20); 对象调用方法
//方法的反射操作是调用c对象来进行方法调用。和a.print(10,20)的效果一样
//通过invoke方法来实现方法的反射。invoke(对象的名称,Object类型的传递的参数),这个方法是有返回值的,返回值的类型是Object的,可能需要强制类型转化。如果调用的方法本身没有返回值,呢么返回null,如果有返回值则返回对应的返回值
Object o=m.invoke(a, 10,20); //方法调用对象
Method m2=c.getDeclaredMethod("print", String.class,String.class);
Object o1=m2.invoke(a,"hello","world");
//如果方法没有参数,就只写方法名称即可
Method m3=c.getDeclaredMethod("print");
m3.invoke(a);
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
class A{
public void print(){
System.out.println("helloworld");
}
public void print(int a,int b){
System.out.println(a+b);
}
public void print(String a,String b){
System.out.println(a.toUpperCase()+","+b.toLowerCase());
}
}
五、通过反射了解集合泛型的本质
泛型提供了编译时类型安全检测机制,该机制允许程序员在编译时检测到非法的类型。编译之后的集合的泛型是去泛型化的。泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。
package Fanxing;
import java.io.ObjectInputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
public class TestFan {
public static void main(String[] args) {
ArrayList a=new ArrayList();
ArrayList<String> b=new ArrayList<String>();
b.add("1");
//b.add(0); 会报错
Class c1=a.getClass();
Class c2=b.getClass();
System.out.println(c1==c2);//true
/*
c1==c2结果返回true说明编译之后的集合的泛型是去泛型化的
Java中的集合的泛型,是防止错误输入的,只在编译阶段有效,绕过编译就无效了
*/
//反射的操作都是编译之后的操作。
// 验证:可以通过方法的反射来操作,绕过编译
try {
Method m=c2.getMethod("add", Object.class);
try {
m.invoke(b,20);
System.out.println(b.size());
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
}
}