1.如何创建Class的实例(重点)

1.1过程：源文件经过编译(javac.exe)以后，得到一个或多个.class文件。

.class文件经过运行(java.exe)这步，

就需要进行类的加载（通过JVM的类的加载器），记载到内存中的缓存。每一个放入缓存中的.class文件就是一个Class的实例！

1.2 Class的一个对象，对应着一个运行时类。相当于一个运行时类本身充当了Class的一个实例。

1.3 java.lang.Class是反射的源头。

接下来涉及到反射的类都在java.lang.reflect子包下。如：Field  Method Constructor  Type Package..

当通过Class的实例调用getMethods() --->Method , getConstructors() ---->Constructor

1.4实例化Class的方法(三种):

~~~

       // 1.调用运行时类的.class属性  

       Class clazz1 = Person.class;

       System.out.println(clazz1);

Class clazz2 = Creator.class;

System.out.println(clazz2);

// 2.通过运行时类的对象，调用其getClass()方法

Person p = new Person();

Class clazz3 = p.getClass();

System.out.println(clazz3);

// 3.调用Class的静态方法forName(String className)。此方法报ClassNotFoundException

String className = "com.atguigu.java.Person";

Class clazz4 = Class.forName(className);

System.out.println(clazz4);

//4.通过类的加载器

        ClassLoader classLoader = this.getClass().getClassLoader();

        Class clazz = classLoader.loadClass(className);

        System.out.println(clazz.getName());

~~~

2.有了Class实例以后，可以做什么？

应用一：

可以创建对应的运行时类的对象(重点)

~~~

//获取运行时类的对象：方法一

@Test

public void test1() throws Exception{

Class clazz = Class.forName("com.atguigu.review.Animal");

Object obj = clazz.newInstance();

Animal a = (Animal)obj;

System.out.println(a);

}

//调用指定的构造器创建运行时类的对象

@Test

public void test2() throws Exception{

Class clazz = Animal.class;

Constructor cons = clazz.getDeclaredConstructor(String.class,int.class);

cons.setAccessible(true);

Animal a = (Animal)cons.newInstance("Tom",10);

System.out.println(a);

}

~~~

3.有了Class实例以后，可以做什么？

应用二：获取对应的运行时类的完整的类的结构：属性、方法、构造器、包、父类、接口、泛型、注解、异常、内部类

~~~

属性:

Field[] getFields只能获取到运行时类及其父类中声明为Public 的属性（包含其父类中的声明的public）

Field[] getDeclaredFields:获取运行时类本身声明的所有的属性（①任何权限修饰符修饰的都能获取②不含父类中的）

String Modifier.toString(field.getModifiers()):获取属性的权限修饰符

Class field.getType() : 获取属性的类型

方法:

Method[] clazz.getMethods() :获取到对应的运行时类中声明的权限为public的方法（包含其父类中的声明的public）

Method[] clazz.getDeclaredMethods()：获取到对应的运行时类中声明的所有的方法（①任何权限修饰符修饰的都能获取②不含父类中的）

Class method.getReturnType() :方法的返回值

Class[] method.getParameterTypes() : 方法形参

Class[] method.getExceptionTypes(): 异常类型

Constructor[] clazz.getDeclaredConstructors():获取构造器

Class  clazz.getSuperclass(); 获取父类

Type clazz.getGenericSuperclass(); 获取带泛型的父类

ParameterizedType param = (ParameterizedType)type; 获取父类的泛型

Type[] args = param.getActualTypeArguments();

System.out.println(((Class)args[0]).getName());

Class[] clazz.getInterfaces(); 获取实现的接口

Package clazz.getPackage(); 获取所在的包

Annotation[] clazz.getAnnotations(); 获取注释

~~~

4.有了Class实例以后，可以做什么？

应用三：调用对应的运行时类中指定的结构（某个指定的属性、方法、构造器）(重点)

~~~

//调用指定属性

@Test

public void test3() throws Exception{

Class clazz = Class.forName("com.atguigu.review.Animal");

Object obj = clazz.newInstance();

Animal a = (Animal)obj;

//调用非public的属性

Field f1 = clazz.getDeclaredField("name");

f1.setAccessible(true);

f1.set(a, "Jerry");

//调用public的属性

Field f2 = clazz.getField("age");

f2.set(a, 9);

System.out.println(f2.get(a));

System.out.println(a);

//调用static的属性

Field f3 = clazz.getDeclaredField("desc");

System.out.println(f3.get(null));

}

//调用指定的方法

@Test

public void test4() throws Exception{

Class clazz = Class.forName("com.atguigu.review.Animal");

Object obj = clazz.newInstance();

Animal a = (Animal)obj;

//调用非public的方法

Method m1 = clazz.getDeclaredMethod("getAge");

m1.setAccessible(true);

int age = (Integer)m1.invoke(a);

System.out.println(age);

//调用public的方法

Method m2 = clazz.getMethod("show", String.class);

Object returnVal = m2.invoke(a,"金毛");   invoke 调用后返回方法的返回值

System.out.println(returnVal);

//调用static的方法

Method m3 = clazz.getDeclaredMethod("info");

m3.setAccessible(true);

//        m3.invoke(Animal.class);

m3.invoke(null);

}

~~~

5.动态代理---反射的应用。体会反射的动态性

代理设计模式的原理:

使用一个代理将对象包装起来, 然后用该代理对象取代原始对象. 任何对原始对象的调用都要通过代理. 代理对象决定是否以及何时

将方法调用转到原始对象上

静态代理：要求被代理类和代理类同时实现相应的一套接口；通过代理类的对象调用重写接口的方法时，实际上执行的是被代理类的同样的

方法的调用。

动态代理：在程序运行时，根据被代理类及其实现的接口，动态的创建一个代理类。当调用代理类的实现的抽象方法时，就发起对被代理类同样

方法的调用。

涉及到的技术点：

~~~

①提供一个实现了InvocationHandler接口实现类，并重写其invoke()方法

②Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),h);

//注：obj：被代理类对象 ； h:实现了InvocationHandler接口的实现类的对象

例子见：TestProxy例子

~~~

动态代理与AOP