黑马程序员—Java基础—类的加载和反射

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------ 

类的加载和反射

类的加载：当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。

加载

就是指将class文件读入内存，并为之创建一个Class对象。

任何类被使用时系统都会建立一个Class对象。

连接

  验证 是否有正确的内部结构，并和其他类协调一致

准备 负责为类的静态成员分配内存，并设置默认初始化值

解析 将类的二进制数据中的符号引用替换为直接引用

初始化初始化步骤

类加载器的组成

BootstrapClassLoader 根类加载器

        也被称为引导类加载器，负责Java核心类的加载比如System,String等。在JDK中JRE的lib目录下rt.jar文件中

ExtensionClassLoader 扩展类加载器

负责JRE的扩展目录中jar包的加载。在JDK中JRE的lib目录下ext目录

SysetmClassLoader 系统类加载器

负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径 

反射

反射概念：

反射：JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制，简单记，就是通过class文件对象，去使用该文件中的成员变量，构造方法，成员方法。

反射的好处：大大的增强了程序的扩展性。

反射的基本步骤：

1、获得Class对象，就是获取到指定的名称的字节码文件对象。

2、实例化对象，获得类的属性、方法或构造函数。

3、访问属性、调用方法、调用构造函数创建对象。

获取Class对象：

获取字节码文件的三种方式：

方式一：Object类的getClass()方法

方式二：数据类型的静态属性class

方式三：Class类中的静态方法
public static Class forName(String className)

代码：

 获取字节码文件的三种方式 23行 Java

Raw

  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

public class ReflectDemo {
public static void main(String[] args) throws ClassNotFoundException {
// 方式1
Person p = new Person();
Class c = p.getClass();

Person p2 = new Person();
Class c2 = p2.getClass();

System.out.println(p == p2);// false
System.out.println(c == c2);// true

// 方式2
Class c3 = Person.class;
// int.class;
// String.class;
System.out.println(c == c3);

// 方式3
Class c4 = Class.forName("cn.itcast_01.Person");
System.out.println(c == c4);
}
}

注意：方式三分法的参数是该类的带包路径，如果书写不正确，会报ClassNotFoundException异常。

实例化对象，获得类的属性、方法或构造函数。

获取构造方法(Class类的方法)
public Constructor[] getConstructors():所有公共构造方法
public Constructor[] getDeclaredConstructors():所有构造方法
public Constructor<T> getConstructor(Class<?>... parameterTypes)：获取单个公共构造方法

public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)：获取任意单个构造方法

注意这里的参数是Class对象，是该构造方法参数的字节码文件对象。

创建对象(Constructor的方法)

public TnewInstance(Object... initargs)   

使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。

代码：

 通过反射获取构造方法并使用 32行 Java

Raw

  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

import java.lang.reflect.Constructor;

/*
 * 需求：通过反射去获取该构造方法并使用：
 */
public class ReflectDemo2 {
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Person.class;

// 获取带参构造方法对象
// public Constructor<T> getConstructor(Class<?>... parameterTypes)
Constructor con = c.getConstructor(String.class, int.class,
String.class);

// 通过带参构造方法对象创建对象
// public T newInstance(Object... initargs)
Object obj = con.newInstance("林青霞", 27, "北京");
System.out.println(obj);
}
}
class Person{
    public String name;
    public int age;
    public String address;
    public Person(String name;int age;String address){
        this.name=name;
        this.age=age;
        this.address=address;
    }
}

获取所有成员(Class类的方法)

public Field[] getFields()获取所有公共成员变量
public Field[] getDeclaredFields获取所有成员变量
public Field getField(String name)获取单个公共成员变量
public Field getDeclaredField(String name)获取单个成员变量

修改成员的值(Field的方法)

public void set(Object obj, Object value) 将指定对象变量上此 Field 对象表示的字段设置为指定的新值

反射获取成员方法(Class类的方法)

public Method getMethod(String name, Class<?>... parameterTypes)获取单个公共成员方法
public Method[] getMethods()获取所有公共成员方法
public Field getDeclaredField(String name)获取单个成员方法
public Field[] getDeclaredFields()获取所有成员方法

调用成员方法(Method的方法)

public Object invoke(Object obj, Object... args) 对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。

暴力访问(Constructor、Field、Method都有的方法)
setAccessible(true)

代码：

 反射步骤练习 65行 Java

Raw

  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class ReflectDemo {
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Person.class;

Constructor con = c.getConstructor();
Object obj = con.newInstance();

Method m1 = c.getMethod("show");
m1.invoke(obj);
System.out.println("----------");
Method m2 = c.getMethod("method", String.class);
m2.invoke(obj, "hello");
System.out.println("----------");

Method m3 = c.getMethod("getString", String.class, int.class);
Object objString = m3.invoke(obj, "hello", 100);
System.out.println(objString);
// private void function()
Method m4 = c.getDeclaredMethod("function");
m4.setAccessible(true);
m4.invoke(obj);
}
}
class Person {
private String name;
int age;
public String address;
public Person() {
}
private Person(String name) {
this.name = name;
}
Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person(String name, int age, String address) {
this.name = name;
this.age = age;
this.address = address;
}
public void show() {
System.out.println("show");
}
public void method(String s) {
System.out.println("method " + s);
}
public String getString(String s, int i) {
return s + "---" + i;
}
private void function() {
System.out.println("function");
}
public String toString() {
return "Person [name=" + name + ", age=" + age + ", address=" + address
+ "]";
}

}

反射练习：

Test1:Integer泛型的ArrayList添加字符串

思路：

1、获取ArrayList的字节码文件对象

2、通过字节码文件对象获取成员方法add(Object obj);

3、通过Method类的invoke()方法添加字符串

代码：

 Integer泛型的ArrayList添加字符串 22行 Java

Raw

  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;

/*
 * Integer泛型ArraList中存储字符串
 */
public class Test1 {
public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
//定义Integer泛型的ArrayList
ArrayList<Integer> list = new ArrayList<Integer>();
//获取list的字节码文件对象
Class c=list.getClass();
//获取成员方法
Method method=c.getDeclaredMethod("add",Object.class);
//取消权限访问，暴力访问
method.setAccessible(true);
//添加字符串
method.invoke(list, "hello");
System.out.println(list);
}
}

Test2:写一个方法，public void setProperty(Object obj, String propertyName, Object value){}，
此方法可将obj对象中名为propertyName的属性的值设置为value。

思路：

1、获取obj的Class对象

2、获取成员变量propertyName

3、设置其值为vlaue

代码：

 反射练习2 23行 Java

Raw

  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

import java.lang.reflect.Field;

public class Test3 {
public static void main(String[] args)throws Exception {
//创建Person类对象
Person p=new Person();
//调用方法设置其指定property值为vlaue
setProperty(p,"name","陈奕迅");
System.out.println(p.name);
}
//符合要求的方法
public static void setProperty(Object obj,String property,Object value)throws Exception{
Class c=obj.getClass();
Field field=c.getDeclaredField(property);
field.setAccessible(true);
field.set(obj,value);
}
}
//类
class Person{
String name;
int age;
}

注意：一定要注意Class、Constructor、Field、Method各个方法的参数及返回值类型，否则很容易报错，注意抛出异常问题。

动态代理

动态代理的概念：

动态代理
代理：本来应该自己做的事情，却请了别人来做，被请的人就是代理对象。
动态代理：在程序运行过程中产生的这个对象
动态代理其实就是通过反射来生成一个代理

在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理。
Proxy类中的方法创建动态代理类对象
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
最终会调用InvocationHandler的方法
InvocationHandler
Object invoke(Object proxy,Method method,Object[] args)

代码：

 动态代理 45行 Java

Raw

  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

interface StudentDao {
public abstract void login();
public abstract void regist();
}
class StudentDaoImpl implements StudentDao {
public void login() {
System.out.println("学生登录");
}
public void regist() {
System.out.println("学生注册");
}

}

class MyInvocationHandler implements InvocationHandler {
private Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
//Object invoke(Object proxy, Method method, Object[] args) 
//在代理实例上处理方法调用并返回结果
System.out.println("权限校验");
Object result=method.invoke(target,args);
System.out.println("日志记录");
return result;
}
}
public class DaiLiTest {
public static void main(String[] args) {
StudentDao sd=new StudentDaoImpl();
MyInvocationHandler handler=new MyInvocationHandler(sd);
Object obj=Proxy.newProxyInstance(sd.getClass().getClassLoader(), 
sd.getClass().getInterfaces(), handler);
StudentDao s=(StudentDao) obj;
s.regist();
s.login();
}
}

注：Proxy类中创建动态代理对象的方法的三个参数；
ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上
InvocationHandler接口中invoke方法的三个参数：
proxy:代表动态代理对象
method:代表正在执行的方法
args:代表调用目标方法时传入的实参

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------