Day 7 of 90 Days Java Challenge: Abstraction & Interfaces

💻 DSA – Day 7: Functions & Methods (Java) Today was all about understanding how functions make code cleaner, reusable, and easier to manage. I explored both the fundamentals and some powerful concepts used in real-world programming. ✅ What I learned today 🔹 Introduction to Functions Why we use them and how they help in breaking problems into smaller pieces. 🔹 Function Syntax + Code Demo Writing basic methods and calling them inside main(). 🔹 Parameters vs. Arguments Understanding how data flows into functions. 🔹 What happens in memory? (Call Stack) How Java manages method calls internally. 🔹 Call by Value (in Java) Java always creates a copy of variables when passing them to methods. 🧮 Problems I solved using Functions ✔ Product of two numbers ✔ Finding Factorial ✔ Binomial Coefficient ✔ Check if a number is Prime ✔ Optimized Prime Check ✔ Print all Primes in a Range ✔ Binary → Decimal (with code) ✔ Decimal → Binary (with code) These problems helped me apply concept + logic simultaneously. 🔄 Inbuilt vs User-Defined Methods Learning when to use Java’s built-in methods and when writing your own is better. ➕ Function Overloading Same function name, different parameters → cleaner and flexible code. Explored: Overloading using different parameters Overloading using different data types 📌 Scope in Java Understanding where variables can be accessed: Method Scope Block Scope This helps avoid errors and write structured code. 🚀 Small progress daily = Big progress later Enjoying how each concept connects to the next. Tomorrow I’ll continue leveling up step by step. #DSA #Day7 #Java #Functions #Methods #CodingJourney #100DaysOfCode #LearningInPublic #BCA #ProblemSolving

☕ Today’s Java Refresh — SOLID Principles Today I revisited the SOLID principles — those five timeless design principles that help us write clean, maintainable, and scalable code. I’ve read about them before, but this time, I tried to really connect each one to the kind of code I write every day..... S — Single Responsibility A class should do one thing, and do it well. When each class has a clear purpose, debugging and extending code becomes effortless. O — Open/Closed Classes should be open for extension but closed for modification. You can add new features without changing existing logic — often through inheritance or abstraction. L — Liskov Substitution Subclasses should be replaceable by their parent class without breaking the application. It’s what keeps polymorphism predictable and safe. I — Interface Segregation Don’t force a class to implement methods it doesn’t use. Smaller, focused interfaces lead to cleaner, modular code. D — Dependency Inversion High-level modules shouldn’t depend on low-level ones; both should depend on abstractions. This is where dependency injection really shines. SOLID isn’t about memorizing rules. It’s about writing code that’s easier to trust, extend, and maintain — for others and for your future self. #Java #SOLID #CoreJava #DesignPrinciples #SoftwareDevelopment #CleanCode #LearningInPublic

☀️ Day 11 of My 90 Days Java Challenge – Collection Classes After exploring the interfaces yesterday, today I moved to their implementations — the actual engines behind the Collections Framework. And that’s where the real differences start to matter. Most tutorials just say “use ArrayList instead of arrays” — but no one tells you why that choice can make or break your code later. Here’s what I discovered 👇 🔹 1️⃣ List Implementations — performance is personality ArrayList → great for search, slow for inserts. LinkedList → perfect for frequent adds/removes, not random access. These tiny performance tradeoffs define real-world efficiency — something you only learn by profiling, not by reading. 🔹 2️⃣ Set Implementations — order and uniqueness HashSet → fast but unordered. LinkedHashSet → remembers insertion order. TreeSet → keeps elements sorted. Choosing between them isn’t just syntax — it’s about data intention. 🔹 3️⃣ Map Implementations — keys tell the story HashMap → fastest for lookups. LinkedHashMap → predictable iteration order. TreeMap → sorted keys, great for range-based operations. Many developers ignore these nuances and end up writing slow, unpredictable code. 🔹 4️⃣ Real-world lesson: The best developers don’t memorize collections — they choose based on behavior, access patterns, and constraints. 💭 Key takeaway: Every collection class tells a story of trade-offs. Knowing why and when to use each one is the skill that turns code into craftsmanship. #Day11 #Java #CoreJava #Collections #JavaDeveloper #LearningJourney #90DaysChallenge

Day 16: Solving “Find Pivot Index” – LeetCode (Java) Today, I explored an interesting problem called “Find Pivot Index” from LeetCode. It really helped me understand how to balance sums on both sides of an array element. Problem Statement: Given an array, find the index where the sum of all elements on the left is equal to the sum of all elements on the right. If no such index exists, return -1. Key Logic: For each element: Calculate leftSum = sum of elements before the index. Calculate rightSum = sum of elements after the index. Compare both. If they match → that’s your pivot index! 🔍 Example: Input: [1, 7, 3, 6, 5, 6] Output: 3 Explanation: Left sum = 11, Right sum = 11 Learning Moment: Concepts Used: Nested loops Prefix sums Edge case handling Logical debugging Next Step: I’ll now optimize this logic to a more efficient approach (using total sum & prefix sum) to make it run in O(n) time. #Java #LeetCode #DSA #ProblemSolving #LearningJourney #90DaysOfCode #BCA #CareerGrowth

𝗝𝗮𝘃𝗮 𝗥𝗲𝗰𝗼𝗿𝗱𝘀: 𝗔 𝗦𝗼𝗽𝗵𝗶𝘀𝘁𝗶𝗰𝗮𝘁𝗲𝗱 𝗪𝗮𝘆 𝘁𝗼 𝗕𝘂𝗶𝗹𝗱 𝗗𝗧𝗢𝘀 ☕ When Java introduced records, I immediately thought: “Finally, a cleaner way to write DTOs!” A record is a special kind of class designed to hold immutable data, no boilerplate, no setters, just the essentials. With a single line, Java automatically gives you a constructor, getters, and even equals, hashCode, and toString. Because records are immutable, you can’t modify their fields, no setters allowed. And that’s a good thing: immutability makes data safer and easier to reason about, especially in concurrent systems. For me, records are the most elegant way to express DTOs in Java (introduced in version 14 and made permanent in16), concise, expressive, and intentional. What do you think ? Have you used records in your projects? Any drawbacks or lessons learned? 💡 #LearningJourney #CuriosityDriven #Java #developers #JavaDeveloper #Programming #SoftwareEngineering #DTO #CleanCode #TechTips #CodingJourney

💡 𝗝𝗮𝘃𝗮/𝐒𝐩𝐫𝐢𝐧𝐠 𝐁𝐨𝐨𝐭 𝐂𝐥𝐞𝐚𝐧 𝐂𝐨𝐝𝐞 𝗧𝗶𝗽 🔥 💎 𝗢𝗽𝘁𝗶𝗼𝗻𝗮𝗹.𝗶𝗳𝗣𝗿𝗲𝘀𝗲𝗻𝘁𝗢𝗿𝗘𝗹𝘀𝗲() 𝗳𝗼𝗿 𝗡𝘂𝗹𝗹 𝗦𝗮𝗳𝗲𝘁𝘆 ✅ The 𝗶𝗳𝗣𝗿𝗲𝘀𝗲𝗻𝘁𝗢𝗿𝗘𝗹𝘀𝗲() method is a powerful feature introduced in 𝗝𝗮𝘃𝗮 𝟵 that takes null safety to the next level. It allows you to handle both present and absent values elegantly in a single expression, eliminating the need for verbose null checks and improving code readability. 💡 While 𝗶𝗳𝗣𝗿𝗲𝘀𝗲𝗻𝘁() from Java 8 only handles the present case, 𝗶𝗳𝗣𝗿𝗲𝘀𝗲𝗻𝘁𝗢𝗿𝗘𝗹𝘀𝗲() extends this capability by accepting two parameters: a Consumer for when the value exists and a Runnable for when it's absent. This functional approach makes your code more expressive and less error-prone than traditional if-null patterns. 🔥 𝗔𝗱𝘃𝗮𝗻𝘁𝗮𝗴𝗲𝘀 𝗼𝗳 𝘂𝘀𝗶𝗻𝗴 𝗶𝗳𝗣𝗿𝗲𝘀𝗲𝗻𝘁𝗢𝗿𝗘𝗹𝘀𝗲() ◾Eliminates repetitive if-null checks, making your code more concise and elegant. ◾Prevents NullPointerException errors by forcing explicit handling of absent values. ◾Supports functional programming style with lambda expressions and method references. ◾Works seamlessly with Optional chains using map, filter, and flatMap operations. 🤔 What's your opinion on using Optional in modern Java? #java #springboot #programming #softwareengineering #softwaredevelopment

Java Agents and Bytecode Manipulation: Practical Insights for Observability and Control 💡 Java agents are tiny programs that ride along the JVM, shaping how your code runs by touching bytecode as it’s loaded. They hook into the Instrumentation API via premain or agentmain, and they can add a bytecode transformer that rewrites methods on the fly or even redefines already‑loaded classes. 🧰 The core power lies in dynamic observability and behavior enhancement: you can inject timing data, log calls, or enforce constraints without changing your source. Libraries like ByteBuddy provide a safer, expressive way to describe transformations and minimize boilerplate. ⚠️ But there are trade‑offs: instrumentation adds overhead and can complicate debugging if not done carefully. Class‑loading boundaries, security policies, and startup sequencing can limit what you can safely modify in production. Start with targeted transforms and rigorous validation. 🚀 Real‑world patterns include profiling, tracing, and feature toggles. Keep transforms opt‑in and modular; prefer pre‑main agents when you need early instrumentation, and avoid sweeping changes that affect all classes. 🎯 Takeaways: align your goals, measure impact, and keep changes isolated. Pilot in staging, use feature flags, and document governance around live instrumentation. What’s your take? In what scenario would you consider using a Java agent, and what guardrails would you put in place? #Java #Bytecode #InstrumentationAPI #SoftwareEngineering #Observability

Been revisiting some old Java design principles lately. Funny how something you learned years ago starts making new sense when you lead systems at scale. For instance — the idea of composition over inheritance felt academic early on, but at scale, it’s often the difference between flexibility and painful refactoring later 😅. The fundamentals never go out of style — they just deepen with experience. Curious if others have had similar “oh, now I get it” moments — which principle or pattern hit differently once you saw it in the real world? #Java #SystemDesign #SoftwareEngineering #CleanCode

🚀 #Day51 of My Java Journey Today, I explored Constructor Chaining in Java🧱 🔍 𝐖𝐡𝐚𝐭 𝐢𝐬 𝐂𝐨𝐧𝐬𝐭𝐫𝐮𝐜𝐭𝐨𝐫 𝐂𝐡𝐚𝐢𝐧𝐢𝐧𝐠? Constructor Chaining is the process of calling one constructor from another within the same class or from a parent class. 𝑰𝒕 𝒉𝒆𝒍𝒑𝒔 𝒊𝒏: ✅Avoiding duplicate initialization code ✅Improving reusability ✅Keeping constructors clean and organized  𝗪𝗮𝘆𝘀 𝘁𝗼 𝗣𝗲𝗿𝗳𝗼𝗿𝗺 𝗖𝗼𝗻𝘀𝘁𝗿𝘂𝗰𝘁𝗼𝗿 𝗖𝗵𝗮𝗶𝗻𝗶𝗻𝗴: 1️⃣𝑾𝒊𝒕𝒉𝒊𝒏 𝒔𝒂𝒎𝒆 𝒄𝒍𝒂𝒔𝒔: It can be done using this() keyword for constructors in the same class 2️⃣𝑭𝒓𝒐𝒎 𝑷𝒂𝒓𝒆𝒏𝒕 𝒄𝒍𝒂𝒔𝒔: by using super() keyword to call the constructor from the parent class. 🎯 𝐀𝐛𝐨𝐮𝐭 𝐭𝐡𝐢𝐬() ➡️this() is used only inside constructors ➡️ It calls constructor of the same class whose parameters match the parameters passed to this(parameters). ➡️ Must be the first executable statement inside the constructor 🎯 𝐀𝐛𝐨𝐮𝐭 𝐭𝐡𝐢𝐬. (𝐤𝐞𝐲𝐰𝐨𝐫𝐝) ➡️Refers to the current object ➡️It is used to differentiate between the local variable and the instance variable in the method when they have same name. 10000 Coders #Java #LearningJourney #Programming #OOP #Constructors #DeveloperJourney #FullStackDevelopment🚀

☀️ Day 12 of My 90 Days Java Challenge – Iterator & Enumerator: The Hidden Navigators of Collections Today was about something that looks simple on the surface — traversing collections. But behind every loop lies a quiet hero — Iterator and its ancestor, Enumerator. Most developers just use for-each and move on. But understanding these two changes the way you think about how data is accessed and controlled. Here’s what I realized 👇 🔹 1️⃣ Enumerator – the old-school traveler Introduced in legacy classes like Vector and Stack, the Enumerator interface came before the Collections Framework. It’s simple — with just hasMoreElements() and nextElement() — but limited. You can only read data, not modify it while traversing. Still, understanding it gives you insight into how Java evolved toward modern iteration. 🔹 2️⃣ Iterator – the modern navigator Iterator replaced Enumerator for a reason — it’s fail-fast, universal, and safe. Methods like hasNext(), next(), and remove() let you traverse and modify collections while keeping data integrity intact. 🔹 3️⃣ Fail-fast behavior isn’t a bug — it’s protection Many don’t realize why ConcurrentModificationException exists. It’s not an error — it’s Java’s way of protecting your collection from inconsistent states during iteration. It teaches a valuable principle: better to fail fast than to corrupt data silently. 🔹 4️⃣ Behind the scenes of “for-each” Even the simple enhanced for-loop (for(String s : list)) uses an Iterator under the hood. It’s a small reminder that abstraction doesn’t replace understanding — it depends on it. 💭 Key takeaway: Iteration isn’t just about looping — it’s about safe navigation through data. Knowing how Enumerator and Iterator work gives you a deeper respect for how Java ensures consistency, even in motion. #Day12 #Java #CoreJava #Collections #Iterator #Enumerator #LearningJourney #90DaysChallenge