1、获取class文件对象的三种方式
1 package cn.itcast_01;
2
3 public class Person {
4 private String name;
5 int age;
6 public String address;
7
8 public Person() {
9 }
10
11 private Person(String name) {
12 this.name = name;
13 }
14
15 Person(String name, int age) {
16 this.name = name;
17 this.age = age;
18 }
19
20 public Person(String name, int age, String address) {
21 this.name = name;
22 this.age = age;
23 this.address = address;
24 }
25
26 public void show() {
27 System.out.println("show");
28 }
29
30 public void method(String s) {
31 System.out.println("method " + s);
32 }
33
34 public String getString(String s, int i) {
35 return s + "---" + i;
36 }
37
38 private void function() {
39 System.out.println("function");
40 }
41
42 @Override
43 public String toString() {
44 return "Person [name=" + name + ", age=" + age + ", address=" + address
45 + "]";
46 }
47
48 }
Person
1 package cn.itcast_01;
2
3 /*
4 * 反射：就是通过class文件对象，去使用该文件中的成员变量，构造方法，成员方法。
5 *
6 * Person p = new Person();
7 * p.使用
8 *
9 * 要想这样使用，首先你必须得到class文件对象，其实也就是得到Class类的对象。
10 * Class类：
11 * 成员变量 Field
12 * 构造方法 Constructor
13 * 成员方法 Method
14 *
15 * 获取class文件对象的方式：
16 * A:Object类的getClass()方法
17 * B:数据类型的静态属性class
18 * C:Class类中的静态方法
19 * public static Class forName(String className)
20 *
21 * 一般我们到底使用谁呢?
22 * A:自己玩 任选一种，第二种比较方便
23 * B:开发 第三种
24 * 为什么呢?因为第三种是一个字符串，而不是一个具体的类名。这样我们就可以把这样的字符串配置到配置文件中。
25 */
26 public class ReflectDemo {
27 public static void main(String[] args) throws ClassNotFoundException {
28 // 方式1
29 Person p = new Person();
30 Class c = p.getClass();
31
32 Person p2 = new Person();
33 Class c2 = p2.getClass();
34
35 System.out.println(p == p2);// false
36 System.out.println(c == c2);// true
37
38 // 方式2
39 Class c3 = Person.class;
40 // int.class;
41 // String.class;
42 System.out.println(c == c3);
43
44 // 方式3
45 // ClassNotFoundException
46 Class c4 = Class.forName("cn.itcast_01.Person");
47 System.out.println(c == c4);
48 }
49 }
2、通过反射获取无参构造方法并使用
1 package cn.itcast_02;
2
3 import java.lang.reflect.Constructor;
4
5 import cn.itcast_01.Person;
6
7 /*
8 * 通过反射获取构造方法并使用。
9 */
10 public class ReflectDemo {
11 public static void main(String[] args) throws Exception {
12 // 获取字节码文件对象
13 Class c = Class.forName("cn.itcast_01.Person");
14
15 // 获取构造方法
16 // public Constructor[] getConstructors():所有公共构造方法
17 // public Constructor[] getDeclaredConstructors():所有构造方法
18 // Constructor[] cons = c.getDeclaredConstructors();
19 // for (Constructor con : cons) {
20 // System.out.println(con);
21 // }
22
23 // 获取单个构造方法
24 // public Constructor<T> getConstructor(Class<?>... parameterTypes)
25 // 参数表示的是：你要获取的构造方法的构造参数个数及数据类型的class字节码文件对象
26 Constructor con = c.getConstructor();// 返回的是构造方法对象
27
28 // Person p = new Person();
29 // System.out.println(p);
30 // public T newInstance(Object... initargs)
31 // 使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
32 Object obj = con.newInstance();
33 System.out.println(obj);
34
35 // Person p = (Person)obj;
36 // p.show();
37 }
38 }
3、通过反射获取带参构造方法并使用
1 package cn.itcast_02;
2
3 import java.lang.reflect.Constructor;
4
5 /*
6 * 需求：通过反射去获取该构造方法并使用：
7 * public Person(String name, int age, String address)
8 *
9 * Person p = new Person("林青霞",27,"北京");
10 * System.out.println(p);
11 */
12 public class ReflectDemo2 {
13 public static void main(String[] args) throws Exception {
14 // 获取字节码文件对象
15 Class c = Class.forName("cn.itcast_01.Person");
16
17 // 获取带参构造方法对象
18 // public Constructor<T> getConstructor(Class<?>... parameterTypes)
19 Constructor con = c.getConstructor(String.class, int.class,
20 String.class);
21
22 // 通过带参构造方法对象创建对象
23 // public T newInstance(Object... initargs)
24 Object obj = con.newInstance("林青霞", 27, "北京");
25
26 System.out.println(obj);
27 }
28 }
4、通过反射获取私有构造方法并使用
1 package cn.itcast_02;
2
3 import java.lang.reflect.Constructor;
4
5 /*
6 * 需求：通过反射获取私有构造方法并使用
7 * private Person(String name){}
8 *
9 * Person p = new Person("风清扬");
10 * System.out.println(p);
11 */
12 public class ReflectDemo3 {
13 public static void main(String[] args) throws Exception {
14 // 获取字节码文件对象
15 Class c = Class.forName("cn.itcast_01.Person");
16
17 // 获取私有构造方法对象
18 // NoSuchMethodException：每个这个方法异常
19 // 原因是一开始我们使用的方法只能获取公共的，下面这种方式就可以了。
20 Constructor con = c.getDeclaredConstructor(String.class);
21
22 // 用该私有构造方法创建对象
23 // IllegalAccessException:非法的访问异常。
24 // 暴力访问
25 con.setAccessible(true);// 值为true则指示反射的对象在使用时应该取消Java语言访问检查。
26 Object obj = con.newInstance("风清扬");
27
28 System.out.println(obj);
29 }
30 }
5、通过反射获取成员变量并使用
1 package cn.itcast_03;
2
3 import java.lang.reflect.Constructor;
4 import java.lang.reflect.Field;
5
6 /*
7 * 通过发生获取成员变量并使用
8 */
9 public class ReflectDemo {
10 public static void main(String[] args) throws Exception {
11 // 获取字节码文件对象
12 Class c = Class.forName("cn.itcast_01.Person");
13
14 // 获取所有的成员变量
15 // Field[] fields = c.getFields();
16 // Field[] fields = c.getDeclaredFields();
17 // for (Field field : fields) {
18 // System.out.println(field);
19 // }
20
21 /*
22 * Person p = new Person(); p.address = "北京"; System.out.println(p);
23 */
24
25 // 通过无参构造方法创建对象
26 Constructor con = c.getConstructor();
27 Object obj = con.newInstance();
28 System.out.println(obj);
29
30 // 获取单个的成员变量
31 // 获取address并对其赋值
32 Field addressField = c.getField("address");
33 // public void set(Object obj,Object value)
34 // 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
35 addressField.set(obj, "北京"); // 给obj对象的addressField字段设置值为"北京"
36 System.out.println(obj);
37
38 // 获取name并对其赋值
39 // NoSuchFieldException
40 Field nameField = c.getDeclaredField("name");
41 // IllegalAccessException
42 nameField.setAccessible(true);
43 nameField.set(obj, "林青霞");
44 System.out.println(obj);
45
46 // 获取age并对其赋值
47 Field ageField = c.getDeclaredField("age");
48 ageField.setAccessible(true);
49 ageField.set(obj, 27);
50 System.out.println(obj);
51 }
52 }
6、通过反射获取成员方法并使用
1 package cn.itcast_04;
2
3 import java.lang.reflect.Constructor;
4 import java.lang.reflect.Method;
5
6 public class ReflectDemo {
7 public static void main(String[] args) throws Exception {
8 // 获取字节码文件对象
9 Class c = Class.forName("cn.itcast_01.Person");
10
11 // 获取所有的方法
12 // Method[] methods = c.getMethods(); // 获取自己的包括父亲的公共方法
13 // Method[] methods = c.getDeclaredMethods(); // 获取自己的所有的方法
14 // for (Method method : methods) {
15 // System.out.println(method);
16 // }
17
18 Constructor con = c.getConstructor();
19 Object obj = con.newInstance();
20
21 /*
22 * Person p = new Person(); p.show();
23 */
24
25 // 获取单个方法并使用
26 // public void show()
27 // public Method getMethod(String name,Class<?>... parameterTypes)
28 // 第一个参数表示的方法名，第二个参数表示的是方法的参数的class类型
29 Method m1 = c.getMethod("show");
30 // obj.m1(); // 错误
31 // public Object invoke(Object obj,Object... args)
32 // 返回值是Object接收,第一个参数表示对象是谁，第二参数表示调用该方法的实际参数
33 m1.invoke(obj); // 调用obj对象的m1方法
34
35 System.out.println("----------");
36 // public void method(String s)
37 Method m2 = c.getMethod("method", String.class);
38 m2.invoke(obj, "hello");
39 System.out.println("----------");
40
41 // public String getString(String s, int i)
42 Method m3 = c.getMethod("getString", String.class, int.class);
43 Object objString = m3.invoke(obj, "hello", 100);
44 System.out.println(objString);
45 // String s = (String)m3.invoke(obj, "hello",100);
46 // System.out.println(s);
47 System.out.println("----------");
48
49 // private void function()
50 Method m4 = c.getDeclaredMethod("function");
51 m4.setAccessible(true);
52 m4.invoke(obj);
53 }
54 }
7、通过反射运行配置文件内容
配置文件class.txt的内容：
className=cn.itcast.test.Student
methodName=love
1 package cn.itcast.test;
2
3 public class Student {
4 public void love() {
5 System.out.println("爱生活,爱烨儿");
6 }
7 }
1 package cn.itcast.test;
2
3 public class Teacher {
4 public void love() {
5 System.out.println("爱生活,爱青霞");
6 }
7 }
1 package cn.itcast.test;
2
3 public class Worker {
4 public void love() {
5 System.out.println("爱生活,爱娘子");
6 }
7 }
1 package cn.itcast.test;
2
3 import java.io.FileReader;
4 import java.lang.reflect.Constructor;
5 import java.lang.reflect.Method;
6 import java.util.Properties;
7
8 /*
9 * 通过配置文件运行类中的方法
10 *
11 * 反射：
12 * 需要有配置文件配合使用。
13 * 用class.txt代替。
14 * 并且你知道有两个键。
15 * className
16 * methodName
17 */
18 public class Test {
19 public static void main(String[] args) throws Exception {
20 // 反射前的做法
21 // Student s = new Student();
22 // s.love();
23 // Teacher t = new Teacher();
24 // t.love();
25 // Worker w = new Worker();
26 // w.love();
27 // 反射后的做法
28
29 // 加载键值对数据
30 Properties prop = new Properties();
31 FileReader fr = new FileReader("class.txt");
32 prop.load(fr);
33 fr.close();
34
35 // 获取数据
36 String className = prop.getProperty("className");
37 String methodName = prop.getProperty("methodName");
38
39 // 反射
40 Class c = Class.forName(className);
41
42 Constructor con = c.getConstructor();
43 Object obj = con.newInstance();
44
45 // 调用方法
46 Method m = c.getMethod(methodName);
47 m.invoke(obj);
48 }
49 }
8、通过反射越过泛型检查
1 package cn.itcast.test;
2
3 import java.lang.reflect.InvocationTargetException;
4 import java.lang.reflect.Method;
5 import java.util.ArrayList;
6
7 /*
8 * 我给你ArrayList<Integer>的一个对象，我想在这个集合中添加一个字符串数据，如何实现呢？
9 */
10 public class ArrayListDemo {
11 public static void main(String[] args) throws NoSuchMethodException,
12 SecurityException, IllegalAccessException,
13 IllegalArgumentException, InvocationTargetException {
14 // 创建集合对象
15 ArrayList<Integer> array = new ArrayList<Integer>();
16
17 // array.add("hello");
18 // array.add(10);
19
20 Class c = array.getClass(); // 集合ArrayList的class文件对象
21 Method m = c.getMethod("add", Object.class);
22
23 m.invoke(array, "hello"); // 调用array的add方法，传入的值是hello
24 m.invoke(array, "world");
25 m.invoke(array, "java");
26
27 System.out.println(array);
28 }
29 }
9、通过反射写一个通用的设置某个对象的某个属性为指定的值
1 package cn.itcast.test;
2
3 public class ToolDemo {
4 public static void main(String[] args) throws NoSuchFieldException,
5 SecurityException, IllegalArgumentException, IllegalAccessException {
6 Person p = new Person();
7 Tool t = new Tool();
8 t.setProperty(p, "name", "林青霞");
9 t.setProperty(p, "age", 27);
10 System.out.println(p);
11 System.out.println("-----------");
12
13 Dog d = new Dog();
14
15 t.setProperty(d, "sex", ‘男‘);
16 t.setProperty(d, "price", 12.34f);
17
18 System.out.println(d);
19 }
20 }
21
22 class Dog {
23 char sex;
24 float price;
25
26 @Override
27 public String toString() {
28 return sex + "---" + price;
29 }
30 }
31
32 class Person {
33 private String name;
34 public int age;
35
36 @Override
37 public String toString() {
38 return name + "---" + age;
39 }
40 }
10、动态代理的概述和实现
1 package cn.itcast_06;
2
3 import java.lang.reflect.InvocationHandler;
4 import java.lang.reflect.Method;
5
6 public class MyInvocationHandler implements InvocationHandler {
7 private Object target; // 目标对象
8
9 public MyInvocationHandler(Object target) {
10 this.target = target;
11 }
12
13 @Override
14 public Object invoke(Object proxy, Method method, Object[] args)
15 throws Throwable {
16 System.out.println("权限校验");
17 Object result = method.invoke(target, args);
18 System.out.println("日志记录");
19 return result; // 返回的是代理对象
20 }
21 }
1 package cn.itcast_06;
2
3 /*
4 * 用户操作接口
5 */
6 public interface UserDao {
7 public abstract void add();
8
9 public abstract void delete();
10
11 public abstract void update();
12
13 public abstract void find();
14 }
1 package cn.itcast_06;
2
3 public class UserDaoImpl implements UserDao {
4
5 @Override
6 public void add() {
7 System.out.println("添加功能");
8 }
9
10 @Override
11 public void delete() {
12 System.out.println("删除功能");
13 }
14
15 @Override
16 public void update() {
17 System.out.println("修改功能");
18 }
19
20 @Override
21 public void find() {
22 System.out.println("查找功能");
23 }
24
25 }
1 package cn.itcast_06;
2
3 import java.lang.reflect.Proxy;
4
5 public class Test {
6 public static void main(String[] args) {
7 UserDao ud = new UserDaoImpl();
8 ud.add();
9 ud.delete();
10 ud.update();
11 ud.find();
12 System.out.println("-----------");
13 // 我们要创建一个动态代理对象
14 // Proxy类中有一个方法可以创建动态代理对象
15 // public static Object newProxyInstance(ClassLoader loader,Class<?>[]
16 // interfaces,InvocationHandler h)
17 // 我准备对ud对象做一个代理对象
18 MyInvocationHandler handler = new MyInvocationHandler(ud);
19 UserDao proxy = (UserDao) Proxy.newProxyInstance(ud.getClass()
20 .getClassLoader(), ud.getClass().getInterfaces(), handler);
21 proxy.add();
22 proxy.delete();
23 proxy.update();
24 proxy.find();
25 // System.out.println("-----------");
26 //
27 // StudentDao sd = new StudentDaoImpl();
28 // MyInvocationHandler handler2 = new MyInvocationHandler(sd);
29 // StudentDao proxy2 = (StudentDao) Proxy.newProxyInstance(sd.getClass()
30 // .getClassLoader(), sd.getClass().getInterfaces(), handler2);
31 // proxy2.login();
32 // proxy2.regist();
33 }
34 }
时间： 2024-07-28 15:25:12