Difference: 1. Value transfer creates a copy, while reference transfer does not create a copy; 2. The original object cannot be changed in the function during value transfer, but the original object can be changed in the function during reference transfer. Passing by value means that a copy of the actual parameters is passed to the function when calling the function, so that if the parameters are modified in the function, the actual parameters will not be affected; passing by reference means that the actual parameters are copied when calling the function. The address is passed directly to the function, so modifications to the parameters in the function will affect the actual parameters.
The operating environment of this tutorial: windows7 system, java8 version, DELL G3 computer.
actual and formal parameters
We all know that parameters can be defined when defining a method in Java. For example, the main method in Java, public static void main(String[ ] args), the args here are parameters. Parameters are divided into formal parameters and actual parameters in programming languages.
Formal parameters: are the parameters used when defining the function name and function body. The purpose is to receive the parameters passed in when calling the function.
Actual parameters: When calling a parameterized function, there is a data transfer relationship between the calling function and the called function. When calling a function in the calling function, the parameters in parentheses after the function name are called "actual parameters"
A simple example:
public static void main( String[ ] args) {
ParamTest pt = new ParamTest();
pt.sout( "Hollis");//實(shí)際參數(shù)為Hollis
}
public void sout( String name) {/!形式參數(shù)為name
system.out.println(name);
}
The actual parameters are The content that is actually passed when calling a method with parameters, and the formal parameters are the parameters used to receive the content of the actual parameters.
Value passing and reference passing
As mentioned above, when we call a parameterized function, the actual parameters will be passed to the formal parameters. However, in programming languages, there are two cases of transfer in this transfer process, namely transfer by value and transfer by reference. Let's take a look at how passing by value and passing by reference are defined and distinguished in programming languages.
Value passing refers to copying a copy of the actual parameters to the function when calling the function, so that if the parameters are modified in the function, the actual parameters will not be affected. Passing by reference refers to passing the address of the actual parameters directly to the function when calling the function. Then the modification of the parameters in the function will affect the actual parameters.
With the above concepts, you can then write code and practice it. Let’s see whether it is value passing or reference passing in Java. So, the simplest piece of code came out:
public static void main( String[] args) {
ParamTest pt = new ParamTest();
int i = 10;
pt.pass(i);
System.out.println( "print in main , i is " +i);
}
public void pass(int j){
j = 20;
system.out.println( "print in pass , j is " + j);
}
In the above code, we modify the value of parameter j in the pass method, and then print the value of the parameter in the pass method and main method respectively. The output result is as follows:
print in pass , j is 20
print in main , i is 10
It can be seen that the modification of the value of i inside the pass method does not change the value of the actual parameter i. So, according to the above definition, someone came to the conclusion: Java's method passing is value passing. However, some people soon raised questions (haha, so don’t jump to conclusions easily.). Then, they will move out the following code:
public static void main(String[ ] args) {
ParamTest pt = new ParamTest();
User hollis = new User();
hollis.setName( "Hollis");
hollis.setGender("Male");
pt.pass(hollis);
system.out.println( "print in main , user is " + hollis);}public void pass(User user) {
user.setName( "hollischuang");
System.out.println( "print in pass , user is " + user);}
is also a pass method, and the value of the parameter is also modified within the pass method. The output result is as follows:
print in pass , user is User{name='hollischuang', gender='Male '}
print in main , user is User{name='hollischuang' , gender='Male '}
After the pass method is executed, the value of the actual parameter is changed. According to the definition of passing by reference above, the value of the actual parameter is changed. Isn’t this called passing by reference? . Therefore, based on the above two pieces of code, someone came to a new conclusion: in Java methods, when passing ordinary types, it is passed by value, and when passing object types, it is passed by reference. However, this statement is still wrong. If you don’t believe me, take a look at the following parameter transfer where the parameter type is an object:
public static void main( string[] args) {
ParamTest pt = new ParamTest();
string name = "Hollis";
pt.pass(name ) ;
System.out.println( "print in main , name is " + name);
}
public void pass(string name) {
name = "hollischuang";
system.out.println( "print in pass , name is " + name);
}
The output result of the above code is
print in pass , name is hollischuangprint in main , name is Hollis
What’s the explanation? An object is also passed, but the original parameter is The value has not been modified. Could it be that the transferred object has become a value transfer again?
Value transfer in Java
Above, we gave three examples to show the The results are different, which is why many beginners and even many advanced programmers are confused about Java's transfer types. In fact, what I want to tell you is that the above concept is not wrong, but there is a problem with the code example. Come on, let me outline the key points of the concept for you, and then give you a few truly appropriate examples.
Value passing refers to copying a copy of the actual parameters to the function when calling the function, so that if the parameters are modified in the function, the actual parameters will not be affected. Passing by reference refers to passing the address of the actual parameters directly to the function when calling the function. Then the modification of the parameters in the function will affect the actual parameters.
So, let me summarize for you the key points of the difference between value passing and reference passing.
##Pass by value
Pass by reference
Fundamental difference
Will create a copy
Does not create a copy
All
The original object cannot be changed in the function
The original object can be changed in the function
public static void main(String[ ] args){
ParamTest pt = new ParamTest();
User hollis = new User();
hollis.setName( "Hollis");
hollis.setGender("Male" );
pt.pass(hollis);
system.out.println("print in main , user is " + hollis);
public void pass(User user) {
user = new User();
user.setName( "hollischuang");
user.setGender( "Male");
system.out.println( "print in pass , user is " + user);
上面的代碼中，我們?cè)趐ass方法中，改變了user對(duì)象，輸出結(jié)果如下:
print in pass , user is User{name='hollischuang ' , gender='Male '}
print in main , user is User{name='Hollis', gender= 'Male '}
Passing by sharing means that when a function is called, a copy of the address of the actual parameter is passed to the function (if the actual parameter is on the stack, the value is copied directly). When operating parameters inside a function, you need to copy the address to find the specific value before operating. If the value is on the stack, then because it is a direct copy of the value, operations on the parameters within the function will not affect external variables. If the original copy is the address of the original value in the heap, then you need to find the corresponding location in the heap based on the address before performing the operation. Because a copy of the address is passed, the operation on the value within the function is visible to the external variable.
To put it simply, transfer in Java is by value, and this value is actually a reference to the object. Passing by sharing is actually just a special case of passing by value. So we can say that passing in Java is passing by sharing, or that passing in Java is passing by value.
So operating parameters inside the function will not affect external variables. If the original copy is the address of the original value in the heap, then you need to find the corresponding location in the heap based on the address before performing the operation. Because a copy of the address is passed, the operation on the value within the function is visible to the external variable.
To put it simply, transfer in Java is by value, and this value is actually a reference to the object.
Passing by sharing is actually just a special case of passing by value. So we can say that passing in Java is passing by sharing, or that passing in Java is passing by value.
The above is the detailed content of What is the difference between pass by value and pass by reference in java. For more information, please follow other related articles on the PHP Chinese website!
Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
The settings.json file is located in the user-level or workspace-level path and is used to customize VSCode settings. 1. User-level path: Windows is C:\Users\\AppData\Roaming\Code\User\settings.json, macOS is /Users//Library/ApplicationSupport/Code/User/settings.json, Linux is /home//.config/Code/User/settings.json; 2. Workspace-level path: .vscode/settings in the project root directory
To correctly handle JDBC transactions, you must first turn off the automatic commit mode, then perform multiple operations, and finally commit or rollback according to the results; 1. Call conn.setAutoCommit(false) to start the transaction; 2. Execute multiple SQL operations, such as INSERT and UPDATE; 3. Call conn.commit() if all operations are successful, and call conn.rollback() if an exception occurs to ensure data consistency; at the same time, try-with-resources should be used to manage resources, properly handle exceptions and close connections to avoid connection leakage; in addition, it is recommended to use connection pools and set save points to achieve partial rollback, and keep transactions as short as possible to improve performance.
itertools.combinations is used to generate all non-repetitive combinations (order irrelevant) that selects a specified number of elements from the iterable object. Its usage includes: 1. Select 2 element combinations from the list, such as ('A','B'), ('A','C'), etc., to avoid repeated order; 2. Take 3 character combinations of strings, such as "abc" and "abd", which are suitable for subsequence generation; 3. Find the combinations where the sum of two numbers is equal to the target value, such as 1 5=6, simplify the double loop logic; the difference between combinations and arrangement lies in whether the order is important, combinations regard AB and BA as the same, while permutations are regarded as different;
fixture is a function used to provide preset environment or data for tests. 1. Use the @pytest.fixture decorator to define fixture; 2. Inject fixture in parameter form in the test function; 3. Execute setup before yield, and then teardown; 4. Control scope through scope parameters, such as function, module, etc.; 5. Place the shared fixture in conftest.py to achieve cross-file sharing, thereby improving the maintainability and reusability of tests.
java.lang.OutOfMemoryError: Javaheapspace indicates insufficient heap memory, and needs to check the processing of large objects, memory leaks and heap settings, and locate and optimize the code through the heap dump analysis tool; 2. Metaspace errors are common in dynamic class generation or hot deployment due to excessive class metadata, and MaxMetaspaceSize should be restricted and class loading should be optimized; 3. Unabletocreatenewnativethread due to exhausting system thread resources, it is necessary to check the number of threads, use thread pools, and adjust the stack size; 4. GCoverheadlimitexceeded means that GC is frequent but has less recycling, and GC logs should be analyzed and optimized.
Use classes in the java.time package to replace the old Date and Calendar classes; 2. Get the current date and time through LocalDate, LocalDateTime and LocalTime; 3. Create a specific date and time using the of() method; 4. Use the plus/minus method to immutably increase and decrease the time; 5. Use ZonedDateTime and ZoneId to process the time zone; 6. Format and parse date strings through DateTimeFormatter; 7. Use Instant to be compatible with the old date types when necessary; date processing in modern Java should give priority to using java.timeAPI, which provides clear, immutable and linear
Java
