------- android培训、java培训、iOS培训、.Net培训期待与您交流！ ----------
类的加载
当程序要使用某个类时如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。
类初始化时机
创建类的实例
访问类的静态变量，或者为静态变量赋值
调用类的静态方法
使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
初始化某个类的子类
直接使用java.exe命令来运行某个主类
类加载器
负责将.class文件加载到内存中，并为之生成对应的Class对象
虽然我们不需要关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行
类加载器的组成
Bootstrap ClassLoader根类加载器、Extension ClassLoader扩展类加载器、System ClassLoader系统类加载器
反射
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对应任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调节对象的方法的功能称为java语言的反射机制。
要想解剖一个类，必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法，所以先要获取到每一个字节码文件对应的Class类型的对象
就是通过class文件对象，去使用该文件中的成员变量、构造方法、成员方法
要想这样使用，首先必须得到class文件对象，其实也就是得到Class类的对象
Class类：
成员变量 Field
构造方法 Constructor
成员方法 Method
获取class文件对象的方式：
一、Object类的getClass()方法
Person p1=new Person();
Class c1=p1.getClass();
二、数据类型的静态属性class
Class c2=Person.class;
三、Class类中的静态方法 ：public static Class forName(String className)
Class c3=Class.forName("Person");
注：要写类名的全路径（带包名的）
开发时用第三种，因为第三种是一个字符串，而不是一个具体的类名，这样我们就可以把这样的字符串配置到配置文件中
以下都以Person类为例：
class Person
{
private String name;
int age;
public String address;
public Person()
{
}
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+"]";
}
}通过反射获取构造方法并使用
public Constructor[] getConstructors():获取所有公共构造方法
public Constructor[] getDeclaredConstructors():所有构造方法
public Constructor getConstructor(Class... parameterTypes):获取单个构造方法
...表示可传参数也可不传
参数表示的是：你要获取的构造方法的构造参数个数及数据类型的class字节码文件对象
public T newInstance(Object... initargs)
使用此Constructor对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例
public Constructor getConstructor(Class... parameterTypes):获取带参构造方法对象
暴力访问
con.setAccessible(true);//值为true则指示反射的对象在使用时应该取消JAVA语言访问检查
import java.lang.reflect.Constructor;
class ReflectDemo
{
public static void main(String[] args) throws Exception
{
//获取字节码文件对象
Class c=Class.forName("Person");
//Constructor[] cons=c.getConstructors();
//Constructor[] cons=c.getDeclaredConstructors();
//for(Constructor con : cons)
//{
// System.out.println(con);
//}
Constructor con=c.getConstructor();//返回的是构造方法对象
Object obj=con.newInstance();
System.out.println(obj);//底层调用toString方法
}
}/*
需求：<strong>通过反射去获取该构造方法并使用</strong>：public Person(String name,int age,String address)
*/
import java.lang.reflect.Constructor;
class ReflectDemo
{
public static void main(String[] args) throws Exception
{
//获取字节码文件对象
Class c=Class.forName("Person");
Constructor con=c.getConstructor(String.class,int.class,String.class);
Object obj=con.newInstance("张三",29,"北京");
System.out.println(obj);
}
}/*
需求：<strong>通过反射获取私有构造方法并使用</strong>：private Person(String name){}
*/
import java.lang.reflect.Constructor;
class ReflectDemo
{
public static void main(String[] args) throws Exception
{
//获取字节码文件对象
Class c=Class.forName("Person");
//获取私有构造方法对象
//会报异常：NoSuchMethodException 没有这个方法异常
//原因是一开始我们使用的方法只能获取公共的
//Constructor con=c.getConstructor(String.class);
//用该私有构造方法创建对象
//也会报异常：IllegalAccessException 非法的访问异常
Constructor con=c.getDeclaredConstructor(String.class);
//暴力访问
con.setAccessible(true);
//通过私有构造方法对象创建对象
Object obj=con.newInstance("张三");
System.out.println(obj);
}
}通过反射获取成员变量并使用
获取所有成员：getFields 、getDeclaredFields
获取单个成员：getField 、getDeclaredField
修改成员变量的值：set(Object obj,Object value)
将指定对象变量上此Field对象表示的字段设置为指定的新值
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
class ReflectDemo
{
public static void main(String[] args) throws Exception
{
//获取字节码文件对象
Class c=Class.forName("Person");
//获取公共成员变量
//Field[] fields=c.getFields();
//获取所有成员变量
//Field[] fields=c.getDeclaredFields();
//for(Field field : fields)
//{
// System.out.println(field);
// }
//通过无参构造方法创建对象
Constructor con=c.getConstructor();
Object obj=con.newInstance();
System.out.println(obj);
//获取单个的成员变量：获取address并对其赋值
Field addressField=c.getField("address");
//public void set(Object obj,Object value);
//将指定对象变量上此Field对象表示的字段设置为指定的新值
addressField.set(obj,"北京");//给obj对象的addressField字段设置值为“北京”
System.out.println(obj);
//获取name（私有）并对其赋值
Field nameField=c.getDeclaredField("name");
nameField.setAccessible(true);//暴力访问
nameField.set(obj,"张三");
System.out.println(obj);
//获取age并对其赋值（不管私不私有，这样写都能访问）
Field ageField=c.getDeclaredField("age");
ageField.setAccessible(true);//暴力访问
ageField.set(obj,27);
System.out.println(obj);
}
}
通过反射获取成员方法并使用
获取所有方法：getMethods 、getDeclaredMethods
获取单个方法：getMethod 、getDeclaredMethod
暴力访问：method.setAccessible(true);
import java.lang.reflect.Method;
import java.lang.reflect.Constructor;
class ReflectDemo
{
public static void main(String[] args) throws Exception
{
//获取字节码文件对象
Class c=Class.forName("Person");
/*
//获取公共成员方法 <strong>特殊之处</strong>：获取自己的包括父亲的公共方法
//Method[] methods=c.getMethods();
//获取所有成员方法 <strong> 特殊之处</strong>：这里只获取自己的所有方法，不包括父亲的
Method[] methods=c.getDeclaredMethods();
for(Method method :methods)
{
System.out.println(method);
}
*/
//通过无参构造方法创建对象
Constructor con=c.getConstructor();
Object obj=con.newInstance();
//获取单个方法并使用：public void show()
//public Method getMethod(String name,class... parameterTypes)
//第一个参数表示的是方法名，第二个参数表示的是方法的参数的class类型
Method m1=c.getMethod("show");
//public Object invoke(Object obj,Object...args)
//返回值是Object接收，第一个参数表示对象是谁，第二个参数表示调用该方法的实际参数
m1.invoke(obj);//调用obj对象的m1方法（Person对象的show方法）
}
}
import java.lang.reflect.Method;
import java.lang.reflect.Constructor;
class ReflectDemo
{
public static void main(String[] args) throws Exception
{
//获取字节码文件对象
Class c=Class.forName("Person");
//通过无参构造方法创建对象
Constructor con=c.getConstructor();
Object obj=con.newInstance();
//需求：获取方法：public void method(String s)
//public Method getMethod(String name,class... parameterTypes)
//第一个参数表示的是方法名，第二个参数表示的是方法的参数的class类型
Method m1=c.getMethod("method",String.class);
//public Object invoke(Object obj,Object...args)
//返回值是Object接收，第一个参数表示对象是谁，第二个参数表示调用该方法的实际参数
m1.invoke(obj,"hello");
//需求：获取方法：public String getString(String s,int i)
Method m2=c.getMethod("getString",String.class,int.class);
Object objString=m2.invoke(obj,"hello",100);
System.out.println(objString);
}
}
动态代理
代理：本来应该自己做的事情，却请了别人来做，被请的人就是代理对象
动态代理：在程序运行过程中产生的这个对象，动态代理其实就是通过反射来生成一个代理
在JAVA中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理，更强大的代理cglib
Proxy类中的方法创建动态代理类对象
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
最终会调用InvocationHandler的方法
InocationHandler
Object invoke(Object proxy,Method method,Object[] args)
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
class MyInvocationHandler implements InvocationHandler
{
private Object target;//目标对象
MyInvocationHandler(Object target)
{
this.target=target;
}
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable
{
System.out.println("权限校验");
Object result=method.invoke(target,args);
System.out.println("日志记录");
return result;//返回的是代理对象
}
}import java.lang.reflect.Proxy;
class Test
{
public static void main(String[] args)
{
//我们要创建一个动态代理对象
//Proxy类中有一个方法可以创建动态代理对象
//public static Object newProxyInstance(ClassLoader loader,Class[] interfaces,
//InvocationHandler h)
//返回值Object返回的其实就是动态代理对象
//我准备对ud对象做一个代理对象
MyInvocationHandler handler=new MyInvocationHandler(ud);//想让谁当代理对象就传谁
UserDao proxy=(UserDao)Proxy.newProxyInstance(ud.getClass().getClassLoader(),
ud.getClass().getInterfaces(),handler);
proxy.add();
proxy.delete();
proxy.update();
proxy.find();
System.out.println("---------");
StudentDao sd=new StudentDaoImpl();
MyInvocationHandler handler2=new MyInvocationHandler(sd);//想让谁当代理对象就传谁
StudentDao proxy2=(StudentDao)Proxy.newProxyInstance(sd.getClass().getClassLoader(),
sd.getClass().getInterfaces(),handler2);
proxy2.login();
proxy2.regist();
}
}
376
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
