备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

Java基础系列：（3）反射机制的简单总结

2017-11-27 1078
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

一 反射机制概念简介

       JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。（PS：百度百科）

       举个简单例子就是：正常情况下，对于一个存在的类我们可以通过类来创建对象，然后调用其中的属性或方法；但是要是想要通过一个对象来找到对应的类的名称，属性或者方法，这时候就需要用到反射机制了。

       如果想要简单了解反射操作，则首先应该认识的是Class类

二 认识Class类

（1）所有类的对象实际上都是Class类的实例

       在Java中，Object类是一切类的父类，那么所有类的对象实际上也就都是java.lang.Class类的实例，因此所有对象都可以转变成java.lang.Class类型表示。

（2）一个简单实例，获取完整的类名路径

1
2
3
4
5
6
7
8
9
package  javase.reflex;
 
public  class  GetClassDemo01 {
     public  static  void  main(String[] args) {
         GetClassDemo01 demo01 =  new  GetClassDemo01();
         System.out.println(demo01.getClass().getName());  // 输出：javase.reflex.GetClassDemo01
     }
 
}

（3）实例化Class类的三种方式

       由于在Class类中并没有定义任何的构造方法，因此一般通过forName(“”)静态方法来实例化对象。当然也可以使用“对象.getClass()”或“类.class”来实例化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package  javase.reflex;
 
/**
  * 实例化Class对象
  * */
public  class  GetClassDemo02 {
     public  static  void  main(String[] args) {
         Class<?> class1 =  null ;
         Class<?> class2 =  null ;
         Class<?> class3 =  null ;
         // 实例化方法一（常用）
         try  {
             class1 = Class.forName( "javase.reflex.GetClassDemo02" );
         }  catch  (ClassNotFoundException e) {
             e.printStackTrace();
         }
         // 实例化方法二
         class2 =  new  GetClassDemo02().getClass();
         // 实例化方法三
         class3 = GetClassDemo02. class ;
 
         System.out.println( "类名称："  + class1.getName());
         System.out.println( "类名称："  + class2.getName());
         System.out.println( "类名称："  + class3.getName());
     }
 
}

输出：

1
2
3
类名称：javase.reflex.GetClassDemo02
类名称：javase.reflex.GetClassDemo02
类名称：javase.reflex.GetClassDemo02

三 Class类初体验——通过newInstance()方法实例化对象

方法：public Object newInstance() throws InstantiationException,IllegalAccessException

描述：创建此Class对象所表示的类的一个新实例

（1）通过无参构造方法实例化对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package  javase.reflex;
 
class  WebSite {
     private  String name;
     private  String domain;
 
     public  String getName() {
         return  name;
     }
 
     public  void  setName(String name) {
         this .name = name;
     }
 
     public  String getDomain() {
         return  domain;
     }
 
     public  void  setDomain(String domain) {
         this .domain = domain;
     }
 
     public  String toString() {
         return  "名称："  + name +  "\n域名："  + domain;
     }
}
 
public  class  InstanceDemo01 {
 
     public  static  void  main(String[] args) {
         try  {
             Class<?> class1 = Class.forName( "javase.reflex.WebSite" );
             WebSite webSite = (WebSite) class1.newInstance();  // 实例化WebSite对象
             webSite.setName( "zifangsky的个人博客" );
             webSite.setDomain( "http://www.zifangsky.cn" );
 
             System.out.println(webSite);
         }  catch  (ClassNotFoundException e) {
             e.printStackTrace();
         }  catch  (InstantiationException e) {
             e.printStackTrace();
         }  catch  (IllegalAccessException e) {
             e.printStackTrace();
         }
 
     }
 
}

输出：

1
2
名称：zifangsky的个人博客
域名：http: //www.zifangsky.cn

需要注意的是，这种实例化方式需要被实例化的对象的类中必须得存在无参的构造方法，不然程序会报错。比如说这样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
package  javase.reflex;
 
class  WebSite02 {
     private  String name;
     private  String domain;
 
     /**
      * 没有无参数构造方法，下面在进行实例化时会报错
      * */
     // public WebSite02() {
     //
     // }
     public  WebSite02(String name, String domain) {
         this .name = name;
         this .domain = domain;
     }
 
     public  String getName() {
         return  name;
     }
 
     public  void  setName(String name) {
         this .name = name;
     }
 
     public  String getDomain() {
         return  domain;
     }
 
     public  void  setDomain(String domain) {
         this .domain = domain;
     }
 
     public  String toString() {
         return  "名称："  + name +  "\n域名："  + domain;
     }
}
 
public  class  InstanceDemo02 {
     public  static  void  main(String[] args) {
         try  {
             Class<?> class2 = Class.forName( "javase.reflex.WebSite02" );
             WebSite02 webSite = (WebSite02) class2.newInstance();  // 实例化WebSite对象
             webSite.setName( "zifangsky的个人博客" );
             webSite.setDomain( "http://www.zifangsky.cn" );
 
             System.out.println(webSite);
         }  catch  (ClassNotFoundException e) {
             e.printStackTrace();
         }  catch  (InstantiationException e) {
             e.printStackTrace();
         }  catch  (IllegalAccessException e) {
             e.printStackTrace();
         }
 
     }
 
}

运行时报错：

1
2
3
4
5
6
7
java.lang.InstantiationException: javase.reflex.WebSite02
     at java.lang.Class.newInstance(Class.java: 427 )
     at javase.reflex.InstanceDemo02.main(InstanceDemo02.java: 43 )
Caused by: java.lang.NoSuchMethodException: javase.reflex.WebSite02.<init>()
     at java.lang.Class.getConstructor0(Class.java: 3082 )
     at java.lang.Class.newInstance(Class.java: 412 )
     ...  1  more

（2）通过有参构造方法实例化对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
package  javase.reflex;
 
import  java.lang.reflect.Constructor;
import  java.lang.reflect.InvocationTargetException;
 
class  WebSite03 {
     private  String name;
     private  String domain;
     
     /**
      * 只有有参数构造方法
      * */
     public  WebSite03(String name, String domain) {
         this .name = name;
         this .domain = domain;
     }
 
     public  String getName() {
         return  name;
     }
 
     public  void  setName(String name) {
         this .name = name;
     }
 
     public  String getDomain() {
         return  domain;
     }
 
     public  void  setDomain(String domain) {
         this .domain = domain;
     }
 
     public  String toString() {
         return  "名称："  + name +  "\n域名："  + domain;
     }
}
public  class  InstanceDemo03 {
     public  static  void  main(String[] args) {
         try  {
             Class<?> class3 = Class.forName( "javase.reflex.WebSite03" );
             Constructor<?>[] cons = class3.getConstructors();   //申明一个构造方法数组
             
             //取第一个构造方法，并且使用可变参数的形式向该构造方法传递参数
             WebSite03 webSite = (WebSite03) cons[ 0 ].newInstance( "zifangsky的个人博客" , "http://www.zifangsky.cn" );
         
             System.out.println(webSite);
         }  catch  (ClassNotFoundException e) {
             e.printStackTrace();
         }  catch  (InstantiationException e) {
             e.printStackTrace();
         }  catch  (IllegalAccessException e) {
             e.printStackTrace();
         }  catch  (IllegalArgumentException e) {
             e.printStackTrace();
         }  catch  (InvocationTargetException e) {
             e.printStackTrace();
         }
 
     }
 
}

输出：

1
2
名称：zifangsky的个人博客
域名：http: //www.zifangsky.cn

四 通过反射取得类的结构的常用操作示例

首先定义了一个接口和它的子类

接口：

1
2
3
4
5
6
7
8
package  javase.reflex;
 
public  interface  Animal {
     public  final  String WATER =  "水" ;
     public  void  drink();
     public  void  eat();
     public  String introduce(String name, int  age);
}

它的子类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
package  javase.reflex;
 
public  class  Dog  implements  Animal{
     private  String name;
     private  int  age;
     //三个构造方法
     public  Dog() {
         
     }
     
     public  Dog(String name) {
         this .name = name;
     }
     
     public  Dog(String name,  int  age) {
         this .name = name;
         this .age = age;
     }
 
     public  String getName() {
         return  name;
     }
 
     public  void  setName(String name) {
         this .name = name;
     }
 
     public  int  getAge() {
         return  age;
     }
 
     public  void  setAge( int  age) {
         this .age = age;
     }
 
     /**
      * 喝水
      * */
     public  void  drink() {
         System.out.println( "每天喝"  + WATER);
         
     }
     /**
      * 吃东西
      * */
     public  void  eat() {
         System.out.println(name +  "： 啃骨头 + 吃肉" );
     }
     /**
      * 介绍
      * */
     public  String introduce(String name,  int  age) {  
         return  "我的名字是"  + name +  "，今年"  + age +  "岁了" ;
     }
 
}

一些常用操作示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
package  javase.reflex;
 
import  java.lang.reflect.Constructor;
import  java.lang.reflect.Field;
import  java.lang.reflect.Method;
import  java.lang.reflect.Modifier;
 
public  class  Demo {
     /**
      * 获取实现的接口
      * */
     public  void  getInterfacesDemo() {
         try  {
             Class<?> class1 = Class.forName( "javase.reflex.Dog" );
             Class<?>[] inter = class1.getInterfaces();  // 获取所有接口
 
             for  (Class<?> c : inter)
                 System.out.println( "实现的接口： "  + c.getName());
 
         }  catch  (ClassNotFoundException e) {
             e.printStackTrace();
         }
     }
 
     /**
      * 获取继承的父类
      * */
     public  void  getSuperDemo() {
         try  {
             Class<?> class1 = Class.forName( "javase.reflex.Dog" );
             Class<?> superClass = class1.getSuperclass();  // 获取父类
 
             System.out.println( "父类： "  + superClass.getName());
 
         }  catch  (ClassNotFoundException e) {
             e.printStackTrace();
         }
     }
 
     /**
      * 获取所有构造方法
      * */
     public  void  getConstructorsDemo() {
         try  {
             Class<?> class1 = Class.forName( "javase.reflex.Dog" );
             Constructor<?>[] cons = class1.getConstructors();  // 获取所有构造方法
 
             for  (Constructor<?> con : cons) {
                 Class<?>[] parameters = con.getParameterTypes();  // 获取一个构造方法的所有参数类型
                 int  mo = con.getModifiers();  // 取出权限
                 System.out.print( "构造方法： "  + Modifier.toString(mo) +  " " );  // 输出权限名称
                 System.out.print(con.getName() +  "(" );
 
                 for  ( int  i =  0 ; i < parameters.length; i++) {
                     System.out.print(parameters[i].getName() +  " arg"  + i);
                     if  (i < (parameters.length -  1 ))
                         System.out.print( ", " );
                 }
                 System.out.println( ")" );
             }
 
         }  catch  (ClassNotFoundException e) {
             e.printStackTrace();
         }
     }
 
     /**
      * 获取所有方法
      * */
     public  void  getMethodsDemo() {
         try  {
             Class<?> class1 = Class.forName( "javase.reflex.Dog" );
             Method[] methods = class1.getMethods();
             for  (Method method : methods) {
                 System.out.print( "方法： "
                         + Modifier.toString(method.getModifiers()) +  " " );  // 权限
                 System.out.print(method.getReturnType().getName() +  " " );  // 返回值类型
                 System.out.print(method.getName() +  "(" );  // 方法名
                 // 参数
                 Class<?>[] parameters = method.getParameterTypes();
                 for  ( int  i =  0 ; i < parameters.length; i++) {
                     System.out.print(parameters[i].getName() +  " arg"  + i);
                     if  (i < (parameters.length -  1 ))
                         System.out.print( ", " );
                 }
                 System.out.print( ")" );
                 // 抛出的异常
                 Class<?>[] exceptions = method.getExceptionTypes();
                 if  (exceptions.length >  0 )
                     System.out.print( "throws " );
 
                 for  ( int  i =  0 ; i < exceptions.length; i++) {
                     System.out.print(exceptions[i].getName());
                     if  (i < (exceptions.length -  1 ))
                         System.out.print( "," );
                 }
                 System.out.println();
             }
         }  catch  (ClassNotFoundException e) {
             e.printStackTrace();
         }
     }
 
     /**
      * 获取所有属性
      * */
     public  void  getFieldsDemo() {
         try  {
             Class<?> class1 = Class.forName( "javase.reflex.Dog" );
             // 1 取得本类中的全部属性，（PS：普通代码块）
             {
                 Field[] field = class1.getDeclaredFields();
                 for  (Field f : field) {
                     System.out.print( "本类属性： "
                             + Modifier.toString(f.getModifiers()) +  " " );  // 权限
                     System.out.print(f.getType().getName() +  " " );  // 类型
                     System.out.println(f.getName() +  ";" );  // 属性名称
                 }
             }
             // 2 取得实现的接口或父类中的公共属性
             {
                 Field[] field = class1.getFields();
                 for  (Field f : field) {
                     System.out.print( "公共属性： "
                             + Modifier.toString(f.getModifiers()) +  " " );  // 权限
                     System.out.print(f.getType().getName() +  " " );  // 类型
                     System.out.println(f.getName() +  ";" );  // 属性名称
                 }
             }
         }  catch  (ClassNotFoundException e) {
             e.printStackTrace();
         }
     }
 
     public  static  void  main(String[] args) {
         Demo demo =  new  Demo();
         demo.getInterfacesDemo();
         System.out
                 .println( "******************http://www.zifangsky.cn**********************\n" );
 
         demo.getSuperDemo();
         System.out
                 .println( "******************http://www.zifangsky.cn**********************\n" );
 
         demo.getConstructorsDemo();
         System.out
                 .println( "******************http://www.zifangsky.cn**********************\n" );
 
         demo.getMethodsDemo();
         System.out
                 .println( "******************http://www.zifangsky.cn**********************\n" );
 
         demo.getFieldsDemo();
         System.out
                 .println( "******************http://www.zifangsky.cn**********************\n" );
     }
 
}

输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
实现的接口： javase.reflex.Animal
******************http: //www.zifangsky.cn**********************
 
父类： java.lang.Object
******************http: //www.zifangsky.cn**********************
 
构造方法：  public  javase.reflex.Dog(java.lang.String arg0,  int  arg1)
构造方法：  public  javase.reflex.Dog(java.lang.String arg0)
构造方法：  public  javase.reflex.Dog()
******************http: //www.zifangsky.cn**********************
 
方法：  public  java.lang.String getName()
方法：  public  void  setName(java.lang.String arg0)
方法：  public  int  getAge()
方法：  public  void  setAge( int  arg0)
方法：  public  void  drink()
方法：  public  void  eat()
方法：  public  java.lang.String introduce(java.lang.String arg0,  int  arg1)
方法：  public  final  void  wait() throws  java.lang.InterruptedException
方法：  public  final  void  wait( long  arg0,  int  arg1) throws  java.lang.InterruptedException
方法：  public  final  native  void  wait( long  arg0) throws  java.lang.InterruptedException
方法：  public  boolean  equals(java.lang.Object arg0)
方法：  public  java.lang.String toString()
方法：  public  native  int  hashCode()
方法：  public  final  native  java.lang.Class getClass()
方法：  public  final  native  void  notify()
方法：  public  final  native  void  notifyAll()
******************http: //www.zifangsky.cn**********************
 
本类属性：  private  java.lang.String name;
本类属性：  private  int  age;
公共属性：  public  static  final  java.lang.String WATER;
******************http: //www.zifangsky.cn**********************

五 通过反射调用类中的方法

注：下面的例子使用了前面定义过的javase.reflex.Dog类

（1）调用一般方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package  javase.reflex;
 
import  java.lang.reflect.Constructor;
import  java.lang.reflect.Method;
 
public  class  InvokeDemo {
     public  static  void  main(String[] args) {
         //1 调用的方法无参，而且不涉及类中属性
         {
             try  {
                 Class<?> class1 = Class.forName( "javase.reflex.Dog" );
                 Method method = class1.getMethod( "drink" );
                 method.invoke(class1.newInstance());
             }  catch  (Exception e) {
                 e.printStackTrace();
             } 
             System.out
             .println( "******************http://www.zifangsky.cn**********************\n" );
         }
         
         //2 调用的方法无参，但是涉及到类中的属性
         {
             try  {
                 Class<?> class1 = Class.forName( "javase.reflex.Dog" );
                 Constructor<?>[] cons = class1.getConstructors();         
                 Method method = class1.getMethod( "eat" );
                 method.invoke(cons[ 1 ].newInstance( "旺财" ));   //通过第二个有参数的构造方法初始化name属性
             }  catch  (Exception e) {
                 e.printStackTrace();
             } 
             System.out
             .println( "******************http://www.zifangsky.cn**********************\n" );
         }
         
         //3 调用的方法有参数
         {
             try  {
                 Class<?> class1 = Class.forName( "javase.reflex.Dog" );
                 Method method = class1.getMethod( "introduce" ,String. class , int . class );
                 String ret = (String) method.invoke(class1.newInstance(), "旺财" , 15 );   //有返回值
                 System.out.println(ret);
             }  catch  (Exception e) {
                 e.printStackTrace();
             } 
         }
         
     }
 
}

输出：

1
2
3
4
5
6
7
每天喝水
******************http: //www.zifangsky.cn**********************
 
旺财： 啃骨头 + 吃肉
******************http: //www.zifangsky.cn**********************
 
我的名字是旺财，今年 15 岁了

（2）调用setter和getter方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
package  javase.reflex;
 
import  java.lang.reflect.Method;
 
public  class  InvokeGetSetDemo {
     /**
      * 通过反射调用Getter和Setter方法
      * */
     public  void  TestGetterSetter(){
         try  {
             Class<?> class1 = Class.forName( "javase.reflex.Dog" );
             Object dog = class1.newInstance();   //实例化
             setter(dog,  "name" ,  "大黄" , String. class );
             setter(dog,  "age" ,  4 ,  int . class );
             //输出测试
             System.out.println( "名字： "  + getter(dog,  "name" ));
             System.out.println( "年龄： "  + getter(dog,  "age" ));
                 
         }  catch  (ClassNotFoundException e) {
             e.printStackTrace();
         }  catch  (InstantiationException e) {
             e.printStackTrace();
         }  catch  (IllegalAccessException e) {
             e.printStackTrace();
         }
     }
     /**
      * setter方法
      * @param object 实例化的对象
      * @param str 要设置的属性名称
      * @param value 属性值
      * @param type 属性类型
      * */
     public  void  setter(Object object,String str,Object value,Class<?> type){
         try  {
             //获取setter方法，如：setName。其中要将属性的首字母大写
             Method method = object.getClass().getMethod( "set"  + UpperString(str), type);
             method.invoke(object, value);   //setter方法无返回值
         }  catch  (Exception e) {
             e.printStackTrace();
         }
     }
     
     /**
      * getter方法
      * @param object 实例化的对象
      * @param str 属性名称
      * @return 返回属性
      * 
      * */
     public  Object getter(Object object,String str){
         try  {
             //获取getter方法，如：getName。其中要将属性的首字母大写
             Method method = object.getClass().getMethod( "get"  + UpperString(str));
             return  method.invoke(object);   //getter方法有返回值
         }  catch  (Exception e) {
             e.printStackTrace();
         }
         return  null ;
     }
     
     /**
      * 将字符串的首字母改成大写
      * */
     public  String UpperString(String str){
         return  String.valueOf(str.charAt( 0 )).toUpperCase() + str.substring( 1 );
     }
     
     public  static  void  main(String[] args) {
         new  InvokeGetSetDemo().TestGetterSetter();
 
     }
 
}

输出：

1
2
名字： 大黄
年龄：  4

附：

（1）我们在使用eclipse这类开发工具进行程序开发时，一般在我们输入一个“.”时，就可以提示出这个类的所有方法，这个功能实际上就是用了反射的原理 –> 通过反射获取一个类的所有方法

（2）将Java中的.class文件反编译成.java文件实际上也是应用了反射的原理




本文转自 pangfc 51CTO博客，原文链接：http://blog.51cto.com/983836259/1741355，如需转载请自行联系原作者

文章标签：
域名
Java
关键词：
Java机制
Java反射机制
Java反射
Java基础
Java总结
相关实践学习
基于函数计算快速搭建Hexo博客系统
本场景介绍如何使用阿里云函数计算服务命令行工具快速搭建一个Hexo博客。
技术小阿哥
目录
相关文章
穆雄雄.
|
1月前
|
开发框架 Java API
java反射机制的原理与简单使用
java反射机制的原理与简单使用
穆雄雄.
17 1
请看我回答~
|
2天前
|
Java 数据库连接
深入理解Java异常处理机制
【4月更文挑战第24天】本文将探讨Java中的异常处理机制，包括异常的概念、分类、捕获和抛出等方面。通过深入了解异常处理机制，可以帮助我们编写更加健壮的程序，提高代码的可读性和可维护性。
请看我回答~
9 2
请回答1024
|
2天前
|
Java
Java 反射
Java 反射
请回答1024
5 1
JavaBuild
|
3天前
|
设计模式 Java 索引
由反射引出的Java动态代理与静态代理
由反射引出的Java动态代理与静态代理
JavaBuild
12 0
JavaBuild
|
3天前
|
存储 Java Shell
深入剖析Java中的反射，由浅入深，层层剥离！
深入剖析Java中的反射，由浅入深，层层剥离！
JavaBuild
10 1
桃李春风一杯酒
|
8天前
|
监控 Java 开发者
掌握 Java 反射和动态代理
【4月更文挑战第19天】Java反射和动态代理提供强大功能和灵活性。反射允许运行时检查和操作类，获取类信息、动态调用方法，但可能带来性能损失和降低代码可读性。动态代理则用于创建代理对象，实现透明性和横切关注点分离，常用于日志、权限检查等。两者结合能实现更复杂功能。掌握这些技术能提升代码的灵活性和可扩展性，但也需注意性能和可读性。通过学习和实践，能更好地构建高效软件系统。
桃李春风一杯酒
8 2
薛伟同学
|
14天前
|
Java
代码的魔法师：Java反射工厂模式详解
代码的魔法师：Java反射工厂模式详解
薛伟同学
26 0
程序三两行
|
18天前
|
安全 Java
java反射篇
java反射篇
程序三两行
27 0
程序三两行
|
18天前
|
存储 Java
java反射——设计框架的灵魂
java反射——设计框架的灵魂
程序三两行
19 0
历年考试不作弊
|
21天前
|
安全 Java 调度
深入理解Java中的线程安全与锁机制
【4月更文挑战第6天】 在并发编程领域，Java语言提供了强大的线程支持和同步机制来确保多线程环境下的数据一致性和线程安全性。本文将深入探讨Java中线程安全的概念、常见的线程安全问题以及如何使用不同的锁机制来解决这些问题。我们将从基本的synchronized关键字开始，到显式锁（如ReentrantLock），再到读写锁（ReadWriteLock）的讨论，并结合实例代码来展示它们在实际开发中的应用。通过本文，读者不仅能够理解线程安全的重要性，还能掌握如何有效地在Java中应用各种锁机制以保障程序的稳定运行。
历年考试不作弊
17 4

热门文章

最新文章

  • 1
    Java中的多线程编程：概念、实现与性能优化
  • 2
    基于 java + Springboot + vue +mysql 大学生实习管理系统（含源码）
  • 3
    使用Java代码打印log日志
  • 4
    Java数据结构与算法-java数据结构与算法（二）
  • 5
    【JVM故障问题排查心得】「Java技术体系方向」Java虚拟机内存优化之虚拟机参数调优原理介绍（一）
  • 6
    深入理解Java并发编程：线程安全与性能优化
  • 7
    Java入门高频考查基础知识4（字节跳动面试题18题2.5万字参考答案）
  • 8
    开发语言详解（python、java、Go(Golong)。。。。）
  • 9
    《理解 WebSocket：Java Web 开发的实时通信技术》
  • 10
    java线程池讲解面试
  • 1
    Java中的集合框架：深入理解与应用
    19
  • 2
    Java并发编程：理解并使用Future和Callable接口
    17
  • 3
    性能工具之 Java 调试工具 JDB
    45
  • 4
    JAVA云HIS系统医院信息管理源码
    32
  • 5
    Java基于物联网技术的智慧工地云管理平台源码 依托丰富的设备接口标准库，快速接入工地现场各类型设备
    148
  • 6
    [Java基础]——JVM内存模型
    36
  • 7
    [Java基础]——类的生命周期
    13
  • 8
    [java进阶]——泛型类、泛型方法、泛型接口、泛型的通配符
    23
  • 9
    【java进阶】Java中线程的实现方式
    14
  • 10
    【java进阶】集合的三种遍历(迭代器、增强for、Lambda)
    17

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）