5 Java Mistakes Every Beginner Makes

💎 Understanding the Diamond Problem in Java (and how Java solves it!) Ever heard of the Diamond Problem in Object-Oriented Programming? 🤔 It happens in multiple inheritance when a class inherits from two classes that both have the same method. The Problem Structure: Class A → has a method show() Class B extends A Class C extends A Class D extends B and C Now the confusion is: Which show() method should Class D inherit? This creates ambiguity — famously called the Diamond Problem Why Java avoids it? Java does NOT support multiple inheritance with classes. So this problem is avoided at the root itself. But what about Interfaces? Java allows multiple inheritance using interfaces, but resolves ambiguity smartly. If two interfaces have the same default method, the implementing class must override it. Example: interface A { default void show() { System.out.println("A"); } } interface B { default void show() { System.out.println("B"); } } class C implements A, B { public void show() { A.super.show(); // or B.super.show(); } } Key Takeaways: No multiple inheritance with classes in Java Multiple inheritance allowed via interfaces Ambiguity is resolved using method overriding Real Insight: Java doesn’t just avoid problems — it enforces clarity. #Java #OOP #Programming #SoftwareDevelopment #CodingInterview #TechConcepts

🚀 Learning Core Java – Understanding the final Keyword Today I explored an important concept in Java — the final keyword. The final keyword is used to restrict modification and helps make code more secure, predictable, and stable. It can be used with: ✔ Variables ✔ Methods ✔ Classes 🔹 1. Final Variable If a variable is declared as final: 👉 Its value cannot be changed once assigned It becomes a constant. Example conceptually: final int MAX = 100; This improves safety and prevents accidental modification. 🔹 2. Final Method If a method is declared as final: 👉 It cannot be overridden by the child class This is useful when we want to preserve the original behavior of a method. 🔹 3. Final Class If a class is declared as final: 👉 It cannot be inherited This is used when we want to stop extension of a class for security or design reasons. Example: String class is a famous final class in Java. 🔎 Why abstract and final Cannot Be Used Together These two keywords contradict each other: ✔ abstract → Must be overridden ✔ final → Cannot be overridden Because of this: ❌ abstract final is not allowed in Java 🔹 Difference Between final, finally, and finalize() final ✔ A keyword ✔ Used with variables, methods, and classes finally ✔ A block used with try or try-catch 👉 It executes whether exception occurs or not Mainly used for cleanup operations like closing files or database connections. finalize() ✔ A method of the Object class 👉 Called internally by the Garbage Collector before object destruction ⚠ Deprecated since JDK 9 due to unpredictable behavior and performance issues. 💡 Key Insight 👉 final = Restriction 👉 finally = Cleanup block 👉 finalize() = Garbage collection method Understanding these small differences avoids big confusion during interviews and real projects. Excited to keep strengthening my Core Java fundamentals! 🚀 #CoreJava #FinalKeyword #JavaDeveloper #ObjectOrientedProgramming #ProgrammingFundamentals #LearningJourney #SoftwareEngineering

Primitives vs. Objects in Java Why does some Java code turn purple in your IDE while other code stays black? It's not random—it's telling you something important. Primitive types like int, char, long, and double turn purple because they're baked directly into Java. They're the building blocks, the simplest forms of data the language recognizes. Objects like String don't get that color treatment because they're more complex structures. Here's the practical difference that matters: Objects give you access to the dot (.) operator—a key that unlocks built-in methods. With a String, you can call .toUpperCase(), .toLowerCase(), .length(), and dozens of other methods that manipulate your data. Primitives? They just hold a value. No dot, no methods, no extras. Once you understand this distinction, you'll start reading your IDE's color coding like a second language. Did you know this difference when you started? Drop a 🟣 if this clicked something for you. #java

Day 03 — Also learned something in Java today that I never even heard of before. Tokens. Yeah. Tokens. Let me explain it simply because when I first saw the word I thought it was something complicated. It's actually pretty cool. What is a Token in Java? A Token is the smallest unit in a Java program. Like when you write a sentence — the smallest unit is a word, right? In Java, when the compiler reads your code — it breaks everything down into small pieces called Tokens. There are 5 types of Tokens in Java: 1. Keywords — Reserved words Java already knows Example: `int`, `class`, `if`, `return` 2. Identifiers— Names YOU give to variables, methods, classes Example: `myName`, `totalMarks` 3. Literals— Actual values written in code Example: `10`, `"Hello"`, `true` 4. Operators— Symbols that perform operations Example: `+`, `-`, `=`, `>` **5. Separators** — Punctuation that structures code Example: `{ }`, `( )`, `;` So when you write even one simple line like: `int age = 21;` The compiler sees — a keyword, an identifier, an operator, a literal, and a separator. That one line has 5 tokens. Honestly these small concepts are building my foundation and I am not rushing it anymore. Are you also learning Java? Let me know where you are #Day11 #JavaLearning #JavaBasics #Tokens #QAJourney #ManualTesting #LearningInPublic #BeginnersInTech #SoftwareTesting

Day 11/100 – Java Practice Challenge 🚀 Continuing my #100DaysOfCode journey with another important Java concept. 🔹 Topic Covered: Compile-time vs Runtime Polymorphism 💻 Practice Code: 🔸 Compile-time Polymorphism (Method Overloading) class Calculator { int add(int a, int b) { return a + b; } int add(int a, int b, int c) { return a + b + c; } } 🔸 Runtime Polymorphism (Method Overriding) class Animal { void sound() { System.out.println("Animal sound"); } } class Cat extends Animal { @Override void sound() { System.out.println("Cat meows"); } } public class Main { public static void main(String[] args) { // Compile-time Calculator c = new Calculator(); System.out.println(c.add(10, 20)); System.out.println(c.add(10, 20, 30)); // Runtime Animal a = new Cat(); a.sound(); } } 📌 Key Learnings: ✔️ Compile-time → method decided at compile time ✔️ Runtime → method decided at runtime ✔️ Overloading vs Overriding difference 🎯 Focus: Understanding how Java resolves method calls 🔥 Interview Insight: Difference between compile-time and runtime polymorphism is one of the most frequently asked Java interview questions. #Java #100DaysOfCode #MethodOverloading #MethodOverriding #Polymorphism #JavaDeveloper #Programming #LearningInPublic

Think var in Java is just about saving keystrokes? Think again. When Java introduced var, it wasn’t just syntactic sugar — it was a shift toward cleaner, more readable code.  So what is var? var allows the compiler to automatically infer the type of a local variable based on the assigned value. Instead of writing: String message = "Hello, Java!"; You can write: var message = "Hello, Java!"; The type is still strongly typed — it’s just inferred by the compiler.  Why developers love var:  Cleaner Code – Reduces redundancy and boilerplate  Better Readability – Focus on what the variable represents, not its type  Modern Java Practice – Aligns with newer coding standards  But here’s the catch: Cannot be used without initialization Only for local variables (not fields, method params, etc.) Overuse can reduce readability if the type isn’t obvious Not “dynamic typing” — Java is still statically typed  Pro Insight: Use var when the type is obvious from the right-hand side — avoid it when it makes the code ambiguous.  Final Thought: Great developers don’t just write code — they write code that communicates clearly. var is a tool — use it wisely, and your code becomes not just shorter, but smarter. Special thanks to Syed Zabi Ulla and PW Institute of Innovation for continuous guidance and learning support. #Java #Programming

🔍 Understanding Arrays in Java (Memory & Indexing) Today I learned an important concept about arrays in Java: Given an array: int[] arr = {10, 20, 30, 40, 50}; We often think about how elements are stored in memory. In Java: ✔ Arrays are stored in memory (heap) ✔ Each element is accessed using an index ✔ JVM handles all memory internally So when we write: arr[0] → 10 arr[1] → 20 arr[2] → 30 arr[3] → 40 arr[4] → 50 👉 We are NOT accessing memory directly 👉 We are using index-based access Very-Important Point:  👉 Concept (Behind the scenes) we access elements using something like base + (bytes × index) in Java 💡 Let’s take an example: int[] arr = {10, 20, 30, 40, 50}; When we write: arr[2] 👉 We directly get 30 But what actually happens internally? 🤔 Behind the scenes (Conceptual): Address of arr[i] = base + (i × size) let's suppose base is 100 and we know about int takes 4 bytes in memory for every element :100,104,108,112,116 So internally: arr[2] → base + (2 × 4) Now base is : 100+8=108 now in 108 we get the our value : 30 Remember guys this is all happening behind the scenes 👉 You DON’T calculate it 👉 JVM DOES it for you 👉 But You Still need to know ✔ Instead, it provides safety and abstraction 🔥 Key Takeaway: “In Java, arrays are accessed using indexes, and memory management is handled by the JVM.” This concept is very useful for: ✅ Beginners in Java ✅ Understanding how arrays work internally ✅ Building strong programming fundamentals #Java #Programming #DSA #Coding #Learning #BackendDevelopment

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

Q. Can an Interface Extend a Class in Java? This is a common confusion among developers and even I revisited this concept deeply today. - The answer is NO, an interface cannot extend a class. - It can only extend another interface. But there is something interesting: - Even though an interface doesn’t extend Object, all public methods of the Object class are implicitly available inside every interface. Methods like: • toString() • hashCode() • equals() These are treated as abstractly redeclared in every interface. ⚡ Why does Java do this? - To support upcasting and polymorphism, ensuring that any object referenced via an interface can still access these fundamental methods. ❗ Important Rule: While you can declare these methods in an interface, you cannot provide default implementations for them. interface Alpha { default String toString() { // ❌ Compile time error return "Hello"; } } Reason? Because these methods already have implementations in the Object class. Since every class implicitly extends Object, allowing default implementations of these methods in interfaces would create ambiguity during method resolution. Therefore, Java does not allow interfaces to provide default implementations for Object methods. 📌 Interfaces don’t extend Object, but its public methods are implicitly available. However, default implementations for them are not allowed. #Java #OOP #InterviewPreparation #Programming #Developers #Learning #SoftwareEngineering

📘 Day 9 of Java Learning Series 🔹 String vs StringBuilder vs StringBuffer If you're working with text in Java, understanding these 3 is very important 👇 🔸 1. String ✔ Immutable (cannot be changed) ✔ Every modification creates a new object ✔ Slower when modifying frequently 💡 Example: String s = "Hello"; s = s + " World"; 🔸 2. StringBuilder ✔ Mutable (can be changed) ✔ Faster than String ✔ Not thread-safe 💡 Example: StringBuilder sb = new StringBuilder("Hello"); sb.append(" World"); 🔸 3. StringBuffer ✔ Mutable ✔ Thread-safe (synchronized) ✔ Slightly slower than StringBuilder 💡 Example: StringBuffer sbf = new StringBuffer("Hello"); sbf.append(" World"); 🔸 Key Differences: ✔ String → Immutable ✔ StringBuilder → Fast & Non-Synchronized ✔ StringBuffer → Thread-Safe 💡 When to Use? ✔ Use String → when data doesn’t change ✔ Use StringBuilder → for performance (most cases) ✔ Use StringBuffer → in multi-threaded apps 💬 Which one do you use the most? 👉 Follow me for more Java content 🚀 #Java #Programming #100DaysOfCode #Developers #Learning #CoreJava