您的位置: 首页  >  IT文章  >  【java】反射简单示例

【java】反射简单示例

分类: IT文章 • 2024-03-29 18:55:19 
1 package 反射;
2 
3 public class Test反射 {
4     public static void main(String[] args) {
5         System.out.println(Runtime.getRuntime().getClass());//class java.lang.Runtime
6         Test反射 t=new Test反射();
7         System.out.println(t.getClass());//class 反射.Test反射
8     }
9 }
getClass 
 1 package 反射;
 2 
 3 public class Test反射 {
 4     public static void main(String[] args) {
 5         Test反射 t=new Test反射();
 6         //Class类是反射操作的源头，所有的反射都要从此类开始进行。
 7         Class<?> cls=t.getClass();//第1种Class类实例化方法，用的很少
 8         System.out.println(cls);//class 反射.Test反射
 9         Class<?> cls2=Test反射.class;//第2种Class类实例化方法，用的多,使用领域：Hibernate、Mybatis、Spring
10         System.out.println(cls2);//class 反射.Test反射
11         Class<?> cls3=null;
12         try {
13             cls3=Class.forName("反射.Test反射");//第3种Class类实例化方法，用的多。此处要写全名，即加上包名，否则报错。
14         } catch (ClassNotFoundException e) {
15             e.printStackTrace();
16         }
17         System.out.println(cls3);//class 反射.Test反射
18     }
19 }
Class类3种实例化方式 
 1 package 反射;
 2 class A{
 3     public A(){
 4         System.out.println("调用无参构造实例化对象。");
 5     }
 6     @Override
 7     public String toString() {
 8         return "调用toString()方法。";
 9     }
10 }
11 public class Test反射 {
12     public static void main(String[] args) {
13         Class<?> cls=null;
14         try {
15             cls=Class.forName("反射.A");
16         } catch (ClassNotFoundException e) {
17             e.printStackTrace();
18         }
19         Object o=null;
20         try {
21             o=cls.newInstance();
22         } catch (InstantiationException e) {
23             e.printStackTrace();
24         } catch (IllegalAccessException e) {
25             e.printStackTrace();
26         }
27         System.out.println(o);
28         /**
29          * 运行结果：
30          *    调用无参构造实例化对象。
31          *    调用toString()方法。
32          */
33     }
34 }
利用反射进行实例化对象 
 1 package 反射;
 2 
 3 import java.lang.reflect.Constructor;
 4 import java.lang.reflect.InvocationTargetException;
 5 
 6 class A{
 7     private String name;
 8     private int age;
 9     public A(String name,int age){
10         System.out.println("调用有参构造实例化对象。");
11         this.name=name;
12         this.age=age;
13     }
14     @Override
15     public String toString() {
16         return "调用toString()方法:name="+name+",age="+age;
17     }
18 }
19 public class Test反射 {
20     public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
21         Class<?> cls=null;
22         try {
23             cls=Class.forName("反射.A");
24         } catch (ClassNotFoundException e) {
25             e.printStackTrace();
26         }
27         Object o=null;
28         try {
29             Constructor<?> con=cls.getConstructor(String.class,int.class);
30             o=con.newInstance("张三",18);//从此处可以看出以后定义类的构造方法时最好保留一个无参构造。
31         } catch (InstantiationException e) {
32             e.printStackTrace();
33         } catch (IllegalAccessException e) {
34             e.printStackTrace();
35         }
36         System.out.println(o);
37         /**
38          * 运行结果：
39          *    调用有参构造实例化对象。
40          *    调用toString()方法:name=张三,age=18
41          */
42     }
43 }
利用反射实例化对象，调用有参构造。 
 1 package 反射;
 2 
 3 import java.lang.reflect.InvocationTargetException;
 4 import java.lang.reflect.Method;
 5 
 6 class Person{
 7     private String name;
 8     public void setName(String name) {
 9         this.name = name;
10     }
11     public String getName() {
12         return name;
13     }
14 }
15 public class Test反射 {
16     public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
17         Class<?> cls=Class.forName("反射.Person");
18         Object obj=cls.newInstance();
19         Method methodSetName=cls.getMethod("setName", String.class);
20         Method methodGetName=cls.getMethod("getName");
21         methodSetName.invoke(obj, "张三");
22         System.out.println(methodGetName.invoke(obj));//张三
23     }
24 }
利用反射调用普通方法 
 1 package 反射;
 2 
 3 import java.lang.reflect.Field;
 4 
 5 class Person{
 6     @SuppressWarnings("unused")
 7     private String name;
 8 }
 9 public class Test反射 {
10     public static void main(String[] args) throws Exception {
11         Class<?> cls=Class.forName("反射.Person");
12         Object obj=cls.newInstance();
13         Field fieldName=cls.getDeclaredField("name");
14         fieldName.setAccessible(true);//私有属性的存取不建议用引方式，最好还是用setter和getter方法
15         fieldName.set(obj, "张三");
16         System.out.println(fieldName.get(obj));//张三
17     }
18 }
利用反射存取属性

相关推荐