Java OOP Fundamentals: Classes & Objects Explained

🚀 #100DaysOfCode – Day 12 | Backend Journey Continues 💻🔥 Consistency is starting to feel powerful now. Day 12 done ✅ 🧠 LeetCode Daily Challenge 📌 Problem: Maximum Walls Destroyed by Robots 💡 Approach & Learnings: Today’s problem was a mix of Sorting + Binary Search + Dynamic Programming, which made it super interesting. 🔹 Sorted robots and walls to process efficiently 🔹 Used Binary Search to quickly count walls in a given range 🔹 Applied Dynamic Programming to maximize total walls destroyed 👉 The key challenge was handling overlapping ranges between robots and deciding the optimal strategy to avoid double counting. This problem really tested how well I can combine multiple concepts into one optimized solution. Submission Link: https://lnkd.in/gp99D5sS 🌱 Spring Boot Learning Today I focused on some very important backend concepts: 🔹 PUT vs PATCH Mapping 👉 PUT Mapping Used when updating the entire object Missing fields → become NULL Best for full replacement 👉 PATCH Mapping Used for partial updates Only updates required fields Avoids unnecessary null values 🔹 ReflectionUtils in PATCH Learned how to use Reflection to dynamically update fields inside an entity. 💡 This helps in: Updating fields without writing multiple setters Making PATCH APIs more flexible Writing cleaner and scalable backend code 🔹 ResponseEntity Understood how to structure API responses properly: ✅ Control HTTP status codes ✅ Customize response body ✅ Improve API clarity and standards 📈 Key Takeaways ✔️ Combining multiple DSA concepts is key for optimization ✔️ PATCH is essential for real-world API design ✔️ Reflection adds flexibility to backend logic ✔️ Clean API responses improve overall system design NotesLink: https://lnkd.in/gNZWz96m 🔥 Day 12 done. Still consistent. Still improving. #BackendDevelopment #SpringBoot #Java #LeetCode #100DaysOfCode #CodingJourney

🚀 Day 559 of #750DaysOfCode 🚀 🔍 LeetCode 3741: Minimum Distance Between Three Equal Elements II Today’s problem was an extension of yesterday’s question — but with larger constraints (n up to 1e5), making efficiency crucial ⚡ 💡 Problem Recap: Find three indices (i, j, k) such that: nums[i] == nums[j] == nums[k] Distance = |i - j| + |j - k| + |k - i| is minimized ✨ Approach I Used (Clean & Intuitive): ✔ Stored indices of each number using a HashMap ✔ For each number: If it appears ≥ 3 times Check consecutive triplets of indices ✔ Compute distance using: 👉 |i - j| + |j - k| + |k - i| 💻 Key Code Insight: Instead of checking all combinations, I only checked sliding windows of size 3 within index lists — reducing unnecessary work. 🧠 Learning: Even in medium problems, a simple structured approach (grouping + sliding window) can pass efficiently when applied correctly. ⚡ Complexity: Time: O(n) to build map + O(n) traversal Space: O(n) 💬 Takeaway: Don’t overcomplicate — sometimes the same idea from an easy problem scales well with just a small optimization in thinking. #LeetCode #DSA #Java #CodingJourney #ProblemSolving #Tech #Programming #Developers #100DaysOfCode

🚀 #100DaysOfCode – Day 17 Consistency is turning into confidence. Showing up daily 🔥 ✅ What I accomplished today: 🧠 LeetCode Daily Challenge – XOR After Queries 📌 Problem Overview: You are given an array and a list of queries. Each query contains: left, right → range k → step increment value → multiplier 👉 For each query: ✔ Update elements from left to right with step k ✔ Multiply each selected element by value Finally, compute the XOR of the entire array 💡 My Approach (Simulation): 🔹 Iterated through each query 🔹 For every query: ✔ Started from left ✔ Jumped with step k until right ✔ Applied multiplication with modulo (10^9 + 7) 🔹 After processing all queries: ✔ Calculated final XOR of array ⚡ Time Complexity: 👉 O(Q * (N / K)) in worst case ⚡ Space Complexity: 👉 O(1) 🧩 Key Insights: ✔ Step-based traversal reduces unnecessary operations ✔ Careful handling of large numbers using modulo ✔ XOR aggregation at the end is straightforward but important ✔ Simulation works, but optimization scope exists (future improvement 🚀) 🔗 LeetCode Submission Link: https://lnkd.in/gZKCZf87 ☕ Spring Boot Learning – Lambda & Stream API Today I explored one of the most powerful features in modern Java 💡 📌 Key Concepts Covered: ✔ Introduction to Lambda Expressions ✔ Writing concise and readable functional code ✔ Using Stream API for data processing ✔ Performing operations like: filter() map() forEach() collect() ✔ Converting collections into streams for clean transformations 🌍 Why This Matters: ✔ Reduces boilerplate code ✔ Improves readability and maintainability ✔ Encourages functional programming style ✔ Makes data processing more expressive and efficient 🧠 Big Learning: Writing less code doesn’t mean doing less— it means writing smarter, cleaner, and more expressive code. 🔥 Learning Streak: Day 17/100 Discipline today → Results tomorrow 🚀 #100DaysOfCode #Java #SpringBoot #BackendDevelopment #LeetCode #DSA #ProblemSolving #CodingJourney #SoftwareDevelopment #LearningInPublic #Developers #Consistency #BuildInPublic

Continuing my #100DaysOfCode journey, On Day 44 & Day 45 I explored more advanced features of modern Java that improve data handling and code readability. 📌 What I learned 🔹 Advanced Streams API – filtering, mapping, and collecting data 🔹 Collectors – grouping and transforming data 🔹 Optional Class – handling null values safely 🔹 Introduction to Date & Time API (java.time) 💻 What I practiced Performed operations like filter, map, collect using streams Implemented examples using Optional to avoid null checks Worked with date and time classes for handling time-based data 💡 Key takeaway Modern Java provides powerful tools to write code that is not only functional, but also clean, safe, and easy to maintain. 📈 Progress update From writing basic programs → handling collections → managing threads → using functional programming… Now learning how to write production-level clean code. #100DaysOfCode #100DaysCodingChallenge #JavaDeveloper #JavaFullStack #LearningInPublic #AIPoweredJavaFullStack #JavaStreams #FlmEdutech #FrontlinesMedia Frontlines EduTech (FLM)

🚀 Lately, I’ve been diving into SOLID Principles and how they impact backend development. At first, it felt theoretical… but once applied, everything started making sense. 🔹 S — Single Responsibility → Keep classes focused (less chaos) 🔹 O — Open/Closed → Extend without breaking existing code 🔹 L — Liskov Substitution → Replace components without issues 🔹 I — Interface Segregation → No unnecessary dependencies 🔹 D — Dependency Inversion → Build flexible, loosely coupled systems 💡 Why this matters in backend? 👉 Cleaner and maintainable code 👉 Easier debugging & testing 👉 Better scalability as system grows 👉 Less tight coupling between services ⚡ Biggest learning: Good code is not just about making it work… it’s about making it easy to change and scale. Still learning, but this mindset shift is powerful. #BackendDevelopment #Java #SystemDesign #CleanCode #SOLID #Learn

🧩 Basic OOP Concepts Explained with Simple Examples Object-Oriented Programming (OOP) is the backbone of modern software development. Understanding these core concepts helps you write clean, scalable, and maintainable code 🚀 Here’s a quick breakdown 👇 🔹 1. Encapsulation Hide internal data and expose only what’s necessary. 👉 Example: A BankAccount keeps balance and pin private. Access is controlled via methods like deposit() and getBalance(). 🔹 2. Abstraction Show only essential features while hiding complexity. 👉 Example: An EmailService provides sendEmail(to, body) while internally handling SMTP, authentication, and retries. 🔹 3. Inheritance Reuse and extend behavior from a parent class. 👉 Example: Animal defines speak(). Dog → "Woof!", Cat → "Meow!" — shared logic + customization. 🔹 4. Polymorphism One interface, multiple implementations. 👉 Example: A Shape interface with draw() allows Circle, Rectangle, and Triangle to implement it differently — yet used through a common method. 💡 Mastering OOP is not just about theory — it's about writing better, reusable, and flexible code. 📌 If you're preparing for interviews or strengthening fundamentals, these concepts are non-negotiable. 🔁 Save this for revision and share it with someone learning Java or backend development! #OOP #Java #Programming #BackendDevelopment #SoftwareEngineering

😂 Every developer starts the day thinking: “Today I’ll write a lot of code.”Reality:🕒 10% Writing Code🕵️ 90% Understanding Someone Else’s CodeReading old code feels like detective work:🔍 Who wrote this?🤔 Why is this variable here?😵 What happens if I change this?☕ Where is my coffee?Truth is — coding is not just writing logic, it’s understanding systems, debugging mysteries, and surviving legacy code 😅Respect to every developer silently fighting code battles every day 💻🔥What’s harder for you: writing new code or understanding old code? 👇 .. ... ..... ... .... #DeveloperLife #Programming #Coding #SoftwareEngineering #Java #SpringBoot #BackendDevelopment #TechHumor #Developers #CodeLife #Debugging #ProgrammerHumor #CodingMemes #LinkedInTech #SoftwareDeveloper

🚀 Mastering Loops in Programming (With Simple Examples!) Loops are one of the most powerful concepts in programming — they help you repeat tasks efficiently without writing the same code again and again. Let’s break it down 👇 🔁 1. For Loop (Best when you know the number of iterations) Used when you already know how many times you want to run something. 👉 Example (Java): for(int i = 1; i <= 5; i++) { System.out.println("Number: " + i); } 📌 Output: Number: 1 Number: 2 ... up to 5 🔄 2. While Loop (Runs while condition is true) Perfect when the number of iterations is unknown. 👉 Example: int i = 1; while(i <= 5) { System.out.println("Count: " + i); i++; } 🔂 3. Do-While Loop (Runs at least once) Even if the condition is false, it executes at least once. 👉 Example: int i = 1; do { System.out.println("Value: " + i); i++; } while(i <= 5); 💡 Why Loops Matter? ✔ Save time & reduce code repetition ✔ Improve code readability ✔ Essential for data processing, automation & algorithms 🔥 Pro Tip: Use loops wisely — avoid infinite loops unless intentionally required 😉 💬 Which loop do you use the most in your coding journey? Let’s discuss below! #Programming #Java #Coding #Developers #LearnToCode #TechTips

🛠️ Project Building Update Building a project is very different from just learning concepts. While working on my inventory forecasting system, I started realizing a few things: 📌 Understanding the problem clearly is harder than writing the code   📌 Designing the flow of the system takes more thinking than expected   📌 Even a simple idea becomes complex when you try to implement it  One thing I found interesting is how important it is to break the problem into smaller parts before jumping into development. Instead of directly coding, I’ve been focusing more on: 👉 Structuring the system   👉 Planning the data flow   👉 Understanding how each component connects  To support this process, I’ve been using tools like: 👉 Java & Data Structures for core logic   👉 Spring Boot for backend design   👉 Basic machine learning concepts for prediction   👉 UI prototyping tools to visualize the interface  This approach is helping me build more clarity before implementation. Still learning and improving as I go 🚀 #learning #projects #softwaredevelopment #machinelearning

📘 SOLID Principles — Strengthening My OOP Foundations Lately, I’ve been revisiting one of the most important concepts in software design — SOLID principles. Here’s a quick breakdown of what I learned: 🔹 S — Single Responsibility Principle (SRP) A class should have only one reason to change. ➡️ Keep responsibilities focused and modular. 🔹 O — Open/Closed Principle (OCP) Code should be open for extension but closed for modification. ➡️ Add new features without breaking existing code. 🔹 L — Liskov Substitution Principle (LSP) Subclasses should behave like their parent classes. ➡️ Avoid unexpected runtime issues. 🔹 I — Interface Segregation Principle (ISP) Don’t force classes to implement methods they don’t use. ➡️ Prefer small, specific interfaces. 🔹 D — Dependency Inversion Principle (DIP) Depend on abstractions, not concrete implementations. ➡️ Makes code flexible, testable, and scalable. 💡 Key Takeaways: * SOLID is the foundation of clean, maintainable code * Plays a huge role in frameworks like Spring * Essential for writing scalable and testable applications Still learning and applying these concepts step by step 🚀 #SOLID #Java #Programming #OOP #SoftwareDesign #CleanCode #SpringFramework #LearningJourney #Commitment #Growth #Mindset