Скачать или смотреть Understanding the + Operator in Java: Does It Create New Objects?

Discover how the `+ ` operator functions in Java, and learn why it creates new objects rather than adding values in place.
---
This video is based on the question https://stackoverflow.com/q/62846468/ asked by the user 'Tashkhisi' ( https://stackoverflow.com/u/12867091/ ) and on the answer https://stackoverflow.com/a/62846596/ provided by the user 'Stephen C' ( https://stackoverflow.com/u/139985/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: (Add value to number in place) How + operator work in java?

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding the + Operator in Java: Does It Create New Objects?

When working with numerical operations in Java, you might come across the + operator and wonder how it functions behind the scenes. A common scenario is adding two Long numbers together, such as:

[[See Video to Reveal this Text or Code Snippet]]

In this situation, the main questions arise: Does the third statement create another Object that contains the sum of number1 and number2? Wouldn't it be better to have a method like number1.addValue(number2) to add number2 to number1 in place without creating a new object?

Does Adding Numbers Create a New Object?

The straightforward answer to the first question is yes, it does create a new object. Every time you use the + operator with wrapper classes such as Long, you're not modifying the existing objects but rather creating a new one that contains the result of the addition.

Why Not Use number1.addValue(number2)?

The second question about whether we could have a method like number1.addValue(number2) leads us to a crucial understanding of Java's object model, specifically regarding immutable objects. To understand this better, let's clarify a couple of key points:

Primitive Wrapper Classes Are Immutable: Java’s wrapper classes, including Long, are designed to be immutable. This means once an object is created, its value cannot be changed. You cannot modify number1 directly by adding number2 to it.

Implications of Mutability: If wrapper classes were mutable, it would lead to significantly more complex programming constructs involving boxing and unboxing. Consider the following hypothetical code:

[[See Video to Reveal this Text or Code Snippet]]

In this example, if sum could modify five, you would end up affecting five’s value. After the operation, five would equal 15, making it confusing and potentially unsafe for developers who expect it to hold its original value.

Understanding the Comparison of Wrapper Classes

Java treats equality in a way that can be counterintuitive, especially with wrapper classes. Here is a common scenario:

[[See Video to Reveal this Text or Code Snippet]]

In this code:

The first print statement returns true because the .equals() method checks for value equality.

The second print statement returns false due to reference equality; one_million and one_million_again point to different objects in memory, even though they have the same value.

Conclusion

Understanding how the + operator works in Java, especially with wrapper classes, is crucial for effectively leveraging Java’s capabilities. While it may seem advantageous to have an in-place addition method, the immutability of these objects ultimately leads to safer and less error-prone code. This design choice simplifies the complexities of coding with Java, making it easier for programmers to manage their data without the headaches inherent in mutable object states.

By grasping these principles, you will have a clearer understanding of Java's operational behavior and how it handles object-oriented programming, especially concerning the + operator.