Java Fundamentals: Autoboxing, Abstract Classes & POJOs

I remember staring at Java code wondering... Why is this variable private? Why can't I extend this class? Why does this method work without an object? Modifiers confused me for a long time. So I built the guide I wish I had back then. A complete, colorful visual guide to Java Modifiers — covering everything in one document: ACCESS MODIFIERS 🔴 private — your own class only 🟢 default — same package family 🟠 protected — package + inherited subclasses 🔵 public — accessible from everywhere NON-ACCESS MODIFIERS 🟣 static — belongs to the class, not the object 🟡 final — cannot be changed, overridden, or extended 🔵 abstract — must be completed by subclass 🔴 synchronized — one thread at a time 🌿 volatile & transient — memory + serialization control Each modifier comes with: → Clear rules (no fluff) → Real-world analogies that actually make sense → VSCode-style dark code examples → Color-coded visibility tables Whether you're a beginner trying to understand encapsulation or prepping for a Java interview — this one is for you. PDF attached — free to download and share! Save this post for your next Java revision session. #Java #JavaProgramming #OOP #AccessModifiers #LearnJava #Programming #Developer #CodeNewbie #SoftwareEngineering #TechLearning

Day 19 of Java : Classes Inside Classes? 👀🔥 Today Java got a bit more… interesting. I learned that a class can exist inside another class. Yeah… nested logic just leveled up. 📦 Nested Classes A class inside a class = better structure + cleaner code. ⚡ Static Nested Class No need for outer object. Direct access. Clean and independent. 🧠 Inner Class Now this one is connected. Needs an object of the outer class. Works closely with it. 🎯 Local Class Defined inside a method. Short scope. Used only where needed. 🔥 Anonymous Class No name. No extra setup. Just write and use instantly. Perfect for quick implementations. Big realization today? Java is not just about writing classes… it’s about how you organize and structure them smartly. Day 19 and now even classes have layers 😄🚀 Special thanks to Aditya Tandon Sir & Rohit Negi Sir 🙌 #Java #CoreJava #OOP #Programming #LearningJourney #Developers #BuildInPublic

✨ DAY-41: 🌳 Dependency Injection Made Simple (with a Tree 🌱) Ever wondered how Dependency Injection in Java works? Here’s a simple way to visualize it 👇 Imagine a tree 🌳 (your main class – "TreeComponent") 👉 With Dependency Injection: The tree doesn’t create its own resources. Instead, it receives what it needs — like: • 💧 WaterService • 🌱 SoilService • ☀️ SunlightService Everything is clean, organized, and easy to manage ✅ 👉 Without Dependency Injection: The tree tries to handle everything on its own 😵 Roots get tangled, resources are tightly coupled, and maintenance becomes messy ❌ 💡 Key Takeaway: Dependency Injection = Loose Coupling + Better Flexibility + Easy Testing This is why frameworks like Spring make development powerful and scalable 🚀 Keep learning, keep growing! 🌿 #Java #DependencyInjection #SpringFramework #CleanCode #ProgrammingConcepts #BackendDevelopment #LearningJourney

🚀 Day 55 of #100DaysOfCode — Getting Started with Multithreading in Java Over the past 2 days, I explored one of the most important concepts in Java: Multithreading 🔥 💡 What I Learned 🧵 What is Multithreading? Multithreading allows a program to execute multiple tasks simultaneously, improving performance and efficiency ⚡ 👉 Instead of running tasks one after another, we can run them in parallel. ⚙️ Creating Threads in Java 1️⃣ Using Thread Class Extend the Thread class Override the run() method Start using start() 2️⃣ Using Runnable Interface (Best Practice ✅) Implement Runnable Pass it to a Thread object Start execution using start() 🧠 Key Takeaways ✔ Runnable is preferred over Thread (better design & flexibility) ✔ Supports multiple inheritance ✔ Separates task from execution ✔ Helps in building scalable backend systems ⚠️ Important Concept 👉 Difference between: run() ❌ (normal method call) start() ✅ (creates new thread) 🔥 Real-World Use Cases Backend APIs Payment systems Real-time applications Inventory & billing systems (like the one I'm building 🏪) 🚀 What’s Next? ➡️ Synchronization ➡️ Race Conditions ➡️ ExecutorService (Thread Pool) Learning multithreading feels like unlocking a new level in Java 💪  Huge thanks to my mentor Suresh Bishnoi for simplifying complex concepts like multithreading and pushing me to keep learning consistently. #Java #Multithreading #100DaysOfCode #BackendDevelopment #LearningJourney

Ever wondered why changing one variable sometimes changes everything in Java? Today I finally understood a concept that used to confuse me a lot — Pass by Value vs Pass by Reference (memory perspective). At first, it felt tricky… but once I visualized how memory works, everything started making sense. What I learned: [1] Pass by Value (Definition): A copy of the actual value is passed to another variable. 👉 Both variables work independently. Example: int x = 10; int y = x; // copy y = 20; System.out.println(x); // 10 System.out.println(y); // 20 ➡️ Changing y does NOT affect x [2] Pass by Reference (Concept in Java objects): Actually, Java is always pass by value… BUT for objects, the value being passed is the reference (address). 👉 So multiple variables can point to the same object in memory. Example: Car a = new Car(); a.name = "Maruti"; Car b = a; // reference copy b.name = "Kia"; System.out.println(a.name); // Kia ➡️ Changing b also changes a because both point to the same object. 💡 Real-life analogy: It’s like one person having multiple names — Parents call you one name, friends call you another… but it’s still YOU. Same in Java: Different references ➝ Same object ➝ Same changes. 🔑 Key Takeaways: Java is always pass by value For objects, the value = reference (address) Multiple references can point to the same object Changing via one reference affects all This concept really changed how I look at Java objects and memory. Still learning, still improving… one concept at a time #Java #Programming #LearningJourney #Coding #JavaDeveloper #BeginnerDeveloper #SoftwareDevelopment #100DaysOfCode

𝗠𝗮𝘀𝘁𝗲𝗿𝗶𝗻𝗴 𝗝𝗮𝘃𝗮’𝘀 𝘃𝗮𝗿 Recently, I explored how Java introduced Local Variable Type Inference (var) in Java 10 and how it transformed the way developers write cleaner and more expressive code. Java has traditionally been known for its verbosity. With the introduction of var through Project Amber, the language took a major step toward modern programming practices—balancing conciseness with strong static typing. 𝗪𝗵𝗮𝘁 𝗜 𝗹𝗲𝗮𝗿𝗻𝗲𝗱: • var allows the compiler to infer types from initializers, reducing boilerplate without losing type safety. • It is not a keyword, but a reserved type name, ensuring backward compatibility. • Works only for local variables, not for fields, method parameters, or return types. • The inferred type is always static and compile-time resolved—no runtime overhead. • Powerful in handling non-denotable types, including anonymous classes and intersection types. Must be used carefully: • Avoid when the type is unclear from the initializer • Prefer when the initializer clearly reveals the type (e.g., constructors or factory methods) • Enhances readability only when the initializer clearly conveys the type. 𝗞𝗲𝘆 𝘁𝗮𝗸𝗲𝗮𝘄𝗮𝘆: var is not just about writing less code—it’s about writing clearer, more maintainable code when used correctly. The real skill lies in knowing when to use it and when not to. A special thanks to Syed Zabi Ulla sir at PW Institute of Innovation for their clear explanations and continuous guidance throughout this topic. #Java #Programming #SoftwareDevelopment #CleanCode #Java10 #Developers #LearningJourney

Day 73 of #90DaysDSAChallenge Solved LeetCode 451: Sort Characters By Frequency Learned an important Java design concept today. Problem Overview: The task was to sort characters in a string based on descending frequency. What confused me initially: Why create a separate Freq class instead of just using HashMap and PriorityQueue directly? Key Learning: PriorityQueue stores one complete object at a time. For this problem, each item needs two pieces of data together: Character Frequency Example: Instead of storing: e and 2 separately We package them as: Freq('e', 2) That custom class acts like a container holding both values in one object, so PriorityQueue can compare and sort them correctly. Why this matters: This taught me that custom classes in Java are often not about complexity, they simply bundle related data into one manageable unit. Alternative approach: We can also use Map.Entry<Character, Integer> instead of creating a custom class, but building Freq makes the logic easier to understand while learning. Today’s takeaway: Not every class is for business logic — sometimes it exists just to package data cleanly. #Java #90DaysDSAChallenge #LeetCode #PriorityQueue #HashMap #CodingJourney #ProblemSolving

While working on backend systems, I revisited some features from Java 17… and honestly, they make code much cleaner. One feature I find really useful is Records. 👉 Earlier: We used to write a lot of boilerplate just to create a simple data class. Getters Constructors toString(), equals(), hashCode() ✅ With Java 17 — Records: You can define a data class in one line: public record User(String name, int age) {} That’s it. Java automatically provides: ✔️ Constructor ✔️ Getters ✔️ equals() & hashCode() ✔️ toString() 💡 Practical usage: User user = new User("Dipesh", 25); System.out.println(user.name()); // Dipesh System.out.println(user.age()); // 25 🧠 Where this helps: DTOs in APIs Response objects Immutable data models What I like most is how it reduces boilerplate and keeps the code focused. Would love to know — are you using records in your projects? #Java #Java17 #Backend #SoftwareEngineering #Programming #Microservices #LearningInPublic

🚀 Understanding Java Multithreading Through a Real-Life Scenario This morning, I found myself doing three tasks together: ☕ Making tea 🍽 Washing utensils 🪥 Brushing teeth And suddenly it clicked… 👉 This is how Processes and Multithreading work in Java. 💡 Technical Breakdown: 🔹 Process Each independent activity can be treated as a process Making tea → Process Washing utensils → Process Brushing teeth → Process 👉 A process is an independent program with its own memory space 🔹 Thread Now, inside one task (like making tea), there are smaller steps: Boiling water Adding tea leaves Pouring milk 👉 These are threads (smaller units of execution inside a process that share memory) ⚡ Key Difference: Process → Independent & heavy Thread → Lightweight & shared 🧠 Important Insight: ⚠️ I wasn’t truly doing everything at the exact same time ⚠️ I was rapidly switching between tasks 👉 This is Concurrency, not true Parallelism ⚠️ Real-world Challenge: If multiple threads try to use the same resource simultaneously → Race Condition Example: Two people trying to use the same kettle at the same time 🧠 Key Takeaways: ✔ Multithreading exists in real life ✔ Process vs Thread is fundamental ✔ Concurrency ≠ Parallelism ✔ ExecutorService simplifies thread management ✔ Synchronization is required for shared resources 🚀 What I’m exploring next: Synchronization & Thread Safety Race Conditions in depth Real-world backend use cases 📌 Final Thought: Don’t just learn programming — learn to connect it with real-world systems. #Java #Multithreading #Concurrency #BackendDeveloper #SoftwareEngineering #LearningJourney

🔥 Today's Learning Update — #Day51 Today’s  concept: Why are Strings immutable in Java? 💡 What I understood In Java, once a String is created, it cannot be changed. If we try to modify it, a new String object is created instead. 💡 Why is it designed this way? 1️⃣ String Pool (Memory Efficiency) Multiple variables can point to the same String value without creating new objects. Since Strings are immutable, this is safe and saves memory. 2️⃣ Security Strings are used in things like file paths and database connections. If they were mutable, they could be changed during execution, which could cause serious issues. 3️⃣ HashCode Performance Since a String never changes, its hashCode can be cached. This makes it very efficient when used in structures like HashMap. 💡 Important observation When we “modify” a String, we are actually creating a new object, not changing the existing one. If we need frequent modifications, it’s better to use StringBuilder, which is mutable. 🧠 What I learned today Some design decisions in Java are not limitations — they are optimizations for performance, safety, and memory efficiency. #Java #CoreJava #String #Programming #SoftwareEngineering #ConsistencyCurve