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

最新推荐文章于 2015-11-30 22:54:00 发布

okili

最新推荐文章于 2015-11-30 22:54:00 发布

阅读量324

点赞数

本文链接：https://blog.csdn.net/okili/article/details/28641135

版权

---------------------- android培训、 java培训、期待与您交流！ ----------------------

1、反射机制：

框架的底层是反射，

用于描述字节码文件的类名称是Class;

只要获取到字节码文件对象，就可以获取该字节码中所有的内容。

这就是动态的获取类中的内容并使用。

开发的时候不要抛大异常--有什么异常抛什么异常，能解决解决。

2、反射机制：对一个类进行动态的获取并创建对象，并调用该类中的内容。

* 获取字节码文件对象的方式。

* 方式一：

* 使用Object类中的getClass方法。

* 该方式必须先创建未知类的对象(如果能创建对象，何必获取字节码)，在调用getClass方法。

* 方式二：

* 使用静态的class属性就可以获取。

* 该方式还是需要使用未知的类。

* 方式三：

* 通过Class类中的静态方法 forName(className)完成;

* 爽！只要通过类名就可以获取到对应的字节码文件对象。

* 这种方式的扩展性是最好的。

package cn.itcast.reflect.demo;
import cn.itcast.bean.Person;
public class ReflectDemo {
/**
* @param args
* @throws ClassNotFoundException
*/
public static void main(String[] args) throws ClassNotFoundException {
getClassDemo_3();
}
//方式三
public static void getClassDemo_3() throws ClassNotFoundException{
String className = "cn.itcast.bean.Person";    //用的是字符串，不涉及导包不到包
/*
* forName:
* 1，根据传入的类的名称，自动去classPath路径(eclipse配的)下去找寻与该名称相同的类文件。
* 2，通过 类加载器将该类进行加载，并在内存中生成该类的字节码文件对象。
*/
Class clazz = Class.forName(className);
System.out.println(clazz);// class cn.itcast.been.Person
}
//方式二。
public static void getClassDemo_2() {
Class clazz = Person.class;     //每一种数据类型都有静态的class属性，对应的Class类型的对象
Class clazz1 = int.class;
}
//方式一。
public static void getClassDemo_1(){
Person p1 = new Person();
Person p2 = new Person();
Class clazz1 = p1.getClass();
Class clazz2 = p2.getClass();
System.out.println(clazz1 == clazz2);
}
}

3、反射字段。

* 获取指定类中的指定名称的字段。

* 思路：

* 1，通过类名获取字节码文件对象。

* 2，通过字节码文件对象获取其中的成员字段。

package cn.itcast.reflect.demo.field;
import java.lang.reflect.Field;
public class ReflectFieldDemo {
/**
* @param args
* @throws ClassNotFoundException
* @throws RuntimeException
* @throws NoSuchFieldException
*/
public static void main(String[] args) throws Exception {
getFieldDemo();
}
public static void getFieldDemo() throws ClassNotFoundException, NoSuchFieldException, SecurityException, InstantiationException, IllegalAccessException{
String className = "cn.itcast.bean.Person";  // 参数从配置文件里来的
//1，获取字节码文件对象。
Class clazz = Class.forName(className);
//2,通过Class对象的方法获取字段。
//      Field field = clazz.getField("age");   //该方法只能访问公有的。
Field field = clazz.getDeclaredField("age");    //可以访问已声明的字段。包括私有。
//      System.out.println(field);//  private cn.itcast.bean.Person.age
//      Person p = new Person();
//      p.age = 20;    //  不用反射 设置字段
//      System.out.println(p.age);
//要想对指定属性进行值的设置。必须要先有指定类的对象。
//对象如何创建呢？没法儿new啊？对象都来自于字节码文件。已经有了字节码文件，获取其对象还远吗？不远！
Object obj = clazz.newInstance();
//取消权限检查。
field.setAccessible(true);    //暴力访问--对私有的访问。一般情况不建议;可通过get,set方法访问。
//对字段进行值的设置，需要使用字段对象来完成。
field.set(obj, 30);
System.out.println(field.get(obj));   // 30
//      System.out.println(clazz.getName());  //cn.itcast.bean.Person
}
}

4、反射构造函数。

之前是通过newInstance进行指定的类的实例化。但是该类中如果没有空参数构造函数呢？

或者想通过指定的构造函数进行该类的对象实例化呢？咋办？

* 1，必须先要获取指定的构造函数。

* 2，通过获取到的构造函数对对象进行初始化。

package cn.itcast.reflect.demo.constructor;
import java.lang.reflect.Constructor;
public class ReflectConstructDemo {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
getConstructorDemo();
}
/*
*    22  反射构造函数。
*/
public static void getConstructorDemo() throws ClassNotFoundException, NoSuchMethodException, Exception{
String className = "cn.itcast.bean.Person";
Class clazz = Class.forName(className);

//      Person p = new Person("lisi",20);
//1,如何获取构造函数呢？通过Class对象。
Constructor constructor = clazz.getConstructor(String.class,int.class);
//2,如何初始化，构造器最清楚。
Object obj = constructor.newInstance("lisi",20);//如果传基本数据类型，就会自动装箱

}
}

package cn.itcast.bean;
public class Person {
private String name;
private int age;
public Person() {
super();
System.out.println("person run");     // 检验是否运行
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
System.out.println(this.name+":::"+this.age);
}
/*
* 公有的空参数方法。
*/
public void show(){
System.out.println("Person show run");
}
/*
* 公有，带参数的方法。
*
*/
public void show2(String str,int num){
System.out.println(str+":::"+num);
}
/*
* 获取静态方法。
*/
public static void show3(){
System.out.println("Person static show3 run");
}
/*
* 练习：
*/
private void show4(){
System.out.println(this.name+"::::::"+this.age);    //wangcai:::::20
}
}

5、反射函数：

package cn.itcast.reflect.demo.method;
import java.lang.reflect.Method;
import cn.itcast.bean.Person;
public class ReflectMethodDemo {
public static void main(String[] args) throws Exception {
getMethodDemo3();

}       // 反射函数
/*
* 3 获取公有静态的空参数函数。
*/
public static void getMethodDemo3() throws Exception{
String className = "cn.itcast.bean.Person";
Class clazz = Class.forName(className);
Method method = clazz.getMethod("show3", null);
method.invoke(null, null);
}
/*
* 2获取公有，带参数的函数。
*/
public static void getMethodDemo2() throws Exception{
String className = "cn.itcast.bean.Person";
Class clazz = Class.forName(className);

Method method = clazz.getMethod("show2", String.class,int.class);
Object obj = clazz.newInstance();
method.invoke(obj, "wangwu",32);
}
/*
* 1获取方法。获取公有，空参数的函数。
*/
public static void getMethodDemo() throws Exception{

String className = "cn.itcast.bean.Person";
Class clazz = Class.forName(className);
//获取指定类中的指定方法。
Method method = clazz.getMethod("show", null);// 调用Person的show
//      System.out.println(method);
/*
* 让方法运行起来。
*/
//      Person p = new Person();
//      p.show();
//获取指定类的对象。
Object obj = clazz.newInstance();
//调用方法对象的invoke方法。
method.invoke(obj,null);
}
}