黑马程序员-反射

个人的理解，在不访问获得源码的情况下，可以根据字节码文件，对象来获取，修改这个类的方法，成员，专业的定义为程序可以访问，检测和修改它本身状态或行为的一种能力，并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。

反射机制中涉及的类
java.lang.Class;
java.lang.reflect.Constructor; java.lang.reflect.Field;
java.lang.reflect.Method;
java.lang.reflect.Modifier;

反射基石-Class类
Class 类：java 程序中各个类属于同一类事物，描述这类事物的 java 类 就是 Class 类。
1 该类没有构造方法（Contructor） ，不能直接 new 对象。

2 九个 预定义的 class 对象：
八种基本 数据类型有对应的 Class 对象， 另外 void 也有对应的 Class对象。（ Class cls=void.class; 这是正确的写法。 ）
3 数组类型的 Class 实例对象：Class.isArray();
4 只要在源程序中出现的类型，都有各自的 Class 实例对象。eg：int[]、void

主要方法：
forName() //返回类的字节码
getClass() //获取该类对象的字节码
Package getPackage() //获取该类的包名
String getName() //获取该类的名称
Menthod[] getMethods() //获取该类的方法列表
getInterfaces() // 获取该类的接口
Boolean isPrimitive() //判断是否是原始基本数据类型
Filed getField(String name) // 返回一个成员变量
Menthod getMethod() //获取该类的方法
newInstance() //创建此 Class 对象所表示的类的一个新实例。

forName() 作用 ： 得到 一个类的字节码
eg:

class  Reflect {
    String nameString="lisi";

    @Override
    public String toString() {
        return "a [nameString=" + nameString + "]";
    }


}
public class reflectiontest {   
    public static void main(String[]args) throws ClassNotFoundException, InstantiationException, IllegalAccessException{ 
        Class<?> clazz=Class.forName("com.itheima.Reflect");
        Reflect b=(Reflect) clazz.newInstance();//该方法只能获取空参的构造函数的对象
        System.out.print(b.toString());
    } }  

通过反射获取带参构造方法并使用

Class类的newInstance()方法是使用该类无参的构造函数创建对象, 如果一个类没有无参的构造函数, 就不能这样创建了,可以调用Class类的getConstructor(obj…..arg[]) 来获取 够构造器

class  Reflect {
    String nameString="lisi";
     int age;
     public Reflect(String name,int age) {
        // TODO Auto-generated constructor stub
      this.nameString=name;
      this.age=age;

     }
    @Override
    public String toString() {
        return "a [nameString=" + nameString + "]"+age;
    }


}
public class reflectiontest {   
    public static void main(String[]args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException{ 


        Class<?> clazz=Class.forName("com.itheima.Reflect");
        Constructor constructor=clazz.getConstructor(String.class,int.class);
        Reflect reflect=(Reflect) constructor.newInstance("shangsan",23);
       System.out.print(reflect.toString());
    } }

``Filed 类：代表某个类(字节码文件)中的一个成员变量。
Class.getField(String)方法可以获取类中的指定字段(可见的)

class Reflect {
String nameString=”lisi”;
int age;
public Reflect(String name,int age) {
// TODO Auto-generated constructor stub
this.nameString=name;
this.age=age;

 }
@Override
public String toString() {
    return "a [nameString=" + nameString + "]"+age;
}

}
public class reflectiontest {
public static void main(String[]args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException, NoSuchFieldException{
Class clazz=Class.forName(“com.itheima.Reflect”);
Constructor c=clazz.getConstructor(String.class,int.class);
Reflect reflect=(Reflect) c.newInstance(“zhangsan”,24);
Field field=clazz.getField(“age”);
field.set(reflect, 24);

     System.out.print(reflect.toString());



} }   

暴力反射    

getDeclaedField("name")方法获取,通过set(obj, "李四")方法可以设置指定对象上该字段的值, 如果是私有的需要先调用setAccessible(true)设置访问权限,用获取的指定的字段调用get(obj)可以获取指定对象中该字段的值

class Reflect {
private String nameString=”lisi”;
private int age;
public Reflect(String name,int age) {
// TODO Auto-generated constructor stub
this.nameString=name;
this.age=age;

 }
@Override
public String toString() {
    return "a [nameString=" + nameString + "]"+age;
}

}
public class reflectiontest {
public static void main(String[]args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException, NoSuchFieldException{
Class clazz=Class.forName(“com.itheima.Reflect”);
Constructor c=clazz.getConstructor(String.class,int.class);
Reflect reflect=(Reflect) c.newInstance(“zhangsan”,24);

    Field f = clazz.getDeclaredField("nameString");                     //暴力反射获取字段
    f.setAccessible(true);                                          //去除私有权限
    f.set(p, "李四"); 

     System.out.print(reflect.toString());


} }   

Method
Class.getMethod(String, Class...) 和 Class.getDeclaredMethod(String, Class...)方法可以获取类中的指定方法,调用invoke(Object, Object...)可以调用该方法,Class.getMethod("eat") invoke(obj) Class.getMethod("eat",int.class) invoke(obj,10)

public static void main(String[] args) throws Exception {
        Class clazz = Class.forName("com.heima.bean.Person");
        Constructor c = clazz.getConstructor(String.class,int.class);   //获取有参构造
        Person p = (Person) c.newInstance("张三",23);                     //通过有参构造创建对象

        Method m = clazz.getMethod("eat");                              //获取eat方法
        m.invoke(p);

        Method m2 = clazz.getMethod("eat", int.class);                  //获取有参的eat方法
        m2.invoke(p, 10);
    }



_反射(练习)
(1) 写一个Properties格式的配置文件，配置类的完整名称。
(2) 写一个程序，读取这个Properties配置文件，获得类的完整名称并加载这个类，用反射的方式运行run方法

public static void main(String[] args) throws Exception {
Juicer j = new Juicer(); //创建榨汁机
//j.run(new Apple());
//j.run(new Orange());
BufferedReader br = new BufferedReader(new FileReader(“config.properties”));
Class clazz = Class.forName(br.readLine()); //获取该类的字节码文件
Fruit f = (Fruit) clazz.newInstance(); //创建实例对象
j.run(f);
}
}
interface Fruit {
public void squeeze();
}
class Apple implements Fruit {
public void squeeze() {
System.out.println(“榨出一杯苹果汁儿”);
}
}

class Orange implements Fruit {
public void squeeze() {
System.out.println(“榨出一杯橘子汁儿”);
}
}

class Juicer {
/*public void run(Apple a) {
a.squeeze();
}

public void run(Orange o) {
    o.squeeze();
}*/

public void run(Fruit f) {
    f.squeeze();
}

}
“`