How to use Java Reflection to bypass encapsulation

🙇♂️ Day 52 of My Java Backend Journey 🥇 🔒 Ever wondered why your Java program misbehaves when multiple threads run together? Today, I dived into one of the most important concepts in multithreading Synchronization & Thread Safety 🚦. When multiple threads try to access the same resource, things can get unpredictable wrong outputs, race conditions, even crashes. That’s where synchronization steps in. 📘 3-Line Story: This morning I wrote a simple counter program. Two threads tried updating the same value chaos! 😅 Added synchronization… and suddenly everything became calm and consistent ✔️. Understanding thread safety feels like leveling up in backend development. Every line of code teaches me how real systems stay stable under pressure. Consistency is not just in code, but in growth too 💪✨ By using synchronized blocks or methods, Java ensures only one thread can access that critical section at a time. It’s like a traffic signal for threads 🚦 giving each one a safe turn. Keep learning, keep building. Backend mastery comes one concept at a time. 🚀 #Java #Multithreading #Synchronization #ThreadSafety #BackendDevelopment #CodingJourney #LearnInPublic #JavaDeveloper #100DaysOfCode #TechCareer

⁉️Say goodbye to boilerplate code! If you're still writing bulky anonymous inner classes in Java, it's time to level up. The introduction of Functional Interfaces and Lambda Expressions in Java 8 was a game-changer. Q. Why do they matter? 1. Cleaner, more readable code: Write concise and expressive code by representing an interface with a single abstract method. 2. Enables functional programming: Pass behavior as arguments, unlocking powerful features like the Stream API. 3. Reduces overhead: More lightweight than traditional inner classes, leading to better performance and smaller application footprints. Consider the classic Runnable example: java // Old way Thread t = new Thread(new Runnable() { public void run() { System.out.println("Classic Java"); } }); // Modern way with a lambda Thread t = new Thread(() -> System.out.println("Modern Java")); Use code with caution. This change isn't just cosmetic—it unlocks a more powerful and modern approach to Java development. 🫠What's your favorite use-case for lambdas or the Stream API? Share your thoughts below! #Java #Java8 #Programming #CleanCode #DeveloperTips #SoftwareDevelopment

How HashMap Works in Java Behind the Scenes Ever wondered what really happens when you write: map.put("Aman", 101); Let’s break it down visually. 1) Hashing: The key’s hashCode() is calculated. Example: "Aman".hashCode() gives an integer. This number decides where the entry will go inside the HashMap. 2) Index Calculation: That hash value is converted to a bucket index using: index = hash & (n - 1); This ensures it fits within the internal array size (n). 3) Bucket Storage (Collision Handling): Each bucket is like a locker. If the locker is empty, your entry is stored directly. If another entry already exists at that index, a linked list is created to chain them. Since Java 8, if too many entries go into the same bucket, it converts into a balanced tree for faster lookup. 4) Lookup / Update: When you do map.get("Aman"), Java repeats the same hash process to find the correct bucket and retrieve the value usually in O(1) time. In short: HashMap = Hashing + Buckets + Trees → Fast & Efficient key-value storage #Java #HashMap #DataStructures #BackendDevelopment #SpringBoot #CodingInsights #Programming

🚀 Let’s dive deeper into Java Sealed Classes: The permits keyword! Yesterday we talked about what sealed classes are and why they’re useful. Today, we’ll explore how to control inheritance using permits. What is permits? The permits keyword specifies exactly which classes are allowed to extend a sealed class. This ensures the hierarchy is strictly controlled and prevents unexpected or unwanted subclassing. Important Rule: Any class listed in the permits clause must be declared as one of the following: - final → cannot be subclassed further - sealed → can have its own limited set of subclasses - non-sealed → removes the restriction, allowing open inheritance ✅ Key takeaway: The permits keyword combined with final, sealed, or non-sealed lets you design safe, predictable, and maintainable class hierarchies. #Java #Java17 #SealedClasses #PermitsKeyword #OOP #CleanCode #ProgrammingTips #SoftwareDevelopment

☀️ Day 13 of My 90 Days Java Challenge – Wildcards & Bounded Generics Today I dove deeper into Generics, exploring the part most beginners skip: wildcards and bounds. At first, ?, ? extends, ? super looked like confusing symbols. But once I understood their purpose, everything clicked — they’re not just syntax, they’re contracts that enforce safe and flexible code. Here’s what I realized 👇 🔹 1️⃣ Unbounded wildcard (?) – the “I don’t care” placeholder List<?> means “a list of some type, I don’t know which.” It’s great for read-only access when you want generic methods that accept any collection. Most beginners misuse it by trying to add elements — but that’s exactly what it prevents safely. 🔹 2️⃣ Upper bounded wildcard (? extends) – safe reading List<? extends Number> lets you read elements as Number or its parent types. It allows flexible input while preventing unsafe writes. The lesson: upper bounds are for producers — if you’re only consuming data, use extends. 🔹 3️⃣ Lower bounded wildcard (? super) – safe writing List<? super Integer> allows adding Integer or its subclasses. It’s for consumers — if your method is mainly writing into the collection, lower bounds give flexibility without breaking type safety. 🔹 4️⃣ PECS principle – Producer Extends, Consumer Super This is the golden rule: If your collection produces data, use ? extends. If your collection consumes data, use ? super. Ignoring this principle often leads to messy, type-unsafe code. 💭 Key takeaway: Wildcards aren’t just a syntax quirk — they’re a powerful tool for safe abstraction. Understanding them transforms your generics from “just type placeholders” to real contracts that guide safe, flexible design. #Day13 #Java #CoreJava #Generics #Wildcards #TypeSafety #springboot #advanceJava #LearningJourney #90DaysChallenge

☀️ 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

(Largest Perimeter Triangle — Java 🔺) Hey everyone 👋 Today I explored how to find the largest perimeter triangle from a given array of side lengths using Java. While solving this, I understood how a simple mathematical condition can help in optimizing the entire logic 🔥 Here’s the breakdown 👇 🧠 Concept: To form a valid triangle from 3 sides, the sum of any two sides must be greater than the third one. → a + b > c → a + c > b → b + c > a 💡 Approach 1: Sort the array in descending order and check triplets from the start. If any 3 consecutive sides satisfy the triangle condition, their sum gives the largest perimeter. ⚡ Approach 2 (Optimized): Instead of reversing the array, just sort it in ascending order and iterate from the end — gives the same result but with cleaner logic and less work. 🧩 Time Complexity: O(N log N) 💾 Space Complexity: O(1) This problem helped me understand how sorting order and traversal direction can make an algorithm more elegant and efficient 🚀 📁 Code is available on my GitHub repo: https://lnkd.in/ekjD9s22 #Java #DSA #ProblemSolving #Arrays #CodingJourney #Developers #LearningByDoing #FullStackDeveloper #MCA #GitHub

☕ Revisiting Java Core Concepts Today, I explored some of the core fundamentals of Java that every developer should understand clearly. 💡 Currently, I’m following the sessions by Faisal Memon, and his explanations are helping me strengthen my understanding of Java step by step. 🙌 For those revising or learning Java — here’s a quick recap 👇 🔹 JDK, JRE, and JVM — understanding how a Java program actually runs: ➡️ It all starts with a .java file (your source code). ➡️ Using the javac compiler (part of the JDK), the source code is compiled into a .class file, which contains bytecode. ➡️ This bytecode is platform-independent, meaning it can run on any system — “Write Once, Run Anywhere.” ➡️ The JRE (Java Runtime Environment) is used to run this .class (bytecode) file. It provides the necessary libraries and runtime environment. ➡️ Inside the JRE, the JVM (Java Virtual Machine) executes the bytecode, converting it into machine code, and finally produces the output on screen. 🔹 Java 25 (LTS) — the latest Long-Term Support version, focused on performance, reliability, and modern Java enhancements. 🔹 Variables and Constants — • Variables can change during program execution. • Constants are declared using the final keyword to prevent modification. 🔹 Comments in Java — improving code readability and documentation: • Single-line → // • Multi-line → /* ... */ • JavaDoc → /** ... */ used for generating documentation. Understanding this complete flow — from writing code to seeing output — really strengthened my grasp of how Java works under the hood. 🚀 #Java #JDK #JRE #JVM #Java25 #Programming #Learning #Developers #CodingJourney #FaisalMemon #LearningJourney

🚀 Wrapping up my mini-series on Java Sealed Classes! Over the last two days, I explored what sealed classes are and how the permits keyword helps control inheritance. Today, let’s put everything together with one complete example — showing how sealed, final, and non-sealed subclasses can work in harmony. 💡 Here’s why I find sealed classes so valuable: - They bring clarity to your codebase — you instantly know all possible subclasses. - They add a layer of security and control, preventing unwanted inheritance. - They make your design cleaner and more maintainable in the long run. - And they work beautifully with pattern matching and switch expressions since the compiler knows every subclass. In short, sealed classes give Java developers the right balance between structure and flexibility — a small feature that makes a big impact on code quality. #Java #Java17 #SealedClasses #CleanCode #ProgrammingTips #OOP #CodeDesign #SoftwareDevelopment #JavaDeveloper

🚀 Just published my Java AST Parser Package! 🚀 I'm excited to share my latest open-source contribution - a powerful Java Abstract Syntax Tree (AST) parser that makes it easier to analyze and process Java source code programmatically. 📦 npm Package and Docs : (npm i java-ast-parser) 👇 https://lnkd.in/g-q6tG-z 📦 Check it out on GitHub: 👇 https://lnkd.in/gmxAGJvB Note:- I'd love your feedback and contributions! If you find this useful, please consider: ⭐ Starring the repo 🔍 Opening issues for bugs/feature requests 💡 Submitting PRs for improvements #Java #AST #OpenSource #Programming #DeveloperTools #CodeAnalysis #JavaDevelopment #GitHub