Java Multiple Inheritance Limitation and Interface Solution

A small Java concept I revisited this week: Difference between String.valueOf() and toString() At first glance, both convert objects to String: String.valueOf(obj) obj.toString() But their behavior is different when the object is null. Example: Object obj = null; String.valueOf(obj); // returns "null" obj.toString();  // throws NullPointerException So why does this happen? Let’s look at the internal working. Inside the String class, String.valueOf(Object obj) is implemented like this: public static String valueOf(Object obj) {  return (obj == null) ? "null" : obj.toString(); } This means: • If the object is null → it safely returns the string "null" • Otherwise → it calls obj.toString() But when we directly call: obj.toString() Java tries to invoke a method on a null reference, which immediately throws a NullPointerException. Why this matters in real applications: When converting values (like IDs, numbers, or objects) to String, String.valueOf() is often safer because it avoids unexpected crashes. Small details like this make Java code more reliable. Always interesting how tiny language features can prevent real production bugs. Which one do you usually use in your projects? #Java #BackendEngineering #SoftwareEngineering #JavaTips #LearningInPublic

🔹 Why are Strings immutable in Java? This is one of the most common questions asked in Java interviews. But the real value is not just knowing that Strings are immutable — it's understanding why Java was designed this way. Let’s break it down in a simple way. 👇 📌 First, what does immutable mean? In Java, once a String object is created, its value cannot be changed. For example: String s = "Hello"; s.concat(" World"); You might expect the value to become "Hello World", but it doesn't change the original String. Instead, Java creates a new String object. 🔐 1. Security Strings are used in many sensitive areas like: • File paths • Database connections • Class loading • Network URLs Example: Class.forName("com.company.PaymentService"); If Strings were mutable, someone could modify the class name after validation and load a malicious class. Immutability helps keep these operations secure and predictable. 🧠 2. String Pool (Memory Optimization) Java maintains a special memory area called the String Constant Pool. When we write: String a = "hello"; String b = "hello"; Both variables point to the same object in memory. Because Strings cannot change, Java can safely reuse objects, saving a lot of memory in large applications. ⚡ 3. Thread Safety Immutable objects are naturally thread-safe. Multiple threads can read the same String without needing synchronization. This is extremely useful in high-concurrency backend systems like Spring Boot microservices. 🚀 4. Better Performance in HashMap Strings are commonly used as keys in HashMap. Since the value of a String never changes, its hashCode can be cached, which makes lookups faster. If Strings were mutable, the hash value could change and the object might become unreachable inside the map. 💡 In short Making Strings immutable improves: 🔐 Security 🧠 Memory efficiency ⚡ Performance 🧵 Thread safety Sometimes the most powerful design decisions in a programming language are the ones that quietly make systems more stable and predictable. Java’s immutable String is one of those brilliant decisions. ☕ #Java #JavaDevelopers #BackendDevelopment #JVM #Programming #SoftwareEngineering

☕ Java Daily Dose #7 Why Java cares so much about "equals()" and "hashCode()" Most developers know the rule: 👉 If you override "equals()", you must override "hashCode()". But why? When you store an object in a hash-based collection ("HashMap", "HashSet", etc.), Java does not start with "equals()". Instead it follows this flow: 1️⃣ Call "hashCode()" 2️⃣ Use it to select a bucket 3️⃣ Inside that bucket, use "equals()" to check equality So in simple terms: - "hashCode()" → Where to look - "equals()" → Whether it matches ⚠️ If two objects are logically equal but have different hashCodes, they land in different buckets. "equals()" is never called. Result? ❌ No compile error ❌ No exception ❌ Tests may pass 💥 But production behavior becomes incorrect. That’s why the Java contract exists: «Override "equals()" → Always override "hashCode()"» Because in Java collections: "hashCode()" helps Java find. "equals()" helps Java decide. Break the contract → Break the collection. #JavaDailyDose #Java #BackendEngineering #JavaCollections

📌 Java Question – Why Are Strings Immutable? We use String every day in Java. But have you ever thought: - Why are Strings immutable in Java? You cannot change them once created. String s = "Hello"; s.concat(" World"); System.out.println(s); 👉 Output: Hello Even after calling concat, the original string didn’t change. 🤯 Why Did Java Design It This Way? There are 3 strong reasons behind this decision. 🔐 1️⃣ Security Strings are used in: - Database connections - File paths - Network URLs If Strings were mutable, these values could be changed at runtime, creating security risks. ⚡ 2️⃣ String Pool (Memory Optimization) Java stores Strings in a String Pool. String a = "Java"; String b = "Java"; Both a and b point to the same object. This is only possible because Strings are immutable. 👉 Saves memory 👉 Improves performance 🧵 3️⃣ Thread Safety Immutable objects are inherently thread-safe. No synchronization needed. Multiple threads can safely use the same String object. 🧠 Key Insight Whenever you “modify” a String: s = s.concat(" World"); 👉 A new object is created 👉 The old one remains unchanged Follow for more Java basics, interview questions, and system design concepts. #Java #Programming #SoftwareEngineering #JavaDeveloper #InterviewPreparation

Day 2 of improving my Java basics. Tried something different today — finding the length of a string without using length() method. Used exception handling and charAt() to figure it out. Small problem, but it really made me think about how things work internally. =============================================== // Online Java Compiler // Use this editor to write, compile and run your Java code online class Main {   public static void main(String[] args) {           String s="Madhukar Pandey";     int count =0;     boolean b=true;           while(b)     {       try       {         s.charAt(count);         count++;       }       catch(StringIndexOutOfBoundsException e )       {         System.out.println("Length of string is:"+count);         b=false;                 }     }   } }

EVERYONE CAN WRITE JAVA CODE. BUT CAN YOU ANSWER WHAT THE JVM IS ACTUALLY DOING AT RUNTIME? Below are REAL interview questions used to test production-level Java understanding. Java (Runtime, JVM, Concurrency) 1) A Java application becomes slower over time without throwing errors. What could be happening internally? 2) OutOfMemoryError occurs even though heap size looks sufficient. How is that possible? 3) CPU usage is low but response time is very high. What might be blocking the system? 4) Threads are available in the pool but requests are still waiting. Why? 5) Increasing heap size suddenly made performance worse. Explain why. 6) GC pauses increased after a small code deployment. What could have changed? 7) JVM does not terminate even after main() method finishes. What keeps it alive? 8) Parallel streams were introduced but throughput dropped. Why might this happen? 9) Memory usage keeps increasing slowly during runtime. What should you investigate first? 10) Logging configuration change caused a production slowdown. Why? 11) ThreadLocal solved one problem but introduced memory issues. How? 12) ExecutorService tasks fail silently without visible exceptions. Why? 13) Java application behaves differently on Java 8 vs Java 17. What might cause this? 14) Retry logic implemented in code caused system overload. What was the mistake? 15) HashMap performance suddenly degraded when data increased. What could be the reason? 16) Application latency increases but CPU and memory look normal. What would you check? 17) Multiple threads updating shared data cause inconsistent results. Why? 18) Deadlock occurs rarely in production but never locally. What might cause this? 19) High GC frequency starts affecting application response time. What could be happening? 20) A background thread starts affecting API performance. How would you identify it? These questions are asked to see whether you understand how Java behaves in real systems, not just how to write code. I’ll share the detailed pdf of Java and Spring boot Questions individually with interested folks.

❗ Java Bug: Why final List or final Map Is Not Immutable in Java Recently, I ran into immunity issue in Java, which I've never paid attention before. It’s a common misconception that marking a field final automatically makes it “safe” or “immutable.” Unfortunately, this is not true when the field holds a mutable object such as a List or Map. Let’s look at this Java class: @Getter @Builder public class Plan { private final List<String> toDoList; } At first glance, this looks immutable: the field is final, and there is no setter. But watch what happens: List<String> initialToDoList = new ArrayList<>(Arrays.asList("Buy groceries", "Read a book", "Exercise")); var plan = Plan.builder().toDoList(initialToDoList).build(); List<String> firstList = plan.getToDoList(); firstList.size()==3; firstList .add("Learn Java"); //No Exception Obtain list again AFTER adding the item: List<String> secondList = plan.getToDoList(); Now firstList.size()==4 and secondList.size()==4 firstList contains the newly added item 'Learn Java' secondList contains the newly added item 'Learn Java' ❇️ Conclusion: Summary object looks immutable from the outside, but its internal state can be changed at any time. That’s not immutability—that’s an illusion of immutability. I feel it's a Java Bug. If it's final, why not just make it immutable no matter if it's a collection or not 😂. #Java

Most Java developers get confused by this exception. Let me explain why. You run this code: System.out.println("12345".charAt(6)); And the stack trace says StringIndexOutOfBoundsException. But wait... shouldn't it be IndexOutOfBoundsException? 🤔 Here's the thing: it IS an IndexOutOfBoundsException. Java's exception hierarchy uses inheritance to give you MORE specific information, not different information. The hierarchy looks like this: RuntimeException  └── IndexOutOfBoundsException     ├── StringIndexOutOfBoundsException     └── ArrayIndexOutOfBoundsException This is polymorphism applied to exceptions 💡 → charAt() throws StringIndexOutOfBoundsException because the problem happened in a String → array[10] throws ArrayIndexOutOfBoundsException because the problem happened in an array → list.get(99) throws IndexOutOfBoundsException because the problem happened in a collection → A catch(IndexOutOfBoundsException e) block catches ALL of them Why does this matter? When you write catch blocks, you can choose your level of specificity. Catching the parent handles everything. Catching the child gives you precise control over what you handle and what you propagate. This is the same design principle behind Java's entire exception framework: specificity through inheritance. Understanding this hierarchy is what separates a developer who reads stack traces from one who truly understands them. ⚡ What other Java exceptions have tripped you up? Drop them in the comments 👇 📊 Oracle Java SE 17 Docs - IndexOutOfBoundsException API (2025) https://lnkd.in/eN_5XAp4 📊 Baeldung - Java ArrayIndexOutOfBoundsException (2025) https://lnkd.in/evZcjMHs 📊 Rollbar - How to Handle StringIndexOutOfBoundsException in Java (2022) https://lnkd.in/erHwcX4T #Java #SoftwareEngineering #Backend #ExceptionHandling #Programming #OOP #JavaDeveloper #CleanCode

Basic Java Questions That Every Developer Should Know 1️⃣ Why is Java not considered a pure object-oriented language? 💡 Hint: Think about primitive data types. 2️⃣ What is the difference between == and .equals() in Java? 💡 Hint: Reference vs value comparison. 3️⃣ Why is the main() method declared as static in Java? 💡 Hint: Think about how the JVM calls it. 4️⃣ What is the difference between String, StringBuilder, and StringBuffer? 💡 Hint: Mutability and thread safety. 5️⃣ Why doesn’t Java support multiple inheritance with classes? 💡 Hint: The famous Diamond Problem. 6️⃣ What is the difference between JDK, JRE, and JVM? 💡 Hint: Think about development vs execution. 7️⃣ What is the difference between ArrayList and LinkedList? 💡 Hint: Internal data structure and performance. 8️⃣ What happens if you don’t override hashCode() when you override equals()? 💡 Hint: Think about HashMap behavior. 9️⃣ What is the difference between final, finally, and finalize in Java? 💡 Hint: They belong to completely different concepts. 🔟 Why are Strings immutable in Java? 💡 Hint: Security, caching, and thread safety. 💬 Follow for more Java interview questions and system design concepts. 📩 Feel free to drop me a message if you'd like to discuss any interview question. #Java #Programming #SoftwareEngineering #InterviewPreparation #JavaDeveloper