Java Interview Prep: Method Overriding, Final Keyword, and Inheritance

🚀 Why Java does NOT support multiple inheritance with abstract classes, but DOES with interfaces ☕💡 This is one of the most important Java interview and design questions. In Java, a class can extend only one abstract class, but it can implement multiple interfaces. Why? Because allowing multiple inheritance through classes would create ambiguity and conflicts. 😵💫 1️⃣ The Diamond Problem 💎 Imagine this: • Animal has a method sound() • Dog extends Animal and overrides sound() • Cat extends Animal and also overrides sound() Now if Pet could extend both Dog and Cat, which sound() should Java choose? 🤔 That confusion is called the diamond problem. With abstract classes, this problem is dangerous because they can contain: ✅ method implementations ✅ instance variables ✅ constructors ✅ state So if Java allowed multiple abstract-class inheritance, it would be unclear: • which parent method to use • which parent field to inherit • which constructor chain to follow That would make code harder to predict and maintain. ❌ 2️⃣ Why interfaces are allowed ✅ Interfaces were designed to describe capabilities, not object state. Example: • Flyable • Swimmable • Trackable A class can implement many of them because it is simply saying: 👉 “I support these behaviors.” interface Flyable { void fly(); } interface Swimmable { void swim(); } class Duck implements Flyable, Swimmable { public void fly() { System.out.println("Duck flies"); } public void swim() { System.out.println("Duck swims"); } } Here there is no confusion because the class itself provides the implementation. 🎯 3️⃣ But interfaces can have default methods now 😮 Yes, modern Java allows default methods in interfaces. If two interfaces have the same default method, Java forces the child class to override it explicitly. So the conflict is resolved clearly and safely. 🛡️ 4️⃣ Real reason in simple words 👇 Java avoids multiple inheritance with abstract classes because classes carry state + behavior, and mixing many parents can create clashes. ⚠️ Java allows multiple interfaces because interfaces mainly represent contracts, and Java has rules to handle conflicts cleanly. ✅ 5️⃣ Easy interview answer 🎤 Abstract classes cannot be used for multiple inheritance because they may contain state, constructors, and implemented methods, which can create ambiguity. Interfaces support multiple inheritance because they define contracts, and Java can resolve method conflicts safely. 🔥 Rule to remember: One class inheritance, many interface implementations. #Java #Programming #OOP #SoftwareEngineering #InterviewPreparation #SpringBoot #Coding #JavaDeveloper

Hii everyone, Sharing some commonly asked Java interview questions for practice: 1. Why is Java a platform independent language? 2.Why is Java not a pure object oriented language? 3.Tell us something about JIT compiler. 4. Can you tell the difference between equals() method and equality operator (==) in Java? 5.Briefly explain the concept of constructor overloading 5.Define Copy constructor in java. 6.Can the main method be Overloaded.how? 7.Explain the use of final keyword in variable, method and class 8.Do final, finally and finalize keywords have the same function? 9. When can you use super keyword and this keyword? 10. Why is the main method static in Java? 11.. Can the static methods be overridden? 13.Difference between static methods, static variables, and static classes in java. 14.What is a ClassLoader Explain its types? 15.How would you differentiate between a String, StringBuffer, and a StringBuilder? 16.Why string is immutable? 17.What do you understand by class and object? Also, give example. 18.What are the characteristics of an abstract class? 19.What is composition? 20.What is Coupling in OOP and why it is helpful? 21.Explain overloading and overriding with example? 22.Give a real-world example of polymorphism? 23.What is inheritance explain its type? 24.EXplain Encapsulation? 25.What are the differences between error and exception? 26. Using relevant properties highlight the differences between interfaces and abstract classes. 27.type of exception explain it? 28.Different bw throw and throws? 29.What are the differences between HashMap and HashTable in Java? 30.What makes a HashSet different from a TreeSet? 31.Java works as “pass by value” or “pass by reference” phenomenon? 32.Different bw ISA relationship HAS a Relationship? 33. Will the finally block get executed when the return statement is written at the end of try block and catch block as shown below? 34. Explain various interfaces used in Collection framework? 35.What is the difference between ArrayList and LinkedList? 36.What is the difference between List and Set? 37.What is the difference between Comparable and Comparator? 38. How to remove duplicates from ArrayList? 39.HashMap internal works? 40.Can you explain the Java thread lifecycle? 41. What do you understand by marker interfaces in Java? 42.types of memory in java? 43.Why is multiple inheritance not supported in java? 44.Can we override the private methods? 45.What is the difference between compile-time polymorphism and runtime polymorphism? 46.What is exception propagation? 47.volatile keyword? 48.dead lock? 49.Synchronization in java? 50.what is HashMap and weak HashMap? 51.diff b/w jdk jre jvm? 52.what is sterilization and deserialization? 53.diff HashMap and hash table? 54.wrapper class in java?

🚀 Day 6/100 — Methods in Java 🔧 As programs grow bigger, repeating the same code again and again becomes messy. This is where methods help. A method is a reusable block of code that performs a specific task. Instead of rewriting logic multiple times, you write it once and call it whenever needed. This follows the DRY principle — Don't Repeat Yourself. 🔹 Basic Method Syntax returnType methodName(parameters){ // method body } Example: public static void greet(){ System.out.println("Hello Java!"); } Calling the method: greet(); Output: Hello Java! 🔹 Method with Parameters Parameters allow methods to work with different inputs. Example: public static void add(int a, int b){ int sum = a + b; System.out.println(sum); } add(5, 3); Output: 8 🔹 Method with Return Value Sometimes a method needs to return a result. Example: public static int square(int num){ return num * num; } int result = square(4); System.out.println(result); Output: 16 🔹 Method Overloading Java allows multiple methods with the same name but different parameters. This is called method overloading. Java automatically chooses the correct method based on the arguments. Example: public static int add(int a, int b){ return a + b; } public static int add(int a, int b, int c){ return a + b + c; } Usage: System.out.println(add(5,3)); // calls first method System.out.println(add(5,3,2)); // calls second method 🔴 Live Example — Max of 3 Numbers public static int max(int a, int b, int c){ if(a >= b && a >= c){ return a; } else if(b >= a && b >= c){ return b; } else{ return c; } } public static void main(String[] args){ int result = max(10, 25, 15); System.out.println("Maximum number is: " + result); } Output: Maximum number is: 25 🎯 Challenge: Write a method to find the maximum of 3 numbers and test it with different inputs. Drop your solution in the comments 👇 #Java #CoreJava #100DaysOfCode #JavaMethods #ProgrammingJourney

Day 28: Exploring Strings in Java Today I practiced some important concepts related to Strings in Java and how they behave in memory. One of the key characteristics of Java Strings is that they are "immutable". This means once a String object is created, its value cannot be changed. Any operation like replace() or concat() creates a new String object instead of modifying the existing one. For scenarios where frequent modifications are required, using StringBuilder or StringBuffer is recommended because they are mutable. 🔹 Ways to create Strings in Java String str1 = "java"; // String literal String str2 = new String("java"); // Using new operator When Strings are created using literals, they are stored in the String Constant Pool (SCP) inside the heap memory. The SCP avoids duplicate objects to save memory. Because of this: String str1 = "java"; String str3 = "java"; System.out.println(str1 == str3); // true "==" returns true because both references point to the same object in the String Constant Pool. But when we create a String using the new operator: String str3 = new String("java"); System.out.println(str1 == str3); // false System.out.println(str1.equals(str3)); // true == compares memory addresses, while .equals() compares actual values. 🔹 Immutability Example String str7 = "Hello "; str7.concat("Everyone"); System.out.println(str7); // Output: Hello The String is not modified because Strings are immutable. 🔹 Mutable Alternative StringBuilder sb = new StringBuilder("Hello "); sb.append("Everyone"); System.out.println(sb); //Output: Hello Everyone StringBuilder and StringBuffer allow modification without creating multiple objects, making them better for frequent string manipulations in problem solving. 📌 Key Takeaways • Strings are immutable in Java • == compares references, .equals() compares values • String literals use the String Constant Pool • Use StringBuilder/StringBuffer when frequent modifications are required Learning these concepts helped me better understand how Java manages memory and string operations internally. #Java #Programming #JavaDeveloper #CodingJourney #SoftwareDevelopment #LearningInPublic Raviteja T Mohammed Abdul Rahman 10000 Coders

💬✨ STRING.INDENT() AND TRANSFORM(): SMALL JAVA APIS, BIGGER CLEAN CODE 🔸 TLDR Since Java 12, String.indent() and String.transform() make text processing much cleaner. Instead of manually splitting lines, looping, and rebuilding strings with StringBuilder, you can express the same idea in one fluent and readable pipeline. ☕✨ 🔸 WHY THIS MATTERS A lot of Java codebases still contain old-school string manipulation logic that feels heavier than the real intent. When your goal is simply: ▪️ indent some text ▪️ trim it ▪️ reformat it ▪️ chain a few transformations …you do not need ceremony anymore. Java already gives you elegant tools for that. ✅ 🔸 THE OLD WAY String[] lines = text.split("\n"); StringBuilder sb = new StringBuilder(); for (String line : lines) { sb.append(" ").append(line) .append("\n"); } String indented = sb.toString(); This works. But it is verbose, mechanical, and hides the real intention behind implementation details. 😅 🔸 THE MODERN WAY String indented = text.indent(4); String result = text .transform(String::strip) .transform(s -> s.replace(" ", "-")); Now the code says exactly what it does: ▪️ indent the text ▪️ strip extra outer spaces ▪️ replace spaces with dashes That is much easier to read at a glance. 👀 🔸 WHY THE MODERN WAY WINS ▪️ BUILT-IN Indentation is a common need, and indent() turns it into a direct API call. ▪️ CHAINABLE transform() lets you build a fluent pipeline instead of scattering temporary variables everywhere. ▪️ CLEANER INTENT The reader sees the purpose immediately, not the plumbing. ▪️ LESS BOILERPLATE No manual line splitting. No explicit loop. No StringBuilder dance. ▪️ BETTER TEACHING VALUE This is the kind of API that helps newer developers write code that looks modern and expressive from day one. 🔸 HOW IT WORKS ▪️ indent(n) adds indentation to each line of the string ▪️ transform(fn) applies a function to the string and returns the result ▪️ together, they help create readable string-processing pipelines 🔸 WHEN TO USE IT Use these APIs when: ▪️ formatting multiline text ▪️ preparing console output ▪️ adjusting generated content ▪️ applying several string operations in sequence ▪️ improving readability of utility code 🔸 TAKEAWAYS ▪️ String.indent() and String.transform() are available since Java 12 ▪️ they reduce boilerplate for common text operations ▪️ transform() is especially useful for fluent string pipelines ▪️ the biggest win is readability, not just fewer lines of code ▪️ small modern APIs can make everyday Java feel much cleaner #Java #Java12 #JDK #StringAPI #CleanCode #JavaDeveloper #SoftwareEngineering #Programming #BackendDevelopment #CodeQuality #DeveloperTips #ModernJava Go further with Java certification: Java👇 https://bit.ly/javaOCP Spring👇 https://bit.ly/2v7222 SpringBook👇 https://bit.ly/springtify JavaBook👇 https://bit.ly/jroadmap

🚨 N+1 Query Problem in Java (and how it silently kills performance) Ever faced a situation where your application works perfectly in development… but suddenly becomes slow in production? One common culprit: the N+1 Query Problem. 🔍 What is the N+1 Query Problem? It happens when: 1 query is executed to fetch a list of records (N records) Then N additional queries are executed to fetch related data for each record 👉 Total queries = N + 1 💡 Example (Spring Boot + JPA) Let’s say we have two entities: @Entity class Employee { @Id private Long id; private String name; @OneToMany(mappedBy = "employee", fetch = FetchType.LAZY) private List<Task> tasks; } @Entity class Task { @Id private Long id; private String description; @ManyToOne private Employee employee; } 🚨 The Problematic Code List<Employee> employees = employeeRepository.findAll(); for (Employee emp : employees) { System.out.println(emp.getTasks().size()); } ⚠️ What happens behind the scenes? 1 query to fetch employees: SELECT * FROM employee; Then for each employee: SELECT * FROM task WHERE employee_id = ?; 👉 If you have 100 employees → 101 queries executed ✅ Solution 1: Use JOIN FETCH @Query("SELECT e FROM Employee e JOIN FETCH e.tasks") List<Employee> findAllWithTasks(); ✔ Fetches everything in one query ✅ Solution 2: Use @EntityGraph @EntityGraph(attributePaths = {"tasks"}) List<Employee> findAll(); ✔ Cleaner and avoids manual JPQL ✅ Solution 3: Use DTO Projection (Best for APIs) @Query("SELECT new com.example.dto.EmployeeDTO(e.name, t.description) FROM Employee e JOIN e.tasks t") List<EmployeeDTO> fetchData(); ✔ Fetch only required fields → better performance 🧠 Key Takeaway The N+1 problem is not a bug… it's a design issue. Always be mindful of: Lazy vs Eager loading Query count (not just code correctness) ORM behavior under the hood Next time your app feels slow, don’t just optimize logic… Check your queries. #Java #SpringBoot #Hibernate #JPA #BackendDevelopment #PerformanceOptimization #CodingBestPractices #SoftwareEngineering #TechTips #Developers #Programming #CleanCode #SystemDesign #DatabaseOptimization #LearningInPublic

💡 Functional Interfaces in Java — Beyond the Basics If you think Functional Interfaces are just about Lambda expressions, you're only scratching the surface. Let’s go deeper 👇 🔹 Recap: What is a Functional Interface? An interface with exactly one abstract method, annotated optionally with "@FunctionalInterface" for clarity and compile-time safety. --- 🔹 Key Characteristics ✔ Can have multiple default and static methods ✔ Enables functional programming style in Java ✔ Works seamlessly with lambda expressions and method references --- 🔹 Custom Functional Interface Example @FunctionalInterface interface Calculator { int operate(int a, int b); } Usage: Calculator add = (a, b) -> a + b; System.out.println(add.operate(5, 3)); // 8 --- 🔹 Lambda vs Method Reference Lambda: (a, b) -> a + b Method Reference: Integer::sum 👉 Cleaner and more reusable when method already exists. --- 🔹 Where are Functional Interfaces Used? 🔥 1. Streams API list.stream() .filter(x -> x > 10) // Predicate .map(x -> x * 2) // Function .forEach(System.out::println); // Consumer 🔥 2. Multithreading new Thread(() -> System.out.println("Running thread")).start(); 🔥 3. Event Handling & Callbacks Used heavily in asynchronous and reactive programming. --- 🔹 Types of Functional Interfaces (Deep View) ✨ Predicate<T> → Boolean conditions Used for filtering data ✨ Function<T, R> → Transformation Convert one form of data to another ✨ Consumer<T> → Performs action Logging, printing, updating ✨ Supplier<T> → Generates data Lazy loading, object creation ✨ BiFunction / BiPredicate → Work with 2 inputs --- 🔹 Why Companies Care? (Interview Insight) ✔ Reduces boilerplate code ✔ Encourages clean architecture ✔ Essential for Spring Boot & Microservices ✔ Frequently used in real-world production code --- 🔹 Common Mistakes to Avoid ❌ Adding more than one abstract method ❌ Ignoring built-in functional interfaces ❌ Overusing lambdas (readability matters!) --- 🔹 Pro Tip for Freshers 🚀 When solving DSA or backend problems, try rewriting logic using: 👉 Lambda expressions 👉 Streams 👉 Built-in functional interfaces This shows modern Java proficiency in interviews. --- 💬 Final Thought: Functional Interfaces are not just a feature—they represent a shift in how Java developers think and write code. Master them, and your code becomes shorter, smarter, and more powerful ⚡ #Java #FunctionalProgramming #Java8 #BackendDeveloper #CodingJourney #SoftwareEngineering #InterviewPrep

🔥 Core Java (Must Prepare) 1. What is the difference between == and .equals()? == → compares reference (memory location) .equals() → compares content/value 2. Why String is immutable? Security (used in DB, network, etc.) Thread-safe String pool optimization 3. What is String Pool? A memory area in heap where unique String literals are stored. Avoids duplicate objects → improves performance 4. Difference: ArrayList vs LinkedList FeatureArrayListLinkedListStructureDynamic ArrayDoubly Linked ListAccessFastSlowInsert/DeleteSlowFast 5. How HashMap works internally? Uses hashing (hashCode + equals) Stores data in buckets Collision handled using: LinkedList (Java 7) Tree (Java 8 → Balanced Tree) 6. Difference: HashMap vs ConcurrentHashMap HashMap → not thread-safe ConcurrentHashMap → thread-safe (segment locking / CAS) 🔥 OOP & Design 7. What are OOP principles? Encapsulation Inheritance Polymorphism Abstraction 8. Method Overloading vs Overriding Overloading → same method name, different parameters Overriding → runtime polymorphism (same method in subclass) 9. What is SOLID principle? S → Single Responsibility O → Open/Closed L → Liskov Substitution I → Interface Segregation D → Dependency Injection 🔥 Multithreading (VERY IMPORTANT) 10. What is Thread? Lightweight process for parallel execution 11. Runnable vs Callable Runnable → no return Callable → returns value + throws exception 12. What is Synchronization? Prevents multiple threads accessing same resource 13. What is Deadlock? When threads are waiting on each other forever 14. What is Executor Framework? Manages thread pool → improves performance 15. What is volatile keyword? Ensures visibility of changes across threads 🔥 Java 8+ (VERY IMPORTANT) 16. What is Lambda Expression? Short way to write functional code (list) -> list.size() 17. What is Functional Interface? Interface with one abstract method Example: Runnable 18. Stream API? Used for data processing (filter, map, reduce) 19. Optional class? Avoids NullPointerException 🔥 Exception Handling 20. Checked vs Unchecked Exception Checked → compile-time (IOException) Unchecked → runtime (NullPointerException) 21. Difference: throw vs throws throw → used to throw exception throws → declares exception 🔥 Memory & JVM 22. What is JVM? Executes Java bytecode 23. Heap vs Stack Heap → Objects Stack → Method calls, variables 24. What is Garbage Collection? Automatically removes unused objects 🔥 Advanced (4+ Year Level) 25. What is Serialization? Convert object → byte stream 26. transient keyword? Skips variable during serialization 27. Comparable vs Comparator Comparable → natural sorting Comparator → custom sorting 28. Fail-fast vs Fail-safe Fail-fast → throws exception (ArrayList) Fail-safe → works on copy (ConcurrentHashMap) 🔥 Real Interview Scenario Questions 29. How do you handle high traffic in Java? Caching (Redis) Thread pool Load balancing 30. How do you debug production issue? Logs (ELK) Thread dump Heap dump

If you have a Java interview coming up, read this first. Not because I didn't know Java, but because I had never structured my thinking around the questions that actually get asked. Here's what I wish someone had handed me earlier. 👇 🔑 The OOP Pillars (know these cold) Java is built on 4 concepts. If you can't explain them clearly, the interview ends early. • Inheritance: a child class inherits properties from a parent. Think Dog extends to Animal. • Polymorphism: same method, different behaviour. A cat and a dog both have makeSound(), but they sound very different. • Encapsulation: hide your data behind private fields. Use getters and setters. Protect your class from the outside world. • Abstraction: expose only what is needed. Interfaces and abstract classes are your tools here. ⚡ The questions that always come up What's the difference between method overloading and overriding? → Overloading = same name, different parameters (compile-time) → Overriding = same name, same parameters, child redefines behaviour (runtime) What's JDK vs JRE vs JVM? → JVM runs the bytecode → JRE = JVM + libraries (for users) → JDK = JRE + dev tools like the compiler (for developers) Checked vs unchecked exceptions? → Checked = caught at compile time (FileNotFoundException) → Unchecked = caught at runtime (NullPointerException) "String vs StringBuilder vs StringBuffer?" → String is immutable → StringBuilder is mutable, not thread-safe (faster) → StringBuffer is mutable AND thread-safe (synchronized) 📦 Collections they love to ask about • ArrayList: resizable array, allows duplicates • HashMap: key-value pairs, one null key allowed • HashSet: no duplicates, unordered • LinkedList: dynamic sizing, great for frequent insertions/deletions • TreeSet: sorted, unique elements (red-black tree under the hood) 🔒 The keywords they test on • final: can't be changed/overridden/extended • static: belongs to the class, not the object • volatile: ensures visibility across threads • transient: skip this field during serialization • synchronized: one thread at a time, prevents race conditions 🧵 Threading basics they always sneak in Two ways to create a thread: extend Thread or implement Runnable. Know deadlock: it happens when two threads are each waiting for what the other holds. Know wait(), notify(), and notifyAll(): they coordinate thread communication. This is just the surface layer. But getting these right will take you through 80% of what you'll face in a Java interview. Hit a like and repost it to make it visible to a wider audience! Follow Tarun Tiwari for more! And if you're preparing right now, you've got this. 💪 #Java #JavaDeveloper #CodingInterview #SoftwareEngineering #ProgrammingTips #TechCareers #LearnJava #InterviewPrep #OOP #100DaysOfCode

Day 33 – Types of Inheritance in Java Today let's go deeper into Inheritance in Java, focusing on why we use it and the different types it offers. ---------------------------------------------- 🔹 Why Inheritance? 👉 The primary goal is Code Reusability 👉 Helps in Software Enhancement & Scalability 👉 Supports concepts like Polymorphism & Abstraction ---------------------------------------------- 🔹 Types of Inheritance in Java 📌 Java supports the following: 1️⃣ Single Level Inheritance → One child class inherits from one parent class 2️⃣ Multilevel Inheritance → A chain of inheritance (A → B → C) 3️⃣ Hierarchical Inheritance → Multiple child classes inherit from one parent 4️⃣ Multiple Inheritance (❌ Not supported with classes) → One class inheriting from multiple parents 5️⃣ Hybrid Inheritance → Combination of multiple types (achieved using interfaces in Java,also with class but it's should not be in cyclic from- cause diamond problem) ---------------------------------------------- 🔹 Examples (Simple Understanding) ✔ Single → A → B ✔ Multilevel → A → B → C ✔ Hierarchical → A → B & A → C ---------------------------------------------- 🔹 Important Rule ❌ Java does NOT support Multiple Inheritance using classes 👉 Reason: Diamond Problem (Ambiguity Issue) If a class inherits from two parents having the same method, ➡️ Java won’t know which method to execute This leads to confusion, so Java avoids it. ---------------------------------------------- 🔹 Final Keyword in Inheritance 👉 If a class is declared as final ❌ It cannot be extended final class A {} // class B extends A ❌ Not allowed #Java #OOP #Inheritance #LearningInPublic #Programming #Developers #SoftwareEngineering #JavaFullStack