写在前面：Java基础系列文章
Java基础要点笔记1（尚硅谷）
Java基础要点笔记2面向对象（尚硅谷）
Java编程之多线程
Java编程之常用类
Java编程之枚举类&注解
Java编程之Java集合
Java编程之泛型
Java编程之IO流
Java编程之网络编程
Java编程之反射机制
Java编程之Java8&9&10&11新特性
十大排序算法
关于设计模式
Java基础
- 写在前面：Java基础系列文章
- 一、Java反射机制概述
- 二、理解Class类并获取Class实例（重点）
-
- 2.1 理解Class类
- 2.2 获取Class的实例的方式
- 2.3 实例
- 三、类的加载过程与ClassLoader的理解
- 四、创建运行时类的对象（掌握）
- 五、获取运行时类的完整结构(了解)
- 六、调用运行时类的指定结构（重点）
- 七、反射的应用：动态代理（重点）
-
- 7.1 静态代理
- 7.2 动态代理
一、Java反射机制概述
二、理解Class类并获取Class实例（重点）
2.1 理解Class类
Class实例就对应着一个运行时的类。
加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式来获取此运行时类。
2.2 获取Class的实例的方式
public void test3(){
// 方式一：调用运行时类的属性：.class
Class<Person> clazz1 = Person.class ; // 可以加上泛型，也可以不加
System.out.println(clazz1); // class com.atguigu.java.Person
// 方式二：通过运行时类的对象,调用getClass()方法
Person p1 = new Person() ;
Class clazz2 = p1.getClass() ;
System.out.println(clazz2); // class com.atguigu.java.Person
// 方式三：调用class的静态方法：forName(String classpath) （用的较多）
Class clazz3 = Class.forName("com.atguigu.java.Person") ;
System.out.println(clazz3); // class com.atguigu.java.Person
System.out.println(clazz1 == clazz2); // true
System.out.println(clazz1 == clazz3); // true
// 方式四：使用类的加载器：ClassLoader (了解)
ClassLoader classLoader = ReflectionTest.class.getClassLoader() ;
Class clazz4 = classLoader.loadClass("com.atguigu.java.Person") ;
System.out.println(clazz4); // class com.atguigu.java.Person
System.out.println(clazz1 == clazz4); // true
}
2.3 实例
三、类的加载过程与ClassLoader的理解
当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化：类的加载（Load）、类的链接（Link）、类的初始化（Initialize）。
类的加载： 将类的class文件读入内存，并为之创建一个java.lang.Class对象。此过程由类加载器完成；
类的链接： 将类的二进制数据合并到JRE中；
初始化： 执行类构造器()方法的过程；
使用ClassLoader加载配置文件
四、创建运行时类的对象（掌握）
通过反射创建对应的运行时类的对象
Class<Person> clazz = Person.class ; // 不写泛型，就是默认Object
// newInstance():调用此方法，创建对应的运行时类的对象，内部调用了运行时类的空参构造器
/*
* 要想此方法正常的创建运行时类的对象，要求：
* 1. 运行时类必须提供空参的构造器 -------------InstantiationException
* 2. 空参的构造器的访问权限要够。通常，设置为public --------IllegalAccessException
*
* 在javabean中要求提供一个public的空参构造器，原因：
* 1. 便于通过反射，创建运行时类的对象；
* 2. 便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器。
*/
Person obj = clazz.newInstance() ;
System.out.println(obj) ;
public void test(){
int num = new Random().nextInt(3) ;
String classPath = "" ;
switch(num){
case 0:
classPath = "java.util.Date" ;
break ;
case 1:
classPath = "java.lang.Object" ;
break ;
case 2 ;
classPath = "com.atguigu.java.Person" ;
break ;
}
}
/*
* 创建一个指定类的对象
* classpath:指定类的全类名
*/
public Object getInstance(String classpath) throws Exception{
Class clazz = Class.forName(classPath) ;
return clazz.newInstance() ;
}
五、获取运行时类的完整结构(了解)
// 获取属性结构
// getFields() :获取当前运行时类及其父类中声明为public访问权限的属性
Field[] fields = clazz.getFields() ;
for(Field f: fields){
System.out.println(f) ;
}
// getDeclareFields()：获取当前运行时类中声明的所有属性（不包含父类中声明的属性）
Field[] declareFields = clazz.getDeclareFields() ;
for(Field f: declareFields){
System.out.println(f) ;
}
// 权限修饰符 数据类型 变量名
for(Field f: declareFields){
// 1. 权限修饰符
int modifier = f.getModifiers() ; // default:0 public:1 private:2 protected:4
System.out.println(Modifier.toString(modifier)) ;
// 2. 数据类型
Class type = f.getType() ;
System.out.println(type.getName()) ;
// 3. 变量名
String fName = f.getName() ;
System.out.println(fName) ;
}
获取方法里的具体结构：
获取构造器结构：
获取运行时类的父类：
下面获取泛型知道怎么写，这个后面会用到，用的时候直接粘：
下面获取运行是类的接口动态代理的时候会用到：
六、调用运行时类的指定结构（重点）
// 调用运行时类中指定的结构：属性、方法、构造器
public class ReflecttionTest{
@test
public void testField() throws NoSuchFieldException{
Class clazz = Person.class ;
// 创建运行是类的对象
Person p = (Person) clazz.newInstance() ;
// 获取指定的属性:要求运行是类中属性声明为public ★
// 通常采用此方法
clazz.getField("id") ;
// 设置当前属性的值
// set(指明设置哪个对象的属性，将此参数值设置为多少)
id.set(p,1001) ;
// 获取当前属性的值
// get(获取哪个对象的当前属性值)
int pid = id.get(p) ;
}
// 下面这个需要掌握：如何操作运行时类中的指定属性
public void testField() throws NoSuchFieldException{
Class clazz = Person.class ;
// 创建运行时类的对象
Person p = (Person) clazz.newInstance() ;
// 1. getDeclareField(String fieldName):获取运行时类中指定变量名的属性
Field name = clazz.getDeclareField("name") ;
// 2. 保证当前属性是可访问的
name.setAccessible() ;
// 3. 获取、设置对象的此属性值
name.set(p,"Tom") ;
}
public void testMethod() throws Exception{
// 下面这个也需要掌握：如何操作运行时类中的指定方法
// 创建运行时类的对象
Person p = (Person) clazz.newInstance() ;
// 1. 获取指定的某个方法
// getDeclareMethod():参数1：指明获取的方法的名称 参数2:指明获取的方法的形参列表
Methos show = clazz.getDeclaredMethod("show",String.class) ;
// 2. 保证当前方法是可访问的
show.setAccessible() ;
// 3. 调用方法的invoke():参数1：方法的调用者 参数2：给方法形参赋值的实参
// incoke()的返回值即为对应类中调用的方法的返回值
Object returnValue = show.invoke(p,"CHN") ; // String nation = p.show("CHN") ;
System.out.println(returnValue) ;
System.out.println("****************如何调用静态方法****************") ;
// private static void showDesc()
Method showDesc = clazz.getDeclareMethod("showDesc") ;
showDesc.setAccessible(true) ;
// 如果调用的运行时类中的方法没有返回值，则此invoke()返回null
Object returnVal = showDesc.invoke(Person.class) ; // Person.class也可以写成null,因为已经知道是哪个类了
System.out.println(returnVal) ; // null
}
// 如何操作运行时类中的指定构造器，不常用，最常用的就是newInstance()来创建对象
@test
public void testConstructor(){
class clazz = Person.class ;
// private Person(String name)
// 1. 获取指定的构造器
// getDeclareConstructor():参数：指明构造器的参数列表
Constructor constructor = clazz.getDeclaredConstructor(String.class) ;
// 2. 保证此构造器是可访问的
constructor.setAccessible(true) ;
// 3.调用此构造器创建运行时类的对象
Person per = (Person)constructor.newInstance("Tom") ;
System.out.println(per) ;
}
}
七、反射的应用：动态代理（重点）
7.1 静态代理
先举一个静态代理的例子：
/*
* 静态代理举例
* 特点：代理类和被代理类在编译期间，就确定下来了
*/
interface ClothFactory{
void produceCloth() ;
}
// 代理类
class ProxyClothFactory implements ClothFactory{
private ClothFactory factory ; // 用被代理类的对象进行实例化
public ProxyClothFactory(ClothFactory factory){
this.factory = factory ;
}
@Override
public void produceCloth() {
System.out.println("代理工厂做一些准备工作！") ;
factory.produceCloth();
System.out.println("代理工厂做一些后续的收尾工作");
}
}
// 被代理类
class NikeClothFactory implements ClothFactory{
@Override
public void produceCloth() {
System.out.println("Nike工厂生产一批运动服！");
}
}
public class StaticProxyTest {
public static void main(String[] args){
// 创建被代理类的对象
NikeClothFactory nike = new NikeClothFactory() ;
// 创建代理类的对象
ProxyClothFactory proxyClothFactory = new ProxyClothFactory(nike) ;
proxyClothFactory.produceCloth() ;
}
}
运行结果：
代理工厂做一些准备工作！
Nike工厂生产一批运动服！
代理工厂做一些后续的收尾工作
7.2 动态代理
首先要有接口和被代理类，然后代理类是动态的
interface Hunman{
String getBelief() ;
void eat(String food) ;
}
// 被代理类
class SuperMan implements Human{
@Override
public String getBelief(){
return "人要有理想！" ;
}
@Override
public void eat(String food){
System.out.println("hhs"+food) ;
}
}
/*
* 要想实现动态代理，需要解决的问题？
* 问题一：如何根据加载到内存中的被代理类，动态创建一个代理类及其对象？
* 问题二：当通过代理类的对象调用方法时，如何动态的去调用被代理类中的同名方法？
*/
class ProxyFactory{
// 调用此方法，返回一个代理类的对象。解决问题一
public static Object getProxyInstance(Object obj) { // obj:被代理类的对象
MyInvocationHandler handler = new MyInvocationHandler() ;
handler.bind(obj) ;
return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler) ;
}
}
class MyInvocationHandler implements InvovationHandler{
private Object obj ; // 需要使用被代理对象进行赋值
public void bind(Object obj){
this.obj = obj ;
}
// 当我们通过代理类的对象，调用方法a时，就会自动调用如下的方法：invoke()
// 将被代理类要执行的方法a的功能，就声明在invoke()中
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
// method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
// obj:被代理类的对象
Object returnValue = method.invoke(obj,args) ;
// 上述方法的返回值就作为当前类中的invoke()的返回值
return returnValue ;
}
}
public class ProxyTest{
public static void main(String[] args){
Superman superMan = new SuperMan() ;
// proxyInstance:代理类的对象
Human proxyInstance = (Human)ProxyFactory.getProxyInstance(superMan) ;
// 当通过代理类对象调用方法时，就自动的调用被代理类中同名的方法
proxyInstance.getBelief() ;
proxyInstance.eat("草莓") ;
System.out.println("*****************************") ;
NikeClothFactory nikeClothFactory = new NikeColthFactory() ;
ClothFactory proxyClothFactory = (ClothFactory)proxyFactory.getProxyFactorty(nikeClothFactory) ;
proxyClothFactory.produceCloth() ;
}
}
补充知识***：
动态代理和AOP（Aspect Orient Programming）
class HumanUtil{
public void method1(){
System.out.println("================通用方法一======================") ;
}
public void method2(){
System.out.println("=================通用方法二=====================") ;
}
}
OK,此部分完结！撒花