Fundamentals 7 min read

Master Java Fundamentals: From Access Control to Polymorphism

This article provides a concise yet comprehensive guide to core Java concepts, covering access modifiers, aggregation versus inheritance, polymorphism, single-root inheritance, object lifecycle, method signatures, and operator nuances, helping developers build a solid foundation for backend development.

Java One
Java One
Java One
Master Java Fundamentals: From Access Control to Polymorphism

Overview

The author shares a personal learning roadmap for Java backend development, motivated by the need to work with mainstream open‑source frameworks and to deepen understanding of Java after experience with C++, Go, and low‑code platforms.

Objects

1. Access Control

Java uses three keywords— public , private , and protected —to define which parts of a class are visible to callers, allowing library designers to modify internal implementations without breaking external code.

2. Aggregation and Inheritance

Aggregation represents a “has‑a” relationship (e.g., a car has an engine), while inheritance represents an “is‑a” or “is‑like‑a” relationship (e.g., a triangle is a geometric shape). The article includes a UML diagram illustrating the two relationships.

UML diagram of aggregation and inheritance
UML diagram of aggregation and inheritance

3. Polymorphism

Polymorphism relies on late binding, where the JVM determines the actual method implementation at runtime. Unlike C++ which requires the virtual keyword, Java enables late binding by default.

4. Single‑Root Inheritance Structure

All Java classes ultimately inherit from the single root class Object, providing universal capabilities such as heap allocation, garbage collection, and type information.

5. Object Lifecycle

Java objects are allocated exclusively on the heap and reclaimed by the garbage collector, contrasting with C++ where objects may be placed on stack or heap and require manual deallocation. Primitive types reside on the stack, while their wrapper objects live on the heap.

6. Methods, Parameters and Return Values

A method’s signature (name plus parameter list) uniquely identifies it. Java always passes object references, not copies, to methods.

Operators

Java’s primitive comparisons use == or !=. For objects, == compares references; to compare actual content, override and use equals(). Arithmetic on char, byte, and short promotes operands to int, requiring explicit narrowing casts.

Conclusion

The covered sections correspond to chapters 1‑4 of "Thinking in Java", offering a quick yet solid overview of essential Java language features. The author also recommends an online UML‑drawing tool (https://gitmind.com) used to create the diagrams in the article.

JavaprogrammingFundamentalsObject-Oriented
Java One
Written by

Java One

Sharing common backend development knowledge.

0 followers
Reader feedback

How this landed with the community

Sign in to like

Rate this article

Was this worth your time?

Sign in to rate
Discussion

0 Comments

Thoughtful readers leave field notes, pushback, and hard-won operational detail here.