黑马程序员——反射

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、类的加载

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

1、加载 

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

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

2、连接

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

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

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

3、初始化

 

二、类的初始化

1、创建类的实例

2、访问类的静态变量，或者为静态变量赋值

3、调用类的静态方法

4、使用反射方式来强制创建某个类或接口对应的java.lang.Class对象

5、初始化某个类的子类

6、直接使用java.exe命令来运行某个主类

 

三、类加载器

1、类加载器

负责将.class文件加载到内存中，并为之生成对应的Class对象。

2、类加载器的组成

A、Bootstrap ClassLoader 根类加载器

也被称为引导类加载器，负责Java核心类的加载

比如System,String等。在JDK中JRE的lib目录下rt.jar文件中

B、Extension ClassLoader 扩展类加载器

负责JRE的扩展目录中jar包的加载。

在JDK中JRE的lib目录下ext目录

C、Sysetm ClassLoader 系统类加载器

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

 

四、反射

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.

1、三种获取字节码文件对象的方式

方式1: 通过对象获取字节码文件对象

Person p = new Person();

Class c = p.getClass();

方式2: 通过静态属性class获取字节码文件对象

Class c2 = Person.class;

任意数据类型都具备一个class静态属性,比第一种方式简单.

方式3:将类名作为字符串传递给Class类中的静态方法forName

Class c3 = Class.forName("Person");

注意：类名必须写全

2、获取字节码对象成员

A、获取构造方法

public Constructor<T> getConstructor(Class<?>... parameterTypes)throws NoSuchMethodException, SecurityException

public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) throws NoSuchMethodException,SecurityException

B、创建对象

public T newInstance() throws InstantiationException,IllegalAccessException

3、获取成员

获取所有成员

getFields

getDeclaredFields

获取单个成员

getField

getDeclaredField

修改成员的值

public void set(Object obj,Object value) throws IllegalArgumentException, IllegalAccessException

将指定对象变量上此 Field 对象表示的字段设置为指定的新值。

4、获取普通方法

获取所有方法

getMethods

getDeclaredMethods

获取单个方法

getMethod

getDeclaredMethod

暴力访问

method.setAccessible(true);

5、代码体现：

package clazz.clazz;

public class Person {
	private int age;
	String name;
	String sex;
	
	public Person() {
		super();
	}
	public Person(int age) {
		super();
		this.age = age;
	}
	public Person(String name, String sex) {
		super();
		this.name = name;
		this.sex = sex;
	}
	public Person(int age, String name, String sex) {
		super();
		this.age = age;
		this.name = name;
		this.sex = sex;
	}
	
	public void method(){
		System.out.println("public method");
	}
	void method2(){
		System.out.println("default method");
	}
	private void method3(String str){
		System.out.println("private method"+str);
	}
	public void method(int number){
		System.out.println("public method"+number);
	}
	
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	@Override
	public String toString() {
		return "Person [age=" + age + ", name=" + name + ", sex=" + sex + "]";
	}
}


package clazz.clazz;

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

public class MyClass {

	public static void main(String[] args) throws Exception {
		//1、使用第二种方式获取字节码文件对象
		Class<Person> clazz = Person.class;
		//2、反射其构造方法
		Constructor<Person> constructor = clazz.getConstructor(int.class,String.class,String.class);
		//3、通过反射方式，完成创建对象
		Person newInstance = constructor.newInstance(23,"Bruce","男");
		//4、获取成员变量的值
		int age = newInstance.getAge();
		System.out.println(age);
		//反射普通方法的对象的数组
		Method[] methods = clazz.getMethods();
		//获取具体的普通方法对象
		Method method = clazz.getMethod("method");
		//调用普通方法对象的方法，完成普通方法的调用
		method.invoke(newInstance);
		//有参的普通方法
		Method method2 = clazz.getDeclaredMethod("method3", String.class);
		method2.setAccessible(true);
		method2.invoke(newInstance, ":Bruce Lee");
		//反射字段(成员变量)
		Field declaredField = clazz.getDeclaredField("age");
		//public void setAccessible(boolean flag)throws SecurityException
		//将对应的组件设置成可访问，不检查权限。这样的操作叫暴力反射！
		declaredField.setAccessible(true);
		declaredField.set(newInstance, 34);
		System.out.println(newInstance);
	}
}

 

6、反射绕过泛型检查

通过配置文件运行类中的方法

绕过ArrayList<Integer>的一个对象的泛型检查，在这个集合中添加一个字符串数据。只需要将add方法使用反射的方式调用即可。

原因：泛型检查存在擦除泛型的动作(即编译器认识泛型，而虚拟机不认识泛型)，真正在运行时，仍然是泛型位置使用的是Object。

代码体现：

package cn.itcast;

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

public class Test {
	public static void main(String[] args) throws Exception {
		ArrayList<Integer> arrayList = new ArrayList<Integer>();
		arrayList.add(10);
		//arrayList.add("abc");
		
		//使用反射，将add方法反射
		Class clazz = arrayList.getClass();
		
		Method declaredMethod = clazz.getDeclaredMethod("add", Object.class);
		declaredMethod.invoke(arrayList, 10);
		declaredMethod.invoke(arrayList, "abc");
		
		System.out.println(arrayList);
	}
}

 

6、动态代理

A、代理：本来应该自己做的事情，却请了别人来做，被请的人就是代理对象。

如：春季回家买票让人代买

B、动态代理：在程序运行过程中产生的这个对象，即就是通过反射来生成一个代理

C、在代理过程中，可以在本类基础上添加新的功能，使其功能更强大

D、在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理。

E、Proxy类中的方法创建动态代理类对象

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)

最终会调用InvocationHandler的方法

F、InvocationHandler

Object invoke(Object proxy,Method method,Object[] args)

G、代码体现：

package clazz.clazz;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/*
public static Object newProxyInstance(ClassLoader loader,	loader - 定义代理类的类加载器
                                      Class<?>[] interfaces,		interfaces - 代理类要实现的接口列表
                                      InvocationHandler h)		h - 指派方法调用的调用处理程序
                               throws IllegalArgumentException
*/
public class ProxyAndInvocationHandler {

	public static void main(String[] args) {
		//创建被代理的对象
		MyProxyClass mpc = new MyProxyClass();
		//创建InvocationHandler对象，负责具体的代理 执行
		MyHandler mh = new MyHandler(mpc);
		//创建代理对象，将代理对象转成被代理对象的类型
		MyInterface newProxyInstance = (MyInterface)Proxy.newProxyInstance(
				mpc.getClass().getClassLoader(), mpc.getClass().getInterfaces(), mh);
		//代理对象    代理    被代理对象    执行的方法
		newProxyInstance.eat();
		int sleep = newProxyInstance.sleep(8);
		System.out.println(sleep);
	}
}
//定义一个类，实现InvocationHandler接口
class MyHandler implements InvocationHandler{
	
	//传入具体执行的被代理的对象
	MyInterface mi;
	public MyHandler(MyInterface mi) {
		super();
		this.mi = mi;
	}
/*
Object invoke(Object proxy,		proxy - 在其上调用方法的代理实例
              Method method,		method - 对应于在代理实例上调用的接口方法的 Method 实例
              Object[] args)		args - 包含传入代理实例上方法调用的参数值的对象数组，如果接口方法不使用参数，则为 null
              throws Throwable
*/
	//method：动态代理的那个方法
	//args：方法的参数
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		System.out.println("加强的功能");
		Object result = method.invoke(mi,args);
		return result;
	}
}
//定义一个类，实现MyInterface
class MyProxyClass implements MyInterface {
	@Override
	public void eat() {
		System.out.println("EAT EAT");
	}
	@Override
	public int sleep(int number) {
		System.out.println("SLEEP SLEEP");
		return  number;
	}
}
//定义一个接口
interface MyInterface {
	public abstract void eat();
	public abstract int sleep(int number);
}

 

五、设计模式

1、设计模式概述：

设计模式这个术语是由Erich Gamma等人在1990年代从建筑设计领域引入到计算机科学的。它是对软件设计中普遍存在（反复出现）的各种问题，所提出的解决方案。

设计模式并不直接用来完成代码的编写，而是描述在各种不同情况下，要怎么解决问题的一种方案。面向对象设计模式通常以类或对象来描述其中的关系和相互作用，但不涉及用来完成应用程序的特定类或对象。设计模式能使不稳定依赖于相对稳定、具体依赖于相对抽象，避免会引起麻烦的紧耦合，以增强软件设计面对并适应变化的能力。

2、设计模式分类：

创建型模式，共五种：

工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：

适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：

策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

3、目前遇到过的设计模式

(1)、单例设计模式

在整个应用中有且仅有一个实例对象

典型案例：RunTime

(2)、适配器设计模式

将一个类的接口根据用户的需求，适配成便于使用的类/抽象类

典型案例：GUI监听器

(3)、装饰设计模式

添加一个修饰类包裹原来的类，在运行时便可以扩充其新的功能

典型案例：高效缓冲IO流

(4)、工厂设计模式

使用工厂创建某些类的实例对象，从而取代之前自身调用构造new的操作

典型案例：线程池

(5)、模板设计模式

将一个完整功能分隔成不同步骤，对多个实现类共同的操作使用具体的实现，对多个类的差异操作使用抽象

 

六、instanceof关键字

用于判断某个对象所属类型

格式：

对象   instanceof   类名

返回值为布尔值

注意：

可以判断是否为本身类型

可以判断是否为父类型