Скачать или смотреть Understanding Inheritance in Java: Why Members Are Not Shared Between Builders

Discover the key insights into Java inheritance and learn why `Person` members in builder classes behave differently. Enhance your coding skills with this comprehensive guide!
---
This video is based on the question https://stackoverflow.com/q/62209702/ asked by the user 'skyquake' ( https://stackoverflow.com/u/8531004/ ) and on the answer https://stackoverflow.com/a/62209790/ provided by the user 'raggedycoder' ( https://stackoverflow.com/u/2405872/ ) 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: Inheritance in Java and how are members inherited

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 Inheritance in Java: Why Members Are Not Shared Between Builders

Inheritance in Java can sometimes lead to confusion, especially when dealing with multiple classes that extend from a common base class. A recent inquiry regarding the Builder Design Pattern highlighted a crucial misunderstanding related to object references in this context. In this guide, we will explore the problem and provide a clear explanation of what's happening under the hood.

The Problem

When using a builder pattern in Java, a developer encountered surprising results while trying to share a Person object between different builders. The expectation was that updating the name in DetailsBuilder and the org in JobBuilder would reflect on the same Person instance, but the output showed two different instances:

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

Code Breakdown

To understand the issue, let’s take a look at the relevant code snippets. Here are the main parts of the implementation:

Person Class: Defines attributes name and org.

PersonBuilder: Contains a Person object and methods to create instances of DetailsBuilder and JobBuilder.

DetailsBuilder and JobBuilder: Both extend PersonBuilder and make changes to the Person data.

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

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

The Misunderstanding

The confusion arises from the PersonBuilder design. Each time a builder (DetailsBuilder or JobBuilder) is instantiated, a new instance of PersonBuilder is created. This leads to the creation of separate instances of Person, each with their own name and org properties. Thus, when modifications are made in one builder, the changes do not propagate to other builders because they are working on different Person instances.

Solution: Share the Same Person Instance

To ensure that all builders operate on the same Person instance, we need to modify the design so that DetailsBuilder and JobBuilder share a reference to the same Person object. Here’s how to achieve that:

Pass the Person Reference: Modify the constructors of DetailsBuilder and JobBuilder to accept a reference to the Person object from PersonBuilder.

Example Implementation:

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

Conclusion

By adjusting the design of the builder classes to share the same instance of Person, we can ensure that modifications in one builder class will reflect in any other builder that accesses that Person object. This eliminates confusion and aligns behavior with expectations.

If you are implementing the Builder Design Pattern in Java, remember to always consider how object references are managed between your builder classes. This understanding is fundamental to producing effective and bug-free code.

Happy coding!