慕课网《反射——Java高级开发必须懂的》听课笔记
一、class类的使用
class ClassDemo { public static void main(String[] args) { //Foo的对象怎么表示？ Foo foo1 = new Foo();//foo1就表示出来了 //Foo这个类是Class类的实例对象，只有java的虚拟机能创建它的实例对象 //任何一个类都是 Class的实例对象，这个实例对象有三种表示方式: //（1）、类名.class 任何一个类都有一个隐含的静态成员变量class Class c1 = Foo.class; //（2）、已知该类的对象，通过getClass方法 Class c2 = foo1.getClass(); /* * c1、c2表示类的类类型，一个类只可能是一个Class类的类类型 * 万物皆对象 * 类为Class类的实例对象 * 这个对象称之为该类的类类型 * */ //（3）、 Class c3 = null; try { c3 = Class.forName("Foo"); } catch (ClassNotFoundException e) { e.printStackTrace(); } System.out.println(c2 == c3); //我们完全可以通过类的类类型创建该类的实例对象--->通过c1、c2、c3创建Foo类的实例对象 try { /* * 为什么强制转换呢？ * newInstance到底返回什么才能让所有的类都可以这样去实例化呢？ * 那就需要所有类的父类对不对，那个所有类的父类就是Object，所以返回回来的是Object， * 那么这样的话就需要转换类型了，如果设计的人本身就不知道你有Foo这个类，所以他当然不会返回Foo这个类型。 * */ Foo foo = (Foo)c1.newInstance();//需要无参构造方法 foo.print(); } catch (InstantiationException e) { e.printStackTrace(); }catch (IllegalAccessException e) { e.printStackTrace(); } } } class Foo { void print(){} }
二、方法的反射
new 创建的对象，是静态加载类，在编译时刻就需要加载所有可能使用到的类，无论用不用的到，通过动态加载类可以解决这个问题
class Office { public static void main(String[] args) { try { //动态加载类，在运行时加载 Class c = Class.forName(args[0]); //通过类类型创建对象 OfficeAble oa = (OfficeAble)c.newInstance(); oa.start(); } catch (Exception e) { e.printStackTrace(); } } }
统一标准
interface OfficeAble { public void start(); }
当需要拓展功能，如要增加Excel时，只需要实OfficeAble接口，不需要重新编译，一般功能性的类使用动态加载
class Word implements OfficeAble { public void start() { System.out.print("Word start"); } }
三、获取方法的信息
基本数据类型存在类类型
class classType { public static void main(String[] args) { //基本数据类型都存在类类型，以下方式可以表示 Class c1 = int.class;//int的类类型 Class c2 = String.class;//String的类类型 String 的类字节码 Class c3 = double.class;//int的类类型 Class c4 = void.class;//int的类类型 //打印类的名称 System.out.println(c1.getName()); System.out.println(c2.getName()); System.out.println(c2.getSimpleName());//不含包名 } }
打印类的基本信息,包括成员变量、成员函数、构造方法
import java.lang.reflect.Method; import java.lang.reflect.Field; import java.lang.reflect.Constructor; class ClassMessage { /** * 打印类的信息，包括类的成员函数、成员变量 * obj该对象所属类的信息 */ //获取类的成员函数的信息 public static void ClassMessage (Object obj) { //要获取类的信息，首先要获取类的类类型 Class c = obj.getClass();//传递的是哪个子类的对象，得到的就是哪个类的类类型 System.out.println("类名称：" + c.getName()); /** * Method类，方法对象 * 一个成员方法就是一个Method对象 * getMethod()方法获取的就是所有的public函数，包括父类继承来的 * getDeclaredMethod()获取的就是所有该类自己声明的方法，不问访问权限 */ Method[] ms = c.getMethods();//c.getDeclaredMethod() for(int i = 0; i<ms.length; i++) { //获取方法返回值类型的类类型，如得到int，就是得到int.class Class returnType = ms[i].getReturnType(); System.out.print(i + " " + returnType.getName() + " "); //获取方法名称 System.out.print(ms[i].getName() + "("); //获取参数类型--->得到的是参数列表的类型的类类型 Class[] paramTypes = ms[i].getParameterTypes(); for (Class class1: paramTypes) { System.out.print(class1.getName() + ","); } System.out.println(")"); } //----------------------------------------------------------------------------------------- /** * 成员变量也是函数 * java.lang.reflect.Field * getFields()方法获取的是所有的public的成员变量的信息 * getDeclaredField()获取该类自己声明的成员变量的信息（私有） */ //Field[] fs = c.getField(); Field[] fs = c.getDeclaredFields(); for (Field field : fs) { //得到成员变量的类类型 Class fieldType = field.getType(); String typeName = fieldType.getName();//成员变量的名字 String fieldName = field.getName();//成员变量的名称 System.out.println(typeName + " " + fieldName); } //----------------------------------------------------------------------------------------- /** * 打印对象的构造函数信息 * 构造函数也是对象 * java.lang.Constructor中封装了构造函数的信息 * getConstructor()获取所有的public构造函数,getDeclaredConstructor()获取所有的构造函数 */ // Constructor[] cs = c.getConstructor(); Constructor[] cs = c.getDeclaredConstructors(); for (Constructor constructor: cs) { System.out.print(constructor.getName() + "("); //获取构造函数的参数列表-->得到的是参数列表的类类型 Class[] paramTypes = constructor.getParameterTypes(); for (Class class1 : paramTypes) { System.out.print(class1.getName() + ","); } System.out.println(")"); } } }
测试
class ClassMessageMain { public static void main(String[] args) { String s = "hello"; ClassMessage.ClassMessage(s); Integer n1 = 1; ClassMessage.ClassMessage(n1); } }
四、方法的反射操作
1）如何获取某个方法
方法的名称和方法的参数列表才能唯一决定某个方法
2）方法的反射操作
method.invoke(对象，参数列表)
import java.lang.reflect.Method; @SuppressWarnings("unchecked") public class MethodReflect { public static void main(String[] args) { /** * 获取print(int,int)方法, * 1、获取一个方法要先获取类的信息,获取类的信息要先获取类的类类型 */ A a1 = new A(); Class c = a1.getClass(); /** * 2、获取方法 名称和参数列表来决定 * getMethod获取的就是public的方法 * getDelcaredMethod自己声明的方法 */ try { //两种写法都可以 //Method m = c.getMethod("print", new Class[]{int.class, int.class}); Method m = c.getMethod("print", int.class, int.class); /** * 方法的反射操作 * 以往调用 a1.print(10, 20); * 方法的反射操作是用m 对象来进行方法调用，和上面方式效果完全相同 * 方法无返回值则返回null，有返回值则返回具体返回值 */ //Object o = m.invoke(a1, new Object[]{10, 20}); Object o = m.invoke(a1, 10, 20); } catch (Exception e) { e.printStackTrace(); } System.out.println("========================"); try { //获取方法print(String, String); Method m1 = c.getMethod("print", String.class, String.class); //用方法进行反射操作· Object o = m1.invoke(a1, "hello", "World"); } catch (Exception e) { e.printStackTrace(); } } } class A { 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()); } }
五、集合泛型的本质
import java.util.ArrayList; import java.lang.reflect.Method; @SuppressWarnings("unchecked") class GenericNature { public static void main(String[] args) { ArrayList list1 = new ArrayList(); ArrayList<String> list2 = new ArrayList<String>();//只能放String 类型 list1.add("hello"); //list1.add(20);会出错 Class c1 = list1.getClass(); Class c2 = list2.getClass(); System.out.println(c1==c2);//输出true /** * 反射的操作都是编译之后的操作，是运行时的操作 * 上面结果返回true说明编译之后集合的泛型是去泛型化的 * java集合的泛型，是防止错误输入的，只在编译阶段有效，绕过编译就无效 * 验证：可以通过方法的反射来绕过编译 */ try { Method m = c2.getMethod("add", Object.class); m.invoke(list2, 50);//绕过编译去操作就绕过了泛型 System.out.println(list2.size()); System.out.println(list2); } catch (Exception e) { e.printStackTrace(); } //不能用for (String str:list2){}遍历，类型错误 } }