Let me talk about the reflection mechanism of Java.
The reflection mechanism of the Java is a mechanism that is implemented in the running state. From the perspective of a class, one could know all the attributes, methods, and other internal information of any class. From the perspective of an object, you can call any method of any object, get or set its attribute value. Specifically, it had the following functions: 1. To determine the class of an object at run time. 2. Construct an object of any class at run time. 3. To determine the member variables and methods of any class at run time. 4. Calling the member variables and methods of any object at run time. 5. Creating a dynamic agent. The main related APIs include: 1. java.lang.Class: A class. 2. java.lang.reflect.Method: A method that represents a class. 3. java.lang.reflect.Field: A member variable representing the class. 4. java.lang.reflect.Constructor: It represents the construction method of the class. There are several ways to get a class object in Java: 1. Use the class name.class, for example Classclazz = User.class。 2. Use the getClass() method of the object, such as User user = new User(); user.setName("zhangsan"); Classclazz = user.getClass()。 3. Use the Class.forName() method (you need to pass in the fully qualified class name), such as try { Classclazz = Class.forName("com.edwin.java.po.User"); } catch (ClassNotFoundException e) { e.printStackTrace(); }。 In terms of obtaining the construction method and creating the object: 1. Can get all public construction methods, such as Classclazz = User.class; Constructor[] Constructors = clazz.getConstructors(); then traverse the output. 2. You can obtain the construction method of a specific argument and create an object. For example, you can obtain the construction method by passing in the specified argument type, and then use the newInstance() method to create an object. In terms of acquisition methods and usage: 1. Can get all public methods, such as Classclazz = User. class; Method[] methods = clazz.getMethods(); and traverse the output. 2. You can get a specific method and call it. For example, you can get a method named setName with a String argument, and then call it on the object through the invoke() method. In terms of obtaining field attributes and operating them: 1. Can obtain all public attributes, such as Classclazz = User. class; Field[] fields = clazz.getFields(); Traversal output. 2. You can get a specific field attribute and operate on it. For example, you can get an attribute named age and then set the value on the object. In general, the reflection mechanism of Java enabled dynamic programming, allowing programs to obtain information and manipulate objects at run time without having to fully determine this information at compile time. Read more exciting novels for free
The meaning of java-reflection
Reflection was a mechanism that allowed a program to know all the properties, methods, and other information of any class in the running state. It could also obtain this information and call the methods of the object. It allowed the program to query and manipulate the type information of the object at run time. For example, it could directly manipulate the.class file at run time, and it could manipulate the variables, methods, builders, and other information in the class. The java.lang.reflect package provides a set of classes and interface to implement the functions related to reflection, such as the Class class (which can be used to obtain class information), the Field class (which is used to represent the fields of the class), the Method class (which is used to represent the methods of the class), and the Builder class (which is used to represent the builders of the class). Through reflection, you can create objects, call methods, access and modify fields. Reflection is very useful in scenarios such as framework, tools, or dynamic loading classes. However, since it can bypass some access restrictions and bring about a certain performance overhead, it should be used with caution, follow security regulations, and only use it when necessary. <a href="/?from=ask_words" style="color:red" target="_blank">Read more exciting novels for free</a>
java-reflection learning materials
The following are some key points to help you learn how to use reflection: ** 1. Concept Understanding ** 1. ** Concepts ** - In the running state of the program, for any class, all the attributes and methods of the class can be obtained, and for any object, any methods and attributes can be called. For example, before a java-based program runs, the. java-based file will be compiled into a.class file by the virtual machine and executed. Reflection can directly manipulate the.class file while the program is running, so that it can manipulate the variables, methods, builders, and other information in the class. 2. **Class ** - In Java, the Class class and java.lang.reflect class library together provide support for reflection technology. The contents of the Class class were obtained by reading the bytecode of the.class file. The common way to obtain the Class object was Class.forName(). ** 2. Commonly used operations ** 1. ** Builder Class ** - It represents the construction method of the class represented by the Class object, which can be used to create objects at run time. 2. **Field Class ** - It represents the member variable of the class represented by the Class object. It can be used to modify the property value of the member variable at run time. Even the member variable of the private type can be manipulated. 3. **Method Class ** - It represents the member method of the class represented by the Class object. It can be used to call the methods of the object, including the private method. ** 3. The advantages and disadvantages of reflex ** 1. ** Strengths ** - For the entire program, it could achieve sensorless operation and flexibility, and for the framework design, it could better reduce the couple. For example, in the Spring framework of Java, the application of Inversion of Control (IOC) was implemented through reflection. 2. ** Flaws ** - There was a security problem because reflection was retrieving object information in reverse, which destroyed the abstractness of the code. At the same time, because it could bypass restrictions (such as accessing private members), it reduced the reliability and porting of the code. Therefore, it is not recommended to use it outside of the framework. Please use it with caution. <a href="/?from=ask_words" style="color:red" target="_blank">Read more exciting novels for free</a>
java-reflection affects efficiency
The reflection of the java-code will affect the execution efficiency. The reasons were as follows: 1. ** Restrictions on the optimization of the compile **: The JIT compile will perform optimization according to the running condition of the program to improve the efficiency. However, the JIT compile cannot determine the specific method of the reflection call during compilation, and the JIT compile cannot perform static analysis and optimization on it, thus reducing the performance of the reflection. 2. ** Automatic Unboxing Operation **: In reflection, since the compilation process does not know the specific parameters of the method, the most common reference type, Object, is needed to handle all the parameters. This caused the JVs to perform automatic unboxing operations at run-time, converting the Object type into the actual argument type, which added additional overhead. 3. ** Method call overhead **: Reflection will traverse the method array when calling a method, but normal method calls do not need this traverse operation, which will increase the time overhead of reflection calls. 4. ** Security check **: Reflection operation has a certain performance overhead and potential security issues. However, you can skip the security check (you can read the private property) by using setEasily (true) to increase the program's running efficiency by four times. In summary, although reflection provided powerful capabilities for developers, in scenarios with high performance requirements, the reflection mechanism should be used with caution to avoid unnecessary performance loss. Whenever possible, use static type checking and direct method calls to improve the execution efficiency of the program. <a href="/?from=ask_words" style="color:red" target="_blank">Read more exciting novels for free</a>
java-reflection assigning values to attributes
以下是通过Java反射给属性赋值的步骤： 首先，准备一个类，例如有如下的`Teacher`类： ```java class Teacher { private int userId; private String userName; public int getUserId() { return userId; } public String getUserName() { return userName; } private void hello(String name, Integer userId) { System.out.println("Hello World," + name + ", " + userId); } } ``` 若要给这个类的属性通过反射赋值，可以这样做： 1. 获取类的`Class`对象： - 如果已经有类的实例对象，可以通过`obj.getClass()`获取，例如`Teacher`类的实例`teacher`，可以用`teacher.getClass()`。 - 如果没有实例对象，可以直接通过`Class.forName("完整类名")`获取，如`Class.forName("Teacher所在的包名.Teacher")`。 2. 获取类中的所有属性（包括私有属性）：通过`Class`对象调用`getDeclaredFields()`方法得到属性数组。 3. 遍历属性数组，对每个属性进行操作： - 先设置属性可访问（因为属性可能是私有的），通过`field.setAccessible(true)`。 - 然后给属性赋值，假设我们有一个`Map`对象`map`，其中包含了要赋给`Teacher`类属性的值（`map`中的键为属性名，值为要赋的值），可以通过`field.set(newEntity,map.get(field.getName()))`给属性赋值，这里的`newEntity`是`Teacher`类的实例对象（通过`clazz.newInstance()`创建，不过要处理好可能的异常情况）。 例如下面这种通过反射将`Map`中的值赋给类对象对应属性的代码： ```java import java.lang.reflect.Field; import java.util.Map; public class MapToPOJOExample { public static <T> T mapToPOJO(Map map, Class clazz) { Field[] declaredFields = clazz.getDeclaredFields(); Object newEntity = null; try { newEntity = clazz.newInstance(); } catch (Exception e) { // 处理获取实例对象失败的异常 } for (Field field : declaredFields) { field.setAccessible(true); try { if (map.get(field.getName())!= null) { field.set(newEntity, map.get(field.getName())); } } catch (IllegalAccessException e) { // 处理属性赋值失败的异常 } } return (T) newEntity; } } ``` <a href="/?from=ask_words" style="color:red" target="_blank">点击前往免费阅读更多精彩小说</a>
Why is java-based reflection poor?
The main reasons for the poor reflection performance of Java are as follows: 1. ** Restrictions on the optimization of the compile **: The compilation process of the code is uncertain. It may involve a front-end compile, a just-in-time compile (JIT), or a static ahead of time compile (AOT). The JIT's run-time optimization was more important to the program's operation, and the code optimization of the Java Virtual Machine was carried out here. However, since reflection involved dynamic analysis of types, it was unable to perform some optimization of the Java Virtual Machine, resulting in lower performance than non-reflection operations. 2. ** Dynamic type checking and safety checking **: Reflection operations involve dynamic type checking and safety checking, which increases overhead and affects performance. 3. **Method#invoke related operations **: Method#invoke will seal and unseal the parameters. It also needs to check the visibility of the method and verify the parameters. These operations will cause performance loss. 4. ** The reflection method is difficult to inline **: The reflection method is difficult to inline, which also makes its performance poor. <a href="/?from=ask_words" style="color:red" target="_blank">Read more exciting novels for free</a>
The application of java-reflection in data access
In terms of data access, there were certain applications for reflection: 1. ** Databank Driver Loading **: When the underlying database of the project is not fixed, sometimes it is Mystical, sometimes it is Oracle, or other database, the driver class needs to be loaded according to the actual situation. At run-time, the java-reflection could load the corresponding database driver class according to the configuration or conditions, which could interact with different database and increase the flexibility of data access. 2. ** Data access related applications in the framework (such as Spring framework)** - **Spring IOC-Inversion of Control **: In Spring IOC-configuration, various beans can be deployed through configuration files. When a bean instance needs to be obtained for data access operations, such as inquiring data from the database or storing data into the database, it will involve the use of the reflection of the code. Through reflection, Spring can create and manage these bean instances based on configuration information without the need to hard-code the code, which makes the data access layer easier to maintain and extend. - **Spring AOP (Aspect-oriented programming)**: The Spring AOP's dynamic agent function is related to the reflection function of the browser. When performing data access, for example, when performing transaction management, log recording, and other crosscutting concerns on database operations, the reflection mechanism could be used to create a dynamic agent object. On the basis of not modifying the core code of data access, the functions in the data access process could be enhanced, such as logging before data query, or starting, submitting, or rolling back transactions during data update operations. 3. ** Obtain class member variable information for data access **: In some scenarios, you may need to obtain class member variables to construct database query statements or perform data maps. Through reflection, you can obtain the member variables of the class (for example, through methods such as `getDeclaredFields`) to determine the structure and type information of the data, so as to better perform data access operations. For example, you can map the attribute values of the object to the fields of the database table. <a href="/?from=ask_words" style="color:red" target="_blank">Read more exciting novels for free</a>
How to improve the reflection mechanism? Simple design
The following are some simple ideas for the reflection mechanism optimization design: - ** Performance optimization **: - When the reflection mechanism affects the performance of the application, you can consider using traditional object manipulation methods to replace reflection in appropriate places. For example, in Golang, if you don't need the dynamic nature provided by reflection, you can directly access fields or methods by type. Because reflection operations are slower than directly calling methods or accessing fields, it requires additional security checks and search operations. The same was true in Java. Direct calls performed better than reflective calls, so unnecessary dynamic operation scenarios could avoid using reflection. - In a performance sensitive scenario, if reflection is necessary, you can use the buffer mechanism to improve performance. For example, when obtaining the same type of information or operating on the same member multiple times, the results obtained by reflection would be stored in the buffer to avoid the overhead of repeated reflection operations. - ** In terms of error handling **: - When using the reflection mechanism, you should add appropriate error handling logic to ensure that the program can run normally in the face of abnormal situations. For example, in Golang's reflex operation, try... The catch statement was used to catch errors in the operation, such as catching possible errors when using Reflect.set. - ** Security risks **: - Since reflection can bypass the access control qualifier (such as private in Java) and access private members, breaking the class's wrapper brings security risks. In the design, this ability must be treated with caution. Only when it was necessary and controllable would it be used to reflect private members. Security assessments and precautions must be done, such as strictly limiting the scope of code and permission to reflect private members. <a href="/?from=ask_words" style="color:red" target="_blank">Read more exciting novels for free</a>
Java novels
As a fan of web novels, I don't have the ability to actually read novels. However, I can provide you with some novel recommendations on programming in Java. If you want to read a novel about programming, I recommend you to read the book,"Thoughts on programming with java.com." This book is the autobiography of a Java developer. It tells the author's practical experience and thinking process in the field of Java programming. The book not only covers the core concepts and grammar of the programming language, but also provides an in-depth discussion of the application and optimization methods of the programming language. Also, if you want to know more about the storyline of the game, I can recommend some novels about the game. For example, you can read the book "The Java Coders", which tells how a group of Java developers challenged various programming problems and developed amazing applications. Also, you can read the book, The Java Development Life Cycle, which talks about the life cycle methods and tools in the development of Java. I hope these recommendations can meet your needs.
What are the main features of Java Man in the Java Man story?
One main feature is its bipedal nature. Java Man walked on two legs.
Proficiency mechanism
The proficiency mechanism referred to the increase in the proficiency level of the character through performance and completion of specific tasks in the game. Different games had different proficiency mechanisms. For example, League of Legends and Naruto both had proficiency bonus mechanisms. In League of Legends Mobile, players could obtain proficiency and hero points by obtaining an S-rank evaluation, an A-rank evaluation, and victory in the qualifying matches. In Naruto Mobile Games, players needed to accumulate a certain amount of proficiency points to increase their proficiency level. Other games such as Dungeon Fighter Online and Scarlet Scar Night Ritual had a similar proficiency system. Players could increase their proficiency levels by completing missions and clearing dungeons. In general, the proficiency mechanism could help players improve their character's skills and strength. At the same time, it also provided players with rich rewards and advantages.