A structured Java learning ecosystem documenting my journey from Core Java fundamentals to advanced JVM internals while building a comprehensive Java OOP Handbook, interview-oriented notes, practical programs, and automated learning progress.
Last updated: 2026-07-23 19:20 UTC · 42 day(s) logged
Welcome to my Java learning journey.
This repository is much more than a collection of Java programs.
It is a long-term knowledge base that documents everything I learn while mastering Java—from writing my very first programs to understanding how the JVM executes bytecode internally.
Instead of only focusing on syntax, this repository emphasizes understanding how Java works internally, why language features behave the way they do, and how those concepts are used in real-world software development.
Every topic is learned, implemented, documented, and organized into dedicated folders with notes, programs, assignments, and resources.
Alongside the daily learning journey, this repository also contains a complete Java OOP Handbook consisting of 40 carefully structured chapters, transforming personal learning notes into a public reference for students, interview preparation, and developers.
The repository continues to evolve every day through practical coding, structured notes, and GitHub Actions automation.
This repository is built around a few long-term goals.
- ✅ Build a rock-solid understanding of Core Java.
- ✅ Learn Java beyond syntax by understanding JVM internals.
- ✅ Master Object-Oriented Programming through practical implementation.
- ✅ Build a comprehensive Java OOP Handbook.
- ✅ Practice consistently through daily coding sessions.
- ✅ Create a reusable reference for interview preparation.
- ✅ Write clean, readable, and maintainable Java code.
- ✅ Document every important concept with examples.
- ✅ Understand modern Java features introduced after Java 8.
- 🎯 Become placement-ready for Java Backend Development roles.
- 🎯 Build a strong foundation for Spring Boot, Microservices, and System Design.
Most developers learn Java by memorizing syntax.
My goal is different.
I want to understand why Java behaves the way it does.
Whenever I learn a topic, I try to answer questions like:
- Why does this feature exist?
- How is it implemented internally?
- What problem does it solve?
- How does the JVM handle it?
- Where is it used in production software?
- What interview questions are commonly asked about it?
Instead of rushing toward frameworks, I believe mastering the fundamentals first makes learning advanced technologies significantly easier.
This repository reflects that philosophy.
Every concept is accompanied by code, notes, explanations, practical observations, and references so that future revision becomes effortless.
This repository currently includes:
- 📚 Structured Java Learning Journey
- 📚 Complete 40-Chapter Java OOP Handbook
- ☕ JVM Internals Exploration
- 💻 Topic-wise Java Programs
- 📝 Detailed Markdown Notes
- 📂 Practice Assignments
- 🤖 GitHub Actions Automation
- 📈 Auto-generated Progress Tracking
- 🎯 Interview-Oriented Explanations
- 📖 External Learning Resources
- 🔄 Continuous Repository Improvements
| Phase | Topics | Status |
|---|---|---|
| 1. Java Fundamentals | Data Types, Variables, Operators, Type Casting, Control Statements, IO, Arrays, Strings, Wrapper Classes, Integer Cache | ✅ Completed |
| 2. Object-Oriented Programming | Classes, Objects, Constructors, Methods, Encapsulation, Inheritance, Polymorphism, Abstraction, Interfaces, Object Class, Packages, Modern Java OOP | ✅ Completed |
| 3. Core Java APIs | Collections Framework, Exception Handling, Generics, File I/O, NIO, Reflection, Annotations | 🟢 In Progress |
| 4. Modern Java | Lambda Expressions, Functional Interfaces, Streams API, Optional, Date & Time API, Records, Sealed Classes | 🟢 In Progress |
| 5. Multithreading & Concurrency | Threads, Runnable, Executors, Synchronization, Locks, Concurrent Collections | ⚪ Upcoming |
| 6. JVM Internals | Memory Management, Garbage Collection, Class Loading, Method Dispatch, Bytecode, JIT Compiler | 🟢 Ongoing Exploration |
| 7. Advanced Java | JDBC, Reflection, Serialization, Networking, Design Patterns | ⚪ Upcoming |
| 8. Java Backend Development | Spring Boot, Spring MVC, Spring Security, Hibernate, REST APIs | ⚪ Planned |
| 9. System Design | Low-Level Design, High-Level Design, Distributed Systems | ⚪ Planned |
Current Status
- ✅ Java Fundamentals Completed
- ✅ Java OOP Handbook Completed
- 🟢 Expanding Core Java Knowledge
- 🟢 Preparing for Backend Development
- 🎯 Building a strong foundation before Spring Boot
One of the major milestones of this repository is the Java OOP Handbook—a structured, chapter-wise handbook covering Java Object-Oriented Programming from the absolute fundamentals to advanced concepts, JVM internals, and modern Java features.
Unlike traditional notes, this handbook was built while learning each concept, then continuously refined into a public reference for students, interview preparation, and Java developers.
Every chapter contains:
- 📖 Concept Explanation
- 💡 Real-world Examples
- ☕ Java Programs
- 🧠 Interview Notes
- ⚙️ Internal Working (where applicable)
- 🎯 Best Practices
- 🚀 Modern Java Features
- 📌 Key Takeaways
- 📚 Learning Resources
The handbook currently consists of 40 carefully organized chapters, grouped into logical learning phases instead of isolated topics.
📘 Part I — Foundations of Object-Oriented Programming
| No. | Chapter |
|---|---|
| 01 | Introduction to Object-Oriented Programming |
| 02 | Class |
| 03 | Object |
| 04 | Constructors |
| 05 | Instance Variables |
| 06 | Static Variables |
| 07 | Local Variables |
| 08 | Variable Shadowing |
| 09 | Instance Methods |
| 10 | Static Methods |
| 11 | Method Overloading |
🏗️ Part II — Object Creation & Java Keywords
| No. | Chapter |
|---|---|
| 12 | Instance Initialization Block |
| 13 | Static Initialization Block |
| 14 | this Keyword |
| 15 | static Keyword |
| 16 | final Keyword |
| 17 | super Keyword |
🏛️ Part III — Core OOP Principles
| No. | Chapter |
|---|---|
| 18 | Encapsulation |
| 19 | Inheritance |
| 20 | Polymorphism |
| 21 | Abstraction |
| 22 | Interface |
| 23 | Object Class |
🧩 Part IV — Object Relationships & Project Design
| No. | Chapter |
|---|---|
| 24 | Association |
| 25 | Aggregation |
| 26 | Composition |
| 27 | Access Modifiers |
| 28 | Packages |
🚀 Part V — Modern Java & Advanced Object-Oriented Programming
| No. | Chapter |
|---|---|
| 29 | Nested Classes |
| 30 | Anonymous Classes |
| 31 | Enums |
| 32 | Records |
| 33 | Sealed Classes |
| 34 | Immutability |
| 35 | Object Cloning |
| 36 | Reflection |
| 37 | Annotations |
| 38 | Generics |
| 39 | Comparable vs Comparator |
☕ Part VI — JVM Internals & Software Design
| No. | Chapter |
|---|---|
| 40 | SOLID Principles |
| 41 | Dependency Injection |
| 42 | Object Lifecycle |
| 43 | JVM Memory Management |
| 44 | Garbage Collection |
| 45 | Class Loading Mechanism |
| 46 | Method Dispatch |
The Java OOP Handbook was created with four primary goals:
- Build a deep understanding of Object-Oriented Programming.
- Learn Java beyond syntax by understanding the JVM.
- Prepare for technical interviews through concept-oriented learning.
- Create a long-term public reference that continues growing alongside this repository.
Although the handbook is completed in its current form, it is a living document. As I learn new Java features, discover better explanations, or gain real-world experience through projects and backend development, the handbook will continue to evolve.
Learning never really finishes. This handbook represents my current understanding of Java and will grow as my experience grows.
This repository is designed to be self-maintaining.
Instead of manually updating the README after every learning session, I built an automated workflow that keeps the repository synchronized with my progress.
The entire learning journey is driven by a single source of truth:
progress.yml
Every study session is recorded inside progress.yml, including:
- Learning Day
- Date
- Topic
- Folder
- Key Concepts
- Learning Resources
Whenever the file is updated and pushed to GitHub, a GitHub Actions workflow automatically regenerates the following sections inside this README:
- Last Updated
- Learning Progress
- Progress Log
- Notes & Key Takeaways
- Learning Resources
No manual copy-pasting.
No duplicated information.
Everything stays synchronized automatically.
Study Session
│
▼
Update progress.yml
│
▼
Git Push
│
▼
GitHub Actions
│
▼
Generate README Sections
│
▼
Commit Updated README
The philosophy is simple:
Write once. Generate everywhere.
This makes the repository easier to maintain while ensuring the documentation always stays consistent with the actual learning progress.
📦 java-learning-journey
│
├── 📂 Topics
│ │
│ ├── Datatypes
│ ├── JVM_Architecture
│ ├── Operators
│ ├── TypeCasting
│ ├── ControlStatements
│ ├── IO
│ ├── Arrays
│ ├── IntegerCache
│ ├── CommandLineArgs
│ ├── Variables
│ ├── Varargs
│ │
│ ├── Strings
│ │ ├── String
│ │ ├── StringBuilder
│ │ ├── StringBuffer
│ │ ├── StringPool
│ │ ├── StringTokenizer
│ │ └── notes.md
│ │
│ ├── WrapperClasses
│ │
│ └── OOP
│ ├── ClassesAndObjects
│ └── OOP_Handbook
│
├── 📂 Assignments
│ ├── Basics
│ ├── Operators
│ ├── Arrays
│ └── ...
│
├── 📄 progress.yml
│
├── 🤖 .github
│ └── workflows
│
└── 📄 README.md
The repository is organized by topic rather than by date, making it easier to revisit concepts whenever needed.
Every topic folder generally contains:
- Java Programs
- Practice Problems
- Markdown Notes
- Interview Questions
- Real-world Examples
- Learning Resources
Whether you're a beginner or revising Java before interviews, this repository is designed to be explored in multiple ways.
Follow the learning roadmap from beginning to end.
Java Basics
↓
Object-Oriented Programming
↓
Core Java APIs
↓
Modern Java
↓
JVM Internals
↓
Advanced Java
↓
Backend Development
This approach mirrors my own learning journey.
Already know Java?
Simply open the topic you're interested in.
Examples:
- Strings
- Wrapper Classes
- JVM
- OOP Handbook
- Integer Cache
- Collections
- Reflection
This repository is designed so each topic can also be studied independently.
Preparing for placements?
Use this repository as a revision guide.
Every major topic includes:
- Concepts
- Programs
- Best Practices
- Common Interview Questions
- Internal Working
- Important Notes
This repository documents every significant learning session.
Rather than rushing through topics, the focus is on understanding concepts deeply before moving forward.
The progress log below is automatically generated from progress.yml.
As new sessions are added, the table updates automatically through GitHub Actions.
The following sections are auto-generated.
Please do not edit them manually.
| Date | Day | Topic | Folder |
|---|---|---|---|
| 2026-05-26 | 1 | Java Data Types – Understanding Primitive & Reference Types | Topics/Datatypes |
| 2026-05-26 | 2 | JVM Architecture – Understanding How Java Executes Code | Topics/JVM_Architecture |
| 2026-06-02 | 3 | Operators in Java – Expressions, Evaluation & Bitwise Operations | Topics/Operators |
| 2026-06-14 | 4 | Type Casting – Primitive Conversions and Data Loss | Topics/TypeCasting |
| 2026-06-16 | 5 | Control Statements – Decision Making & Iteration | Topics/ControlStatements |
| 2026-06-17 | 6 | Input & Output – Scanner, BufferedReader and Console Input | Topics/IO |
| 2026-06-18 | 7 | Arrays – Fundamentals, Memory & Traversal | Topics/Arrays |
| 2026-06-19 | 8 | Arrays – Practice Problems & Multi-dimensional Arrays | Topics/Arrays |
| 2026-06-20 | 9 | Integer Cache & Wrapper Classes – Autoboxing Internals | Topics/IntegerCache |
| 2026-06-21 | 10 | Command Line Arguments – Passing Runtime Parameters | Topics/CommandLineArgs |
| 2026-06-22 | 11 | Variables in Java – Scope, Lifetime & Memory | Topics/Variables |
| 2026-06-23 | 12 | Varargs – Variable Length Arguments | Topics/Varargs |
| 2026-06-29 | 13 | String – Immutability, Pool & Essential Methods | Topics/Strings/String |
| 2026-06-29 | 14 | StringBuilder – Efficient Mutable Strings | Topics/Strings/StringBuilder |
| 2026-06-30 | 15 | StringBuffer – Thread-safe Mutable Strings | Topics/Strings/StringBuffer |
| 2026-07-01 | 16 | String Pool – JVM Memory & Interview Concepts | Topics/Strings/StringPool |
| 2026-07-02 | 17 | StringTokenizer – Tokenizing Text Data | Topics/Strings/StringTokenizer |
| 2026-07-05 | 18 | Wrapper Classes – Object Representation of Primitive Types | Topics/WrapperClasses |
| 2026-07-07 | 19 | Classes & Objects – Building Blocks of Object-Oriented Programming | Topics/OOP/ClassesAndObjects |
| 2026-07-08 | 20 | Introduction to OOP, Class & Object – Foundations of Java Object-Oriented Programming | Topics/OOP/OOP_Handbook/01_Introduction_to_OOP |
| 2026-07-09 | 21 | Constructors & Instance Variables – Object Initialization | Topics/OOP/OOP_Handbook |
| 2026-07-10 | 22 | Static Variables & Local Variables – Variable Scope and Lifetime | Topics/OOP/OOP_Handbook |
| 2026-07-11 | 23 | Variable Shadowing, Instance Methods & Static Methods | Topics/OOP/OOP_Handbook |
| 2026-07-12 | 24 | Method Overloading & Instance Initialization Blocks | Topics/OOP/OOP_Handbook |
| 2026-07-13 | 25 | Static Initialization Blocks, this Keyword & static Keyword | Topics/OOP/OOP_Handbook |
| 2026-07-14 | 26 | final Keyword & super Keyword | Topics/OOP/OOP_Handbook |
| 2026-07-15 | 27 | Encapsulation & Access Modifiers | Topics/OOP/OOP_Handbook |
| 2026-07-16 | 28 | Packages – Organizing Java Applications | Topics/OOP/OOP_Handbook |
| 2026-07-17 | 29 | Inheritance – Code Reusability and IS-A Relationship | Topics/OOP/OOP_Handbook |
| 2026-07-18 | 30 | Polymorphism – Runtime and Compile-time Behavior | Topics/OOP/OOP_Handbook |
| 2026-07-19 | 31 | Abstraction – Hiding Implementation and Exposing Behavior | Topics/OOP/OOP_Handbook |
| 2026-07-20 | 32 | Interfaces – Achieving Multiple Inheritance of Type | Topics/OOP/OOP_Handbook |
| 2026-07-21 | 33 | Object Class & Association – Root of the Java Class Hierarchy | Topics/OOP/OOP_Handbook |
| 2026-07-22 | 34 | Aggregation & Composition – HAS-A Relationships | Topics/OOP/OOP_Handbook |
| 2026-07-23 | 35 | Nested Classes & Anonymous Classes | Topics/OOP/OOP_Handbook |
| 2026-07-24 | 36 | Enums & Records – Modern Java Language Features | Topics/OOP/OOP_Handbook |
| 2026-07-25 | 37 | Sealed Classes & Immutability | Topics/OOP/OOP_Handbook |
| 2026-07-26 | 38 | Object Cloning & Reflection | Topics/OOP/OOP_Handbook |
| 2026-07-27 | 39 | Annotations & Generics | Topics/OOP/OOP_Handbook |
| 2026-07-28 | 40 | Comparable, Comparator & SOLID Principles | Topics/OOP/OOP_Handbook |
| 2026-07-29 | 41 | Dependency Injection & Object Lifecycle | Topics/OOP/OOP_Handbook |
| 2026-07-30 | 42 | JVM Memory Management, Garbage Collection, Class Loading & Method Dispatch | Topics/OOP/OOP_Handbook |
Every learning session records the most important concepts, observations, interview points, and practical lessons.
Instead of maintaining separate revision notes, the repository automatically builds a cumulative knowledge base over time.
<!-- KEY_CONCEPTS_START -->
### Day 1 — Java Data Types – Understanding Primitive & Reference Types
- Java provides 8 primitive data types for efficient memory usage.
- Reference variables store object references while objects reside on the Heap.
- Learned default values, literal representations, and memory allocation.
- Explored binary, octal, hexadecimal, floating-point, and character literals.
### Day 2 — JVM Architecture – Understanding How Java Executes Code
- Studied the complete Java execution pipeline from source code to machine code.
- Learned the responsibilities of the Class Loader, Runtime Data Areas, and Execution Engine.
- Explored the role of the JIT Compiler in runtime optimization.
- Understood how Garbage Collection automatically manages Heap memory.
### Day 3 — Operators in Java – Expressions, Evaluation & Bitwise Operations
- Explored arithmetic, relational, logical, assignment, and ternary operators.
- Learned operator precedence and associativity rules.
- Practiced bitwise operators and binary manipulation.
- Understood short-circuit evaluation with logical operators.
### Day 4 — Type Casting – Primitive Conversions and Data Loss
- Learned widening and narrowing conversions.
- Explored implicit and explicit casting.
- Observed overflow, truncation, and precision loss.
- Converted between primitive types and Strings.
### Day 5 — Control Statements – Decision Making & Iteration
- Practiced if, if-else, nested if, switch, loops, break, and continue.
- Learned enhanced for-loops and labeled statements.
- Explored Java 14+ switch expressions.
- Solved multiple decision-making practice problems.
### Day 6 — Input & Output – Scanner, BufferedReader and Console Input
- Compared Scanner and BufferedReader performance.
- Handled primitive and String input.
- Learned common Scanner pitfalls such as nextLine() after nextInt().
- Implemented safe input handling practices.
### Day 7 — Arrays – Fundamentals, Memory & Traversal
- Learned array declaration, initialization, and traversal.
- Explored memory representation of arrays.
- Practiced searching and sorting basics.
- Used Arrays utility methods for common operations.
### Day 8 — Arrays – Practice Problems & Multi-dimensional Arrays
- Solved practical array-based coding problems.
- Worked with 2D and jagged arrays.
- Implemented linear and binary search.
- Strengthened indexing and traversal concepts.
### Day 9 — Integer Cache & Wrapper Classes – Autoboxing Internals
- Studied Integer Cache and object reuse.
- Learned autoboxing and unboxing.
- Compared Integer.valueOf() with constructors.
- Explored wrapper class behavior during comparisons.
### Day 10 — Command Line Arguments – Passing Runtime Parameters
- Learned how Java receives command-line arguments.
- Parsed runtime input into primitive types.
- Handled argument validation safely.
- Explored practical use cases for runtime configuration.
### Day 11 — Variables in Java – Scope, Lifetime & Memory
- Studied local, instance, and static variables.
- Understood variable scope, lifetime, and default values.
- Learned memory allocation for different variable types.
- Practiced variable declaration and initialization.
### Day 12 — Varargs – Variable Length Arguments
- Learned how varargs simplify method invocation.
- Compared varargs with arrays.
- Understood method overloading with varargs.
- Explored compiler behavior for variable arguments.
### Day 13 — String – Immutability, Pool & Essential Methods
- Learned String immutability and memory model.
- Explored String Pool and heap allocation.
- Compared == and equals().
- Practiced commonly used String methods.
### Day 14 — StringBuilder – Efficient Mutable Strings
- Learned mutable string manipulation.
- Compared StringBuilder with String.
- Studied internal capacity expansion.
- Practiced append(), insert(), delete(), replace(), and reverse().
### Day 15 — StringBuffer – Thread-safe Mutable Strings
- Learned synchronized mutable strings.
- Compared StringBuffer with StringBuilder.
- Understood performance trade-offs.
- Practiced common StringBuffer operations.
### Day 16 — String Pool – JVM Memory & Interview Concepts
- Studied String Pool internals.
- Learned compile-time vs runtime String creation.
- Practiced interview-oriented object creation questions.
- Visualized String memory using JVM diagrams.
### Day 17 — StringTokenizer – Tokenizing Text Data
- Learned StringTokenizer usage.
- Compared StringTokenizer with split().
- Parsed structured text data.
- Understood legacy parsing techniques.
### Day 18 — Wrapper Classes – Object Representation of Primitive Types
- Studied wrapper classes for all primitive types.
- Learned autoboxing and unboxing.
- Compared parseX() and valueOf().
- Practiced wrapper class interview questions.
### Day 19 — Classes & Objects – Building Blocks of Object-Oriented Programming
- Learned the relationship between classes and objects.
- Studied object creation and initialization.
- Understood heap and stack memory for objects.
- Practiced designing simple Java classes.
### Day 20 — Introduction to OOP, Class & Object – Foundations of Java Object-Oriented Programming
- Revisited the four pillars of Object-Oriented Programming.
- Differentiated classes from objects using real-world examples.
- Learned blueprint vs instance concepts.
- Established the conceptual foundation for the Java OOP Handbook.
### Day 21 — Constructors & Instance Variables – Object Initialization
- Learned the purpose of constructors in object creation.
- Explored default, parameterized, and constructor overloading.
- Studied instance variables and their lifecycle.
- Understood how constructors initialize object state.
### Day 22 — Static Variables & Local Variables – Variable Scope and Lifetime
- Compared static, instance, and local variables.
- Studied memory allocation and lifecycle differences.
- Learned when shared state is useful.
- Practiced scope-based coding examples.
### Day 23 — Variable Shadowing, Instance Methods & Static Methods
- Learned how variable shadowing occurs.
- Compared instance methods with static methods.
- Understood method invocation based on object and class.
- Explored best practices for method design.
### Day 24 — Method Overloading & Instance Initialization Blocks
- Studied compile-time polymorphism using method overloading.
- Learned constructor resolution rules.
- Explored instance initialization blocks.
- Understood object initialization sequence.
### Day 25 — Static Initialization Blocks, this Keyword & static Keyword
- Studied static initialization blocks.
- Learned practical uses of the this keyword.
- Explored static members and class loading.
- Practiced constructor chaining using this().
### Day 26 — final Keyword & super Keyword
- Learned final variables, methods, and classes.
- Explored inheritance initialization using super.
- Compared this and super.
- Practiced constructor chaining with inheritance.
### Day 27 — Encapsulation & Access Modifiers
- Implemented encapsulation using private fields.
- Created getter and setter methods.
- Compared all Java access modifiers.
- Learned principles of information hiding.
### Day 28 — Packages – Organizing Java Applications
- Learned package creation and organization.
- Understood package naming conventions.
- Worked with import statements.
- Explored package visibility.
### Day 29 — Inheritance – Code Reusability and IS-A Relationship
- Studied single, multilevel, and hierarchical inheritance.
- Learned method overriding.
- Explored IS-A relationship.
- Practiced inheritance-based design.
### Day 30 — Polymorphism – Runtime and Compile-time Behavior
- Compared compile-time and runtime polymorphism.
- Studied dynamic method dispatch.
- Explored overriding and overloading together.
- Implemented polymorphism using inheritance.
### Day 31 — Abstraction – Hiding Implementation and Exposing Behavior
- Learned the purpose of abstraction in software design.
- Compared abstract classes with concrete classes.
- Implemented abstraction using abstract methods.
- Understood when abstraction improves maintainability.
### Day 32 — Interfaces – Achieving Multiple Inheritance of Type
- Learned interface declaration and implementation.
- Compared interfaces with abstract classes.
- Studied default and static methods.
- Practiced interface-based design.
### Day 33 — Object Class & Association – Root of the Java Class Hierarchy
- Explored Object class methods.
- Learned equals(), hashCode(), toString() and clone().
- Understood association relationships.
- Practiced object collaboration design.
### Day 34 — Aggregation & Composition – HAS-A Relationships
- Compared association, aggregation and composition.
- Learned ownership relationships.
- Designed reusable object models.
- Applied HAS-A relationships in Java.
### Day 35 — Nested Classes & Anonymous Classes
- Learned member, local and static nested classes.
- Created anonymous class implementations.
- Compared nested classes with top-level classes.
- Understood encapsulation using nested types.
### Day 36 — Enums & Records – Modern Java Language Features
- Learned enum constants and behavior.
- Studied Java Records for immutable data models.
- Compared records with traditional POJOs.
- Explored practical use cases.
### Day 37 — Sealed Classes & Immutability
- Studied sealed classes introduced in modern Java.
- Learned controlled inheritance.
- Explored immutable object design.
- Applied best practices for immutable classes.
### Day 38 — Object Cloning & Reflection
- Learned shallow and deep cloning.
- Studied Cloneable interface.
- Explored Java Reflection API.
- Inspected classes dynamically at runtime.
### Day 39 — Annotations & Generics
- Learned built-in and custom annotations.
- Studied Java Generics.
- Implemented generic classes and methods.
- Understood compile-time type safety.
### Day 40 — Comparable, Comparator & SOLID Principles
- Compared Comparable and Comparator.
- Implemented custom sorting strategies.
- Studied all five SOLID principles.
- Applied object-oriented design best practices.
### Day 41 — Dependency Injection & Object Lifecycle
- Learned Dependency Injection fundamentals.
- Compared constructor and setter injection.
- Studied Java object lifecycle.
- Prepared for Spring Framework concepts.
### Day 42 — JVM Memory Management, Garbage Collection, Class Loading & Method Dispatch
- Explored JVM runtime memory areas.
- Studied modern Garbage Collection algorithms.
- Learned Java Class Loading Mechanism.
- Understood static, dynamic and virtual method dispatch.
- Connected OOP concepts with JVM internals.
<!-- KEY_CONCEPTS_END -->
---
# 📚 Learning Resources
Every topic includes trusted learning resources used while studying.
Resources include:
- Official Java Documentation
- Oracle Documentation
- GeeksforGeeks
- Articles
- Books
- Videos
- Other trusted references