java反射总结_java反射总结

Class类的使用

1)在面向对象的世界里，万事万物皆对象

java语言中，静态的成员、普通数据类型不是对象

1.1 类是谁的对象呢？类是对象，类是java.lang.Class类的实例对象

1.2 这个对象到底如何表示？ There is a class named Class

public class ClassDemo1 {

public static void main(String[] args) {

Foo foo1 = new Foo();//Foo的实例对象

//Foo这个类也是一个实例对象，Class类的实例对象应该如何表示？

//任何一个类都是Class类的实例对象，这个实例对象有三种表示方式

//第一种表示方式--->实际在告诉我们任何一个类都有一个隐含的静态成员变量class

Class c1 = Foo.class; //Class实例对象

//第二种表达方式，已经知道该类的对象，通过getClass方法

Class c2 = foo1.getClass();

/*官网c1，c2表示了Foo类的类类型(class type)

* 万事万物皆对象

* 类也是对象，是Class类的实例对象

* 这个对象我们称为该类的类类型

*/

//不管c1 or c2都代表了Foo类的类类型，一个类只能是Class类的一个实例对象

System.out.println(c1 == c2);

//第三种表达方式

Class c3 = null;

try {

c3 = Class.forName("com.Reflect.Foo");

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

System.out.println(c2 == c3);

//我们完全可以通过类的类类型创建该类的对象实例--->通过c1 or c2 or c3创建Foo的实例

try {

Foo foo = (Foo) c1.newInstance(); //需要有无参数的构造方法

foo.print();

} catch (InstantiationException e) {

e.printStackTrace();

} catch (IllegalAccessException e) {

e.printStackTrace();

}

}

}

class Foo{

void print(){

System.out.println("Foo");

}

}

2)动态加载类；Class.forName("类的全称")

不仅表示了类的类类型，还代表了动态加载类

请大家区分编译、运行

编译时刻加载类是静态加载类、运行时刻加载类是动态加载类

功能性的类一般使用动态加载(如已经有了word和excel的功能，如需要增加ppt的功能，则只需要其他程序员再写一个对应的类即可)

如电脑上有运行的杀毒软件，在杀毒软件在线升级的时候，原来的版本是不需要删除的，是通过动态加载的方式实现升级的

public class OfficeBetter {

public static void main(String[] args) {

try {

//动态加载类，在运行时刻加载

Class c = Class.forName(args[0]);

//通过类类型，创建该类对象

//Word w = (Word) c.newInstance(); 因为无法预知调用什么类，所以不能使用对应类的强制转换类型

//需要为它们统一标准

OfficeAble oa = null;

try {

oa = (OfficeAble) c.newInstance();

} catch (InstantiationException e) {

e.printStackTrace();

} catch (IllegalAccessException e) {

e.printStackTrace();

}

oa.start();

} catch (ClassNotFoundException e) {

e.printStackTrace();

}

}

}

interface OfficeAble {

public void start();

}

3)基本的数据类型

基本的数据类型， void关键字等都存在数据类型

// 获取基本数据类型的类类型

public class ClassDemo2 {

public static void main(String[] args) {

Class c1 = int.class; //int 的类类型

Class c2 = String.class; //String 类的类类型，String类字节码

Class c3 = double.class; //数据类型的字节码表示方式

Class c4 = Double.class; //Double类的字节码表示方式

Class c5 = void.class;

// Class c6 = package.class; 不是在类里面声明的

System.out.println(c1.getName());

System.out.println(c2.getName());

System.out.println(c3.getSimpleName()); //打印不包含包名的类的名称

}

}

4)Class类的基本API操作(ClassUtil和ClassDemo3)

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

public class ClassUtil {

/**

* 打印类的信息，包括类的成员函数

* @param obj 该对象所属类的信息

*/

public static void printClassMessage(Object obj){

//要获取类的信息，首先要获取类的类类型

Class c = obj.getClass(); //传递的是哪个子类的对象，c就是该子类的类类型(Object类是任何类的父类)

//接下来获取类的名称

System.out.println("类的名称是：" + c.getName());

//方法是Method的对象

/**

* Method类，方法对象

* 一个成员变量就是一个Method对象

* getMethod方法获取的是所有的public函数，包括父类继承而来的

* getDeclaredMethods获取的是所有该类自己声明的方法，不问访问权限(继承而来的就无法获取)

*/

Method[] ms = c.getMethods(); //c.getDeclaredMethods();

//获取方法的信息

for(int i = 0; i

//得到方法的返回值类型的类类型

Class returnType = ms[i].getReturnType();

System.out.print(returnType.getName() + "("); //获取返回值类型的名字

//得到方法的名称

System.out.print(ms[i].getName());

//获取参数类型--->得到的是参数列表的类型的类类型

Class[] paramTypes = ms[i].getParameterTypes();

for(Class class1: paramTypes){

System.out.print(class1.getName() + ",");

}

System.out.print(")\n");

}

}

/**

* 获取成员变量的信息

* @param obj

*/

public static void printFieldMessage(Object obj) {

/**

* 成员变量也是对象

* java.lang.reflect.Field

* Field类封装了关于成员变量的操作

* getFields方法获取的是所有的public的成员变量的信息

* getDeclaredFields获取的是该类自己声明的成员变量的信息

*/

// Field[] fs = c.getFields();

Class c = obj.getClass();

Field[] fs = c.getDeclaredFields();

for(Field field: fs){

//得到成员变量的类型的类类型(如果成员变量是String类型，这里得到的是String.class)

Class fieldType = field.getType();

//得到成员变量类型的名字

String typeName = fieldType.getTypeName();

//得到成员变量的名字

String fieldName = field.getName();

System.out.println(typeName + " " + fieldName);

}

}

/**

* 打印对象的构造函数的信息

* @param obj

*/

public static void printConMessage(Object obj){

Class c = obj.getClass();

/**

* 构造函数也是对象

* java.lang.Constructor中封装了构造函数的信息

* getConstructor获取所有的public的构造函数

* getDeclaredConstructors得到所有的构造函数

* 构造函数都是自己声明的

*/

Constructor[] cs = c.getConstructors();

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(constructor.getName() + ")");

}

}

}

5)方法重构：

选中需要重构的方法体--->Refactor--->Extract--->Method--->输入方法名

2、方法的反射：

方法的正常调用方式：a1.print(10,20)；

但是方法的反射操作是用m对象类进行方法调用，和a1.print调用的效果完全相同

import java.lang.reflect.Method;

/**

* 如何去获得方法对象

* 然后用方法对象进行反射操作

*/

public class MethodDemo1 {

public static void main(String[] args) {

/**

* 要获取print(int, int)方法

* 1.要获取一个方法就是获取类的信息，获取类的信息，首先要获取类的类类型

*/

A a1 = new A();

Class c = a1.getClass();

/**

* 2.获取方法名称和参数列表

* getMethod获取的是public的方法

* getDeclaredMethod

*/

try {

//Method m = c.getMethod("print", new Class[]{int.class, int.class});

Method m = c.getMethod("print", int.class, int.class);

System.out.println("===========================================");

Method m1 = c.getMethod("print", String.class, String.class);

System.out.println("===========================================");

Method m2 = c.getMethod("print");

//方法的反射操作

//a1.print(10,20)；方法的反射操作是用m对象类进行方法调用，和a1.print调用的效果完全相同

//用print方法对象来操作a1

//方法如果没有返回值，则返回null；如果有返回值，则返回具体的返回值

m.invoke(a1,new Object[]{10, 20});

m.invoke(a1,10,20);

m1.invoke(a1, "hello", "world");

m2.invoke(a1);

} catch (Exception 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.toUpperCase());

}

}

3、了解泛型的本质：通过Class，Method来认识泛型的本质

泛型是为了防止错误输入的，只是在编译阶段有效，绕过编译就无效了(编译之后就没有泛型存在了)

而反射的操作都是编译之后的操作

因此若使用反射方法进行对象的操作，便可以绕过泛型()

package com.Reflect;

import java.lang.reflect.Method;

import java.util.ArrayList;

public class MethodDemo4 {

public static void main(String[] args) {

ArrayList list = new ArrayList();

ArrayList list1 = new ArrayList();

//泛型是为了防止错误输入的

list1.add("hello");

// list1.add(20);

Class c1 = list.getClass();

Class c2 = list.getClass();

System.out.println(c1 == c2);

//反射的操作都是编译之后的操作

/*

*c1 == c2结果返回true说明编译之后，集合的泛型是去泛型化的

*java中结合的泛型，是防止错误输入的，只是在编译阶段有效

* 绕过编译就无效了(编译之后就没有泛型存在了)

* 验证：我们可以通过方法的反射来操作，绕过编译

*/

try {

Method m = c1.getMethod("add", Object.class);

m.invoke(list1, 20); //绕过编译去操作就绕过了泛型

System.out.println(list1.size());

System.out.println(list1);

// for(String s: list1){ //foreach操作的时候会出错，会有类型转换错误

// System.out.println(s);

// }

} catch (Exception e) {

e.printStackTrace();

}

}

}