黑马程序员——Java基础---反射

反射
JAVA反射机制是在运行状态中，对于任意一个类（class文件），都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象方法的功能称为java语言的反射机制。
动态获取类中信息，就是java反射。可以理解为对类的解剖。
如果想要对指定名称的字节码文件进行加载并获取其中的内容并调用，这时就使用到了反射技术。
P.S. 所谓的框架就是对外提供一些接口，也就是功能扩展的标准，由实现类按照这个接口标准去实现。框架内部如果需要操纵这些实现类的对象完成某些操作，那么只需要把这些实现类的全名（包名+类名）写在某个配置文件中，框架代码只需要读取这个配置文件，就可以获取这个实现类的字节码文件，然后利用反射技术创建这个实现类的对象并且调用相应的方法完成一些操作。
用于描述字节码的类就是Class类，创建对象，可以提取字节码文件中的内容，如字段、构造函数、一般函数。该类就可以获取字节码文件中的所有内容，那么反射就是依靠该类完成的。想要对一个类文件进行解剖，只要获取到该类的字节码文件对象即可。实际开发中一些常用，但又容易写错，遗忘的// 使用反射技术得到T的真实类型
// 获取当前new的对象的泛型的父类类型
ParameterizedType pt = (ParameterizedType) this.getClass().getGenericSuperclass();
// 获取第一个类型参数的真实类型
this.clazz = (Class<T>) pt.getActualTypeArguments()[0];
使用反射获取Method，可以使用getMethod(String name, Class<?>... parameterTypes)来获取，第一个参数是方法的名字，第二个是参数类表
但是这个方法没参数呢？比如：
一个简单的Person 类

public class Person {
public String name="zhangsan";
public int age;
public String str1 = "ball";
public String str2 = "baskecballl";
public Person(){
this.str1=str1;
this.str2=str2;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [age=" + age + ", name=" + name + ", str1=" + str1
+ ", str2=" + str2 + "]";
}
}

复制代码如果是调用set方法很简单，根据规则

Method methodName = p.getClass().getMethod("setName",String.class);
System.out.println(methodName.invoke(p, "张三"));

复制代码这样就获取了，但是如果是get 方法呢，参数列表是空，怎么做的？
这样可以

Method methodName = p.getClass().getMethod("getName",null);
System.out.println(methodName.invoke(p,null));

复制代码这样更好

Method methodName = p.getClass().getMethod("getName");
System.out.println(methodName.invoke(p));

复制代码

示例：获取字节码文件对象的3种方式 Person.java

package cn.itcast.bean;
public class Person
{
private int age;
private String name;
public Person(int age,String name){
super();
this.age = age;
this.name = name;
System.out.println("Person param run..." + this.name + ":" + this.age);
}
public Person(){
super();
System.out.println("person run");
}
public void show(){
System.out.println(name + "...show run..." + age);
}
private void privateMethod(){
System.out.println("method run");
}
public void paramMethod(String str,int num){
System.out.println("paramMethod run..." + str + ":" + num);
}
public static void staticMethod(){
System.out.println("static method run...");
}
}

复制代码
ReflectDemo.java

import cn.itcast.bean.Person;
//要想要对字节码文件进行解剖，必须要有字节码文件对象。
public class ReflectDemo
{
public static void main(String[] args) throws ClassNotFoundException {
getClassObject_1();
System.out.println("--------------------");
getClassObject_2();
System.out.println("--------------------");
getClassObject_3();
}
/*
* 获取字节码对象的方式：
* 方式一：Object类中的getClass()方法的。
* 想要用这种方式，必须要明确具体的类，并创建对象。
* 麻烦。
*/
public static void getClassObject_1(){
Person p = new Person();
Class clazz = p.getClass();
Person p1 = new Person();
Class clazz1 = p1.getClass();
System.out.println(clazz == clazz1);
}
/*
* 方式二：任何数据类型都具备一个静态的属性.class来获取其对应的Class对象。
* 相对简单，但是还是要明确用到类中的静态成员。
* 还是不够扩展。
*/
public static void getClassObject_2(){
Class clazz = Person.class;
Class clazz1 = Person.class;
System.out.println(clazz == clazz1);
}
/*
* 方式三：只要通过给定的类的字符串名称就可以获取该类，更为扩展。
* 可以用Class类中的方法完成。
* 该方法就是forName。
* 这种方法只要有名称即可，更为方便，扩展性更强。
*/
public static void getClassObject_3() throws ClassNotFoundException {
//可以把类的字符串名称写到配置文件中，然后读取出来。
String className = "cn.itcast.bean.Person";
Class clazz = Class.forName(className);
System.out.println(clazz);
}
}

复制代码运行结果： person run
person run
true
--------------------
true
--------------------
class com.test.Person
黑马程序员——Java基础---反射

示例：获取Class中的构造函数

import cn.itcast.bean.Person;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class ReflectDemo
{
public static void main(String[] args) throws Exception {
createNewObject_1();
System.out.println("--------------------");
createNewObject_2();
}
public static void createNewObject_1() throws ClassNotFoundException,InstantiationException,IllegalAccessException {
//早期：new时候，先根据被new的类的名称找寻该类的字节码文件，并加载进内存，
//并创建该字节码文件对象，并接着创建该字节文件的对应的Person对象。
//Person p = new Person();
//现在：
String name = "cn.itcast.bean.Person";
//找寻该文件类文件，并加载进内存，并产生Class对象。
Class clazz = Class.forName(name);
//如何产生该类的对象呢？
Object obj = clazz.newInstance();//调用Person的空参构造函数
}
public static void createNewObject_2() throws ClassNotFoundException,InstantiationException,NoSuchMethodException,IllegalAccessException,InvocationTargetException {
//Person p = new Person("小强",39);
/*
* 当获取指定名称对应类中的所体现的对象时。
* 而该对象初始化不使用空参数构造函数该怎么办呢？
* 既然是通过指定的构造函数进行对象的初始化。
* 所以应该先获取到该构造函数，通过字节码文件对象即可完成。
* 该方法是：getConstructor(parameterTypes);
*/
String name = "cn.itcast.bean.Person";
//找寻该名称类文件，并加载进内存，并产生Class对象。
Class clazz = Class.forName(name);
//获取到了指定的构造函数对象
Constructor constructor = clazz.getConstructor(int.class,String.class);
//通过该构造器对象的newInstance方法进行对象的初始化。
Object obj = constructor.newInstance(38,"小明");
}
}

复制代码运行结果： person run
--------------------
Person param run...小明:38
黑马程序员——Java基础---反射

示例：获取Class的字段

import cn.itcast.bean.Person;
import java.lang.reflect.Field;
public class ReflectDemo
{
public static void main(String[] args) throws Exception {
getFieldDemo();
}
/*
* 获取字节码文件中的字段。
*/
public static void getFieldDemo() throws Exception {
Class clazz = Class.forName("cn.itcast.bean.Person");
//getField只能获取所有可访问公共字段，private获取不到。
//Field field = claszz.getField("age");
//getDeclaredField可以获取到公共字段，也可以获取到私有字段。
Field field = clazz.getDeclaredField("age");
//对私有字段的访问取消权限检查，暴力访问。
field.setAccessible(true);
Object obj = clazz.newInstance();
//为对象的属性赋值
field.set(obj,89);
//获取某对象的某属性值
Object o = field.get(obj);
System.out.println(field);
}
}

复制代码运行结果：person run
private int com.test.Person.age
黑马程序员——Java基础---反射

示例：获取Class中的方法

import cn.itcast.bean.Person;
import java.lang.reflect.Method;
import java.lang.reflect.Constructor;
public class ReflectDemo
{
public static void main(String[] args) throws Exception {
getMethodDemo_1();
System.out.println("---------------------------");
getMethodDemo_2();
System.out.println("---------------------------");
getMethodDemo_3();
}
/*
* 获取指定Class中的公共函数。
*/
public static void getMethodDemo_1() throws Exception {
Class clazz = Class.forName("cn.itcast.bean.Person");
Method[] methods = clazz.getMethods();//获取的都是公有的方法
methods = clazz.getDeclaredMethods();//只获取本类中所有方法，包括私有。
for(Method method : methods){
System.out.println(method);
}
}
public static void getMethodDemo_2() throws Exception {
Class clazz = Class.forName("cn.itcast.bean.Person");
Method method = clazz.getMethod("show",null);//获取空参数一般方法
Object obj = clazz.newInstance();
Constructor constructor = clazz.getConstructor(int.class,String.class);
obj = constructor.newInstance(37,"小明");
method.invoke(obj,null);
}
public static void getMethodDemo_3() throws Exception {
Class clazz = Class.forName("cn.itcast.bean.Person");
Method method = clazz.getMethod("paramMethod",String.class,int.class);//获取空参数一般方法
Object obj = clazz.newInstance();
Constructor constructor = clazz.getConstructor();
obj = constructor.newInstance();
method.invoke(obj,"小强",89);
}
}

复制代码运行结果： public void com.test.Person.show()
public void com.test.Person.paramMethod(java.lang.String,int)
private void com.test.Person.privateMethod()
public static void com.test.Person.staticMethod()
---------------------------
person run
Person param run...小明:37
小明...show run...37
---------------------------
person run
person run
paramMethod run...小强:89
黑马程序员——Java基础---反射

练习：反射练习

代码：

PCI.java

package cn.itcast.reflect.test;
public interface PCI
{
public void open();
public void close();
}

复制代码
SoundCard.java

package cn.itcast.reflect.test;
public class SoundCard implements PCI
{
public void open(){
System.out.println("sound open");
}
public void close(){
System.out.println("sound close");
}
}

复制代码
NetCard.java

package cn.itcast.reflect.test;
public class NetCard implements PCI
{
public void open(){
System.out.println("net open");
}
public void close(){
System.out.println("net close");
}
}

复制代码
Mainboard.java

package cn.itcast.reflect.test;
public class Mainboard
{
public void run(){
System.out.println("main board run...");
}
public void usePCI(PCI p){
if(p != null){
p.open();
p.close();
}
}
}

复制代码
pci.Properties

pci1=cn.itcast.reflect.test.SoundCard
pci2=cn.itcast.reflect.test.NetCard

复制代码
ReflectTest.java

package cn.itcast.reflect.test;
import java.io.File;
import java.io.FileInputStream;
import java.util.Properties;
/*
* 电脑运行
*/
public class ReflectTest
{
public static void main(String[] args) throws Exception {
Mainboard mb = new Mainboard();
mb.run();
//每次添加一个设备都需要修改代码传递一个新创建的对象
//mb.usePCI(new SoundCard());
//能不能不修改代码就可以完成这个动作
//不用new完成，而是只获取其class文件，在内部实现创建对象的动作。
File configFile = new File("pci.properties");
Properties prop = new Properties();
FileInputStream fis = new FileInputStream(configFile);
prop.load(fis);
for(int x = 0; x < prop.size(); x++){
String pciName = prop.getProperty("pci" + (x + 1));
Class clazz = Class.forName(pciName);//用Class去加载这个pci子类
PCI p = (PCI)clazz.newInstance();
mb.usePCI(p);
}
fis.close();
}
}

复制代码

秒客网

黑马程序员——Java基础---反射

相关文章