How the JVM Executes Java Methods

🚨 Exception Handling in Java: A Complete Guide I used to think exception handling in Java was just about 👉 try-catch blocks and printing stack traces. But that understanding broke the moment I started writing real code. I faced: - unexpected crashes - NullPointerExceptions I didn’t understand - programs failing without clear reasons And the worst part? 👉 I didn’t know how to debug properly. --- 📌 What changed my approach Instead of memorizing syntax, I started asking: - What exactly is an exception in Java? - Why does the JVM throw it? - What’s the difference between checked and unchecked exceptions? - When should I handle vs propagate an exception? --- 🧠 My Learning Strategy Here’s what actually worked for me: ✔️ Step 1: Break the concept - Types of exceptions (checked vs unchecked) - Throwable hierarchy - Common runtime exceptions ✔️ Step 2: Write failing code intentionally I created small programs just to: - trigger exceptions - observe behavior - understand error messages ✔️ Step 3: Learn handling vs designing - try-catch-finally blocks - throw vs throws - creating custom exceptions ✔️ Step 4: Connect to real-world development - Why exception handling is critical in backend APIs - How improper handling affects user experience - Importance of meaningful error messages --- 💡 Key Realization Exception handling is not about “avoiding crashes” 👉 It’s about writing predictable and reliable applications --- ✍️ I turned this learning into a complete blog: 👉 Exception Handling in Java: A Complete Guide 🔗 : https://lnkd.in/gBCmHmiz --- 🎯 Why I’m sharing this I’m documenting my journey of: - understanding core Java deeply - applying concepts through practice - and converting learning into structured knowledge If you’re learning Java or preparing for backend roles, this might save you some confusion I had earlier. --- 💬 What was the most confusing exception you faced in Java? #Java #CoreJava #ExceptionHandling #BackendDevelopment #SpringBoot #LearningInPublic #SoftwareDevelopment #CodingJourney

Functional style in Java is easy to get subtly wrong. This post walks through the most common mistakes — from returning null inside a mapper to leaking shared mutable state into a stream — and shows how to fix each one. https://lnkd.in/ey-7r7BW

Day 12 Today’s Java practice was about solving the Leader Element problem. Instead of using nested loops, I used a single traversal from right to left, which made the solution clean and efficient. A leader element is one that is greater than all the elements to its right. Example: Input: {16,17,5,3,4,2} Leaders: 17, 5, 4, 2 🧠 Approach I used: ->Start traversing from the rightmost element ->Keep track of the maximum element seen so far ->If the current element is greater than the maximum, it becomes a leader ->This is an efficient approach with O(n) time complexity and no extra space. ================================================= // Online Java Compiler // Use this editor to write, compile and run your Java code online class Main {   public static void main(String[] args) {     int a [] ={16,17,5,3,4,2};     int length=a.length;     int maxRight=a[length-1];     System.out.print("Leader elements are :"+maxRight+" ");           for(int i=a[length-2];i>=0;i--)     {       if(a[i]>maxRight)       {         maxRight=a[i];         System.out.print(maxRight+" ");       }     }   } } Output:Leader elements are :2 4 5 17  #AutomationTestEngineer #Selenium #Java #DeveloperJourney #Arrays

“Java is too hard to write.” Every developer at some point. But are we talking about Java then or Java now? Old Java: You had to write a lot to do something small. Modern Java: Here I did it fast. You’re welcome. The truth is. Java has changed a lot. It has streams, records and more… it’s not the same language people like to complain about. And here’s something cool. I found a site that shows new Java code side, by side: https://lnkd.in/g7n9VhMD (https://lnkd.in/g7n9VhMD) It’s like watching Java go through a glow-up. So next time someone says "Java is too hard to write" Just ask them: Which Java are you talking about? Java didn’t stay hard to write. We just didn’t keep up with Java. #Java #JDK #Features #Software #Engineering

One of the most valuable lessons from “The New Java Best Practices” by Stephen Colebourne was about Java Records and it goes far beyond reducing boilerplate. Many developers think Records are simply a shorter way to write DTOs. But the real message is this: A Record should model immutable, trustworthy data. Modern Java gives us record to clearly express intent: this object is a transparent carrier of values. Key best practices for Records: 1.All fields should be immutable Not just primitives and Strings even Lists, Maps, and nested objects should be immutable. final List<String> is not enough if the list itself can still change. 2. Prefer basic types and other Records Compose records using primitives, enums, Strings, and other immutable records for safer design. 3.Use the constructor for validation Ensure invalid objects can never be created. Examples: blank username negative amount invalid age 4.Trust generated methods Records automatically provide equals(), hashCode(), and toString(). Avoid overriding them unless there is a strong reason. 5. Be careful with toString() Generated toString() may expose sensitive values like passwords, tokens, or PII in logs. 6. Avoid arrays and mutable fields Arrays, mutable collections, and mutable references go against the core principle of records. Biggest takeaway: A Record with mutable internals is only syntactically modern not architecturally modern. Modern Java is not just about using new features. It is about using them with the right design mindset. Where Records shine: ✔ API request/response models ✔ Event payloads (Kafka, messaging) ✔ Value objects ✔ Read-only projections ✔ Configuration snapshots Where to think twice: ✖ JPA entities ✖ Stateful domain objects ✖ Objects requiring mutation-heavy lifecycle Java has evolved. The question is: Have our design habits evolved with it? #Java #SoftwareEngineering #CleanCode #BackendDevelopment #JavaDeveloper #Architecture #Programming #ModernJava #TechLeadership

Java Devs, let's talk about a core concept that makes our code cleaner and more flexible: "Method Overloading"! Ever wanted to perform similar operations with different inputs without creating a bunch of uniquely named methods? That's where Method Overloading shines! It's a fantastic example of compile-time polymorphism (aka static polymorphism or early binding) that allows a class to have multiple methods with the "same name", as long as their parameter lists are different. Key takeaways: *   Same method name, different parameters = ✅ *   Cannot overload by return type alone (parameters *must* differ) ⚠️ *   The compiler is smart! It picks the most specific match. 🧠 Check out this quick example: ```java class Product {     public int multiply(int a, int b) { // Multiplies two numbers         return a * b;     }     public int multiply(int a, int b, int c) { // Multiplies three numbers         return a * b * c;     } } // Output: // Product of the two integer value: 2 // Product of the three integer value: 6 ``` See how elegant that is? One `multiply` method, multiple functionalities! What are your favorite use cases for Method Overloading in your Java projects? Share in the comments! 👇 #Java #JavaDevelopment #Programming #SoftwareDevelopment #BeginnerProgramming

I used == for Strings when I first started learning Java… and got the wrong result 😅 That small mistake led me to understand one of the most important Java concepts: Heap Memory + String Constant Pool (SCP) Example 1 👇 String str1 = "Zayyni"; String str2 = "zayyni"; System.out.println(str1 == str2); // false System.out.println(str1.equals(str2)); // false System.out.println(str1.equalsIgnoreCase(str2)); // true Here: == → compares memory reference (same object or not) .equals() → compares actual content .equalsIgnoreCase() → compares content while ignoring case sensitivity Now the interesting part 👇 String str1 = new String("Zayyni"); String str2 = new String("Zayyni"; System.out.println(str1 == str2); // false System.out.println(str1.equals(str2)); // true Why? Because new String() creates a new object in Heap Memory every single time. Even if the value is the same, Java creates separate objects. But when we write: String str1 = "Zayyni"; String str2 = "Zayyni"; Java uses the String Constant Pool (SCP) where duplicate string literals are not created again. This saves memory and improves performance. That’s also one of the major reasons why String is immutable in Java — it makes pooling safe, efficient, and reliable. Sometimes the smallest Java concepts teach the biggest lessons. This topic is simple… but it appears in interviews more than people expect 👀 What Java concept confused you the most when you started? 👇 #Java #JavaDeveloper #SpringBoot #BackendDevelopment #Programming #SoftwareEngineering #Coding #Developers #JavaProgramming #JVM #StringPool #HeapMemory #InterviewPreparation #DeveloperLife #TechLearning #CleanCode #CodingJourney #LinkedInLearning #SoftwareDeveloper

How Garbage Collection actually works in Java ? Most developers know this much: “Java automatically deletes unused objects.” That’s true - but not how it actually works. Here’s what really happens: Java doesn’t delete objects randomly. It uses Garbage Collection (GC) to manage memory intelligently. Step 1: Object creation Objects are created in the Heap memory. Step 2: Reachability check Java checks if an object is still being used. If an object has no references pointing to it, it becomes eligible for garbage collection. Step 3: Mark and Sweep The JVM: • Marks all reachable (active) objects • Identifies unused ones • Removes those unused objects from memory Step 4: Memory cleanup Freed memory is reused for new objects. Here’s the key insight: Garbage Collection is not immediate. Just because an object has no reference doesn’t mean it’s deleted instantly. The JVM decides when to run GC based on memory needs. Java doesn’t magically manage memory. It uses smart algorithms to track object usage and clean up when needed. That’s what makes Java powerful - and sometimes unpredictable. #Java #JVM #GarbageCollection #CSFundamentals #BackendDevelopment

🚀 Fail-Fast vs Fail-Safe Iterators in Java When iterating collections, Java gives you two behaviors, and choosing the right one matters. 🔹 Fail-Fast Iterator 1. Throws ConcurrentModificationException if collection is modified during iteration 2. Works on original collection 3. Fast & memory-efficient 👉 Example: List<Integer> list = new ArrayList<>(List.of(1, 2, 3)); for (Integer i : list) { list.add(4); // ❌ throws ConcurrentModificationException } 🔹 Fail-Safe Iterator 1. Works on a clone (copy) of the collection 2. No exception if modified during iteration 3. Safer for concurrent environments 👉 Example: List<Integer> list = new CopyOnWriteArrayList<>(List.of(1, 2, 3)); for (Integer i : list) { list.add(4); // ✅ no exception } ⚖️ Key Differences Fail-Fast → detects bugs early ⚡ Fail-Safe → avoids crashes, allows modification 🛡️ 📌 Rule of Thumb Use Fail-Fast for single-threaded / debugging scenarios Use Fail-Safe for concurrent systems where stability matters 👉 If you are preparing for Java backend interviews, connect & follow - I share short, practical backend concepts regularly. #Java #BackendDevelopment #SpringBoot #DSA #InterviewPrep #JavaCollections