Spring Framework IOC Container & Dependency Injection Basics

🚀 Java Learning Journey – Day 4 Deep Dive into Stack, Heap & References Today was a big clarity day. Instead of just writing Java code, I focused on understanding what actually happens in memory when a program runs. Here’s what I learned: 🧠 1️⃣ Stack vs Heap Stack stores method calls and local variables. Heap stores objects created using new. Every method call creates a new stack frame. When a method finishes, its stack frame is removed. Understanding this made method execution much clearer. 🔎 2️⃣ Primitive vs Reference Primitive values (int, double, etc.) are stored directly in stack. Reference variables are stored in stack. The actual object they refer to is stored in heap. Example: Person p1 = new Person(); p1 → Stack Person object → Heap ♻️ 3️⃣ Object Reachability & Garbage Collection An object becomes eligible for Garbage Collection when: No references point to it anymore. Reassigning or nullifying references can make objects unreachable. This clarified a lot of confusion around memory leaks and object lifecycle. 💡 Biggest Realization Java memory is not magic. Once you understand: Stack frames Reference copying Object reachability Everything becomes predictable and logical. #Java #LearningJourney #JavaMemoryModel #BackendDevelopment #SoftwareEngineering #Day4

🚀 𝗨𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱𝗶𝗻𝗴 𝗜𝗻𝘁𝗲𝗿𝗳𝗮𝗰𝗲𝘀 𝗮𝗻𝗱 𝗖𝗹𝗮𝘀𝘀𝗲𝘀 𝗕𝗲𝗵𝗶𝗻𝗱 𝗝𝗮𝘃𝗮 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻 𝗙𝗿𝗮𝗺𝗲𝘄𝗼𝗿𝗸 In my previous post, I shared why the Collection Framework is preferred over arrays. Today, I wanted to understand what makes the Collection Framework so flexible. The answer lies in two core OOP concepts: Interfaces and Classes. 🔹 𝗪𝗵𝗮𝘁 𝗶𝘀 𝗮 𝗖𝗹𝗮𝘀𝘀? A class is a blueprint for creating objects. It contains data (variables) and behavior (methods). Example: class Student { String name; void study() { System.out.println("Studying..."); } } A class provides the actual implementation. 🔹 𝗪𝗵𝗮𝘁 𝗶𝘀 𝗮𝗻 𝗜𝗻𝘁𝗲𝗿𝗳𝗮𝗰𝗲? An interface defines a contract. It specifies what needs to be done, but not how it should be done. Example: interface Animal { void sound(); } Any class implementing this interface must provide the method body. This promotes: • Abstraction • Loose coupling • Flexibility 🔹 𝗛𝗼𝘄 𝗧𝗵𝗶𝘀 𝗣𝗼𝘄𝗲𝗿𝘀 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻 𝗙𝗿𝗮𝗺𝗲𝘄𝗼𝗿𝗸 -> List<Integer> list = new ArrayList<>(); Here: • List → Interface • ArrayList → Class implementing that interface Because of this design, we can easily switch implementations: -> List<Integer> list = new LinkedList<>(); ✅ No change in reference type — only the implementation changes. Similarly, in Set: -> Set<Integer> set = new HashSet<>(); Here: • Set → Interface • HashSet → Implementation class If needed, we can switch to: -> Set<Integer> set = new TreeSet<>(); Again, the reference remains Set. 💡 This is the real power of interfaces. We can change the implementation without changing the overall structure of our code. 💡 𝗞𝗲𝘆 𝗧𝗮𝗸𝗲𝗮𝘄𝗮𝘆 Interfaces define behavior. Classes provide implementation. This separation is what makes Java applications scalable, maintainable, and extensible. Revisiting fundamentals always gives deeper clarity. #Java #OOP #CollectionFramework #Interfaces #Classes #LearningJourney #DSA

🚀 Learning Series – Post #7 Today’s topic: Dependency Injection Explained in the Simplest Way If you're preparing for Java developer or backend roles, Dependency Injection is a very important concept in Spring Boot. 1️⃣ What is Dependency Injection? Dependency Injection (DI) is a design pattern where an object receives its dependencies from outside instead of creating them itself. 2️⃣ Why do we use Dependency Injection? It helps in reducing tight coupling between classes and makes the code easier to test and maintain. 3️⃣ Types of Dependency Injection • Constructor Injection • Setter Injection • Field Injection 4️⃣ How does Spring Boot use DI? Spring Boot uses the IoC (Inversion of Control) container to automatically inject dependencies using annotations like @Autowired. 5️⃣ Simple Example Instead of creating an object using new, Spring automatically provides the required object to your class. 💡 Tip: In interviews, always mention “Loose Coupling and Better Testability” when explaining Dependency Injection. 📌 Next Post: What is @SpringBootApplication Annotation? #LearningInPublic #SpringBoot #JavaDeveloper #DependencyInjection #BackendDevelopment

IoC is the Principle Behind Dependency Injection After learning Dependency Injection , I thought I understood everything. Spring creates objects. Spring injects them where I need them. All good. But then a question came to my mind: Who is actually controlling the application? When I first started with Java, my code looked like this: UserService userService = new UserService(); Here, I was in control. I created the object. I decided when to use it. But in Spring, things changed. @Service public class UserService { } @RestController public class UserController { private final UserService userService; public UserController(UserService userService) { this.userService = userService; } } Here, I never created UserService. Spring did. 🔁 What is Inversion of Control? Normally: -> Your code controls object creation. With IoC: -> The framework controls object creation. The control is inverted to the framework. Instead of saying, I will create what I need. You say, Spring, give me what I need. Simple Example Without IoC → You cook your own food every day. With IoC → You order food, and the restaurant prepares it. You focus on eating (business logic). The kitchen handles the preparation (dependencies). Spring is the kitchen here. Final Verdict Dependency Injection is a result of IoC. When I understood this difference, Spring made much more sense. It is not just about annotations. It is about shifting control from your code to the framework. Building backend fundamentals step by step 🌱 #Java #SpringBoot #IoC #DependencyInjection #BackendDevelopment #LearningJourney 🚀

Yesterday I shared how I started learning Dependency Injection after struggling to explain it during an interview. Today the journey continued as I explored another core Spring concept: Inversion of Control (IoC) and some of the key annotations used in Spring Boot. At first, IoC sounded like a complicated term, but the idea behind it is actually simple. Inversion of Control means that the framework (Spring) is responsible for creating and managing objects instead of you manually creating them using new. In traditional Java applications, a class would usually create the objects it depends on. With IoC, Spring takes over that responsibility through something called the IoC Container. You simply define your components, and Spring manages them for you. While learning this, I also came across some important Spring annotations that make this possible: • @Component – Marks a class as a Spring-managed component so the IoC container can detect and create it. • @Service – A specialized version of @Component, typically used for classes that contain business logic. • @Repository – Another specialized component used for classes that interact with the database layer. • @Autowired – Tells Spring to automatically inject the required dependency into a class. These annotations help Spring understand what objects it should create and how they should be connected together. What I’m enjoying the most about learning Spring Boot is seeing how these concepts work together to build clean, scalable applications. And the learning journey continues. 🚀 #Java #SpringBoot #BackendDevelopment #SoftwareEngineering #InversionOfControl #DependencyInjection #LearningInPublic

Core Java taught me fundamentals. Spring Boot taught me scalability. From: ❌ Boilerplate code ❌ Manual config ❌ Complex security To: ✅ Auto configuration ✅ Clean architecture ✅ Production-ready APIs That’s the power of Spring Boot.

🚀 Today’s Learning: Record & Sealed Classes in Java Today I explored two powerful features introduced in modern Java versions – Record and Sealed Classes. These features help write cleaner, more secure, and more maintainable code. 🔹 1️⃣ Record Records are used to create immutable data carrier classes with minimal boilerplate code. Instead of writing: Constructors Getters toString() equals() hashCode() Java automatically generates them for us. ✅ Best for DTOs ✅ Immutable by default ✅ Less code, more readability 🔹 2️⃣ Sealed Classes Sealed classes allow us to control which classes can extend or implement a class. ✅ Restricts inheritance ✅ Improves security ✅ Better domain modeling ✅ Useful with pattern matching 📌 Key Takeaway: Record reduces boilerplate code for data objects, while Sealed classes give better control over class hierarchies. #Java #CoreJava #Java17 #Programming #SoftwareDevelopment #Learning #BackendDevelopment .

🚀Data abstraction is the process of hiding certain details and showing only essential information to the user. Abstraction can be achieved with either abstract classes or interfaces (which you will learn more about in the next chapter). The abstract keyword is a non-access modifier, used for classes and methods: Abstract class: is a restricted class that cannot be used to create objects (to access it, it must be inherited from another class). Abstract method: can only be used in an abstract class, and it does not have a body. The body is provided by the subclass (inherited from). An abstract class can have both abstract and regular methods. An abstract class in Java is a special type of class that cannot be instantiated (you cannot create objects from it directly) and is meant to be extended (inherited) by other classes. It is declared using the abstract keyword. 🔹 In Simple Words Think of an abstract class as a blueprint for other classes. It defines: Some common properties (variables) Some common methods (with code) Some abstract methods (without code) that child classes must implement 🔹 Why Do We Use Abstract Classes? We use abstract classes when: ✨We want to provide common behavior to multiple related classes We want to force subclasses to implement certain methods We want partial abstraction (0–100%) What Can an Abstract Class Contain? An abstract class can have: ✨Normal methods (with body) These methods already have code. ✨Child classes can use them directly. Abstract methods (without body) ✨These methods only have declaration. Child classes must give their own implementation. Variables Like normal classes. Constructors Used when child class object is created. Special thanks to the Anand Kumar Buddarapu Saketh Kallepu Uppugundla Sairam #Java #AbstractClass #OOP #ObjectOrientedProgramming #JavaProgramming #CoreJava #ProgrammingBasics #CodingLife #LearnJava #SoftwareDevelopment 🚀💻✨

Day 75 - LeetCode Journey Solved LeetCode 21: Merge Two Sorted Lists in Java ✅ Moving from Strings to Linked Lists! Today’s challenge was about maintaining order while merging two separate data structures into one seamless, sorted list. The Approach: 1) Dummy Node Strategy: Started with a "dummy" node to act as the foundation of the new list, which simplifies edge cases where the head might change. 2) Iterative Comparison: Used a while loop to compare the values of the current nodes in both lists, always attaching the smaller value to our result list. 3) Pointer Management: Carefully advanced the pointers for both the source lists and the new merged list to ensure no data was lost. 4) Cleanup: Once one list was exhausted, I simply appended the remainder of the other list—since they are already sorted, no further comparisons were needed! Key Takeaways: ->Memory Efficiency: Merged the lists in-place by re-linking existing nodes rather than creating new ones. ->100% Runtime: Achieved a 0 ms runtime by focusing on a clean iterative approach. ->Pointer Logic: Reinforced the importance of keeping track of "next" references to prevent breaking the chain. Every pointer moved correctly is a step closer to mastering Linked Lists. Consistency is doing its work! 💪 #LeetCode #DSA #Java #LinkedList #Algorithms #ProblemSolving #CodingPractice #InterviewPreparation #Consistency #DailyCoding