Soniya M’s Post

*⚡ Control Flow in Java (if-else & switch)* *✅ 1️⃣ What is Control Flow?* 👉 Control Flow determines which code runs and when. Example: If condition is true → do this Else → do something else *✅ 2️⃣ if Statement* Used when you want to execute code only if a condition is true. if (condition) { // code } Example: int age = 20; if (age >= 18) { System.out.println("You can vote"); } *✅ 3️⃣ if-else Statement* Used when you want two outcomes. if (condition) { // true block } else { // false block } Example: int age = 16; if (age >= 18) { System.out.println("Adult"); } else { System.out.println("Minor"); } *✅ 4️⃣ if-else if Ladder* Used when you have multiple conditions. int marks = 85; if (marks >= 90) { System.out.println("A Grade"); } else if (marks >= 75) { System.out.println("B Grade"); } else if (marks >= 50) { System.out.println("C Grade"); } else { System.out.println("Fail"); } *🔥 Important Rule ⭐* 👉 Conditions are checked top to bottom 👉 First true condition executes → rest are skipped *✅ 5️⃣ Nested if* 👉 if inside another if int age = 20; boolean hasID = true; if (age >= 18) { if (hasID) { System.out.println("Allowed"); } } *✅ 6️⃣ switch Statement* Used when you have multiple fixed values. 👉 Cleaner than multiple if-else switch (variable) { case value1: // code break; case value2: // code break; default: // code } Example: int day = 2; switch (day) { case 1: System.out.println("Monday"); break; case 2: System.out.println("Tuesday"); break; default: System.out.println("Invalid"); } *🔥 Important Concepts (switch ⭐)* 1️⃣ break keyword 👉 Stops execution after a case Without break: case 1: System.out.println("Monday"); case 2: System.out.println("Tuesday"); 👉 Output: Monday Tuesday 2️⃣ default case 👉 Runs when no case matches *✅ 7️⃣ When to Use What?* - Simple condition: Use if - Two outcomes: Use if-else - Multiple conditions: Use if-else if - Fixed values: Use switch *🔥 Example Program* 👉 This program performs two tasks: 1️⃣ Checks whether a number is positive or negative 2️⃣ Prints the day based on a number using switch class ControlFlowDemo { public static void main(String[] args) { int number = 10; if (number > 0) { System.out.println("Positive"); } else { System.out.println("Negative"); } int day = 1; switch (day) { case 1: System.out.println("Monday"); break; default: System.out.println("Other day"); } } } ✔ Checks number → Positive/Negative ✔ Uses switch → prints day ✔ Uses break → stops execution ✔ Uses default → fallback *⭐ Common Interview Questions* - Difference between if-else and switch - When to use switch over if - What happens if break is missing? - Can we use String in switch? (👉 Yes, Java 7+) *🔥 Quick Revision* if → single condition if-else → two outcomes if-else if → multiple conditions

*⚡ Control Flow in Java (if-else & switch)* *✅ 1️⃣ What is Control Flow?* 👉 Control Flow determines which code runs and when. Example: If condition is true → do this Else → do something else *✅ 2️⃣ if Statement* Used when you want to execute code only if a condition is true. if (condition) { // code } Example: int age = 20; if (age >= 18) { System.out.println("You can vote"); } *✅ 3️⃣ if-else Statement* Used when you want two outcomes. if (condition) { // true block } else { // false block } Example: int age = 16; if (age >= 18) { System.out.println("Adult"); } else { System.out.println("Minor"); } *✅ 4️⃣ if-else if Ladder* Used when you have multiple conditions. int marks = 85; if (marks >= 90) { System.out.println("A Grade"); } else if (marks >= 75) { System.out.println("B Grade"); } else if (marks >= 50) { System.out.println("C Grade"); } else { System.out.println("Fail"); } *🔥 Important Rule ⭐* 👉 Conditions are checked top to bottom 👉 First true condition executes → rest are skipped *✅ 5️⃣ Nested if* 👉 if inside another if int age = 20; boolean hasID = true; if (age >= 18) { if (hasID) { System.out.println("Allowed"); } } *✅ 6️⃣ switch Statement* Used when you have multiple fixed values. 👉 Cleaner than multiple if-else switch (variable) { case value1: // code break; case value2: // code break; default: // code } Example: int day = 2; switch (day) { case 1: System.out.println("Monday"); break; case 2: System.out.println("Tuesday"); break; default: System.out.println("Invalid"); } *🔥 Important Concepts (switch ⭐)* 1️⃣ break keyword 👉 Stops execution after a case Without break: case 1: System.out.println("Monday"); case 2: System.out.println("Tuesday"); 👉 Output: Monday Tuesday 2️⃣ default case 👉 Runs when no case matches *✅ 7️⃣ When to Use What?* - Simple condition: Use if - Two outcomes: Use if-else - Multiple conditions: Use if-else if - Fixed values: Use switch *🔥 Example Program* 👉 This program performs two tasks: 1️⃣ Checks whether a number is positive or negative 2️⃣ Prints the day based on a number using switch class ControlFlowDemo { public static void main(String[] args) { int number = 10; if (number > 0) { System.out.println("Positive"); } else { System.out.println("Negative"); } int day = 1; switch (day) { case 1: System.out.println("Monday"); break; default: System.out.println("Other day"); } } } ✔ Checks number → Positive/Negative ✔ Uses switch → prints day ✔ Uses break → stops execution ✔ Uses default → fallback *⭐ Common Interview Questions* - Difference between if-else and switch - When to use switch over if - What happens if break is missing? - Can we use String in switch? (👉 Yes, Java 7+) *🔥 Quick Revision* if → single condition if-else → two outcomes if-else if → multiple conditions

🚀🎊Day 86 of 90 – Java Backend Development ✨🎆 In Java, an Enum (short for "enumeration") is a special data type used to define a collection of constants. Think of it as a way to create a fixed list of predefined values that a variable can hold—like the days of the week, compass directions, or the states of a process. Before enums were introduced in Java 5, developers used public static final constants, which were prone to errors and lacked type safety. Enums solved this by making the code more readable and robust. 👉1. Basic syntax: Defining an enum is similar to defining a class, but you use the enum keyword. By convention, enum constants are written in uppercase. enum Level {  LOW,  MEDIUM,  HIGH } You can then use this enum in your code like this: Level myVar = Level.MEDIUM; 👉2. Why use enums? Type Safety: You can't accidentally assign a value that isn't part of the enum (e.g., you can't set a Level to "SUPER_HIGH" if it isn't defined). i) Readability: It makes it clear to anyone reading your code what the allowed options are. ii) Switch Statements: Enums work beautifully with switch blocks, making logic branching much cleaner. 👉3. Enums are classes: In Java, enums are more powerful than in many other languages because they are effectively classes. This means they can have: i) Fields: To store additional data for each constant. ii) Methods: To perform actions based on the constant. iii) Constructors: To initialize those fields (though they are always private or package-private). 👉Code explanation enum TrafficLight {   RED("STOP"),    YELLOW("CAUTION"),    GREEN("GO");   private String action;   // Constructor   TrafficLight(String action) {     this.action = action;   }   public String getAction() {     return this.action;   } } 👉4. Useful built-in methods: Every Java enum automatically inherits methods from the java.lang.Enum class: i) values() ----->Returns an array of all constants in the enum. ii) ordinal() ----->Returns the index of the constant (starting at 0). iii) valueOf(String)------>Returns the enum constant with the specified string name. 👉5. When to avoid them: While enums are great for fixed sets of data, don't use them if the list of values needs to change at runtime (e.g., a list of users or products from a database). Enums are strictly for compile-time constants. #Java #Enums

⏳Day 25 – 1 Minute Java Clarity – throw vs throws Two words, one letter difference… huge impact! ⚡ 📌 What is throw? Used to manually throw an exception inside a method. 👉 Followed by an exception object. 📌 What is throws? Used to declare that a method might throw an exception. 👉 Written in the method signature. 📌 Example: class AgeValidator {   // throws declares the exception   void validateAge(int age) throws IllegalArgumentException {     if (age < 18) {       throw new IllegalArgumentException("Age must be 18+"); // throw triggers it     }     System.out.println("Access granted ✅");   }   public static void main(String[] args) {     AgeValidator av = new AgeValidator();     try {       av.validateAge(15);     } catch (IllegalArgumentException e) {       System.out.println(e.getMessage());     }   } } 📌 Key Differences at a Glance: | Feature | throw | throws | | Purpose | Trigger an exception | Declare an exception | | Location | Inside method body | Method signature | | Followed by | Exception object | Exception class name | | Count | One exception at a time | Multiple allowed | 💡 Real-time Example: Think of a security guard 🏢 throw → Guard physically stops you ("You can't enter!") throws → Sign on the door ("ID required to enter") ⚠️ Interview Trap: Can throw handle checked exceptions without try-catch? 👉 NO! Checked exceptions thrown via `throw` must be caught or declared with `throws`! 📌 Quick Tip: java // Multiple exceptions with throws void readFile() throws IOException, FileNotFoundException {   // code } 💡 Quick Summary: ✔ throw → manually raises an exception (action) ✔ throws → warns callers about possible exceptions (declaration) ✔ throw is inside the method, throws is on the method ✔ throw handles one; throws can declare many 🔹 Next Topic → Custom Exceptions in Java Did you know you can throw any object that extends Throwable? Drop 🔥 if this was clear! #Java #ThrowVsThrows #ExceptionHandling #CoreJava #JavaProgramming #JavaDeveloper #BackendDeveloper #1MinuteJavaClarity #100DaysOfCode #Coding

🚀 Today I dived deep into Exception Handling in Java! Have you ever seen a "software not responding" popup or had an app suddenly crash?,. That is often because of an unhandled exception. What is an Exception? In Java, an exception is an unusual event that occurs during the runtime (execution) of a program,,. It is usually triggered by faulty user input—like trying to divide a number by zero or providing a string when a number is expected,,. If these aren't handled, they lead to abrupt termination, which ruins the user experience and can cause significant losses for a company,. How it works behind the scenes: When a problem occurs, the JVM automatically creates an Exception Object,. This object contains the "What" (type of error), "Where" (line number), and "Why" (the reason),. If we don't catch it, the Default Exception Handler prints the error and stops the program immediately,. The Solution: Try-Catch Blocks To ensure normal termination, we follow three simple steps: 1.Identify risky lines of code where a problem might occur,. 2.Place that code inside a try block,. 3.Write a catch block to intercept the exception object and handle it gracefully,. Pro Tip: The Order of Catch Blocks Matters! ⚠️ You can have multiple catch blocks for different errors (like ArithmeticException or ArrayIndexOutOfBoundsException),. However, you must always put specific exceptions first and the general Exception class last,. If you put the general one first, the specific ones become unreachable code because the general class has the capability to catch everything. Code Example: import java.util.Scanner; public class ExceptionDemo { public static void main(String[] args) { Scanner scan = new Scanner(System.in); System.out.println("Connection established."); try { // Step 1 & 2: Identify and wrap risky code, System.out.print("Enter numerator: "); int a = scan.nextInt(); System.out.print("Enter denominator: "); int b = scan.nextInt(); int result = a / b; // Risky line: ArithmeticException if b=0 System.out.println("Result: " + result); } catch (ArithmeticException e) { // Step 3: Handle specific exception, System.out.println("Error: Please enter a non-zero denominator."); } catch (Exception e) { // General catch-all for other unexpected issues System.out.println("Some technical problem occurred."); } System.out.println("Connection terminated.");, } } Looking forward to exploring rethrowing and ducking exceptions tomorrow!. #Java #Coding #BackendDevelopment #ExceptionHandling #LearningJourney #SoftwareEngineering #TapAcademy

🚀🎊Day 78 of 90 – Java Backend Development ✨🎆 A Memory Leak in Java occurs when objects are no longer being used by the application, but the Garbage Collector (GC) is unable to remove them from the heap memory because they are still being unintentionally referenced. Even though Java has automatic memory management, a leak will slowly consume the available heap space until the JVM throws an OutOfMemoryError (OOM), causing the application to crash. 👉1. How it happens (The "GCRoot" Problem) In Java, an object is eligible for garbage collection if it is "unreachable." The GC starts from GC Roots (like local variables in the active thread or static variables) and traces all references. i) Normal Behaviour: When a method finishes, its local variables are cleared, the objects they pointed to become unreachable, and the GC reclaims the memory. ii) The Leak: An object is "logically" dead (your code doesn't need it anymore), but a "physically" live reference still exists (e.g., a forgotten item in a static List). Because a path still exists from a GC Root, the GC assumes the object is still important and leaves it alone. 👉 2. Common Causes in Java 👉Static Collections Static variables live for the entire lifetime of the JVM. If you add objects to a static List or Map and never remove them, they will stay in memory forever. public class Cache {   private static Map<String, Object> map = new HashMap<>();   // If we never call map.remove(), this grows until OOM } 👉Unclosed resources: Connections to databases, files, or network sockets consume memory. If you don't call .close() (or use try-with-resources), the underlying native buffers may leak. 👉Inner classes: Non-static inner classes hold an implicit reference to their outer class. If the inner class object is passed around or stored, the outer class cannot be garbage collected, even if it's no longer used. 👉 Improper equals() and hashCode(): If you use custom objects as keys in a HashMap but don't implement equals() and hashCode() correctly, the Map won't find the duplicate keys. Instead, it will keep adding new entries every time you "update" a value, leading to a silent leak. 👉3. Symptoms of a memory Leak i) Performance Degradation: The GC runs more and more frequently (and takes longer) as it struggles to find free space, leading to "Stop-the-world" pauses. ii) Increased Memory Usage: The "Old Gen" (Tenured) space of the heap shows a steady upward trend in a sawtooth pattern that never returns to its baseline. iii) OutOfMemoryError: The application eventually crashes with java.lang.OutOfMemoryError: Java heap space. 👉 4. How to Detect and Fix To identify a leak, you need to look "inside" the JVM: i)Heap Dumps: Take a snapshot of the memory using jmap or via your IDE. ii)Analysis Tools: Use tools like Eclipse MAT (Memory Analyzer) or VisualVM. These tools show you which objects are taking up the most space and, more importantly, the "Path to GC Root" that is keeping them alive.

Let’s talk about Optional in Java. ☕ When should you use it, and when should you avoid it? Recently, I saw a post suggesting using Optional as a method parameter to simulate Kotlin's Elvis operator (?:). This is actually an anti-pattern! Let's review when to use it and when to avoid it, inspired by Stuart Marks’s famous talk on the topic. What’s the actual problem with null in Java? It’s semantic ambiguity: is it an error, an uninitialized variable, or a legitimate absence of a value? This forces us into defensive coding (if (obj != null)) to avoid the dreaded NPEs. Java introduced Optional<T> to declare a clear API contract: "This value might not be present; it's your responsibility to decide how to handle its absence." ✅ WHERE TO USE OPTIONAL: 👉 Method Return Types: This is its primary design purpose. It clearly communicates that a result might be empty: Optional<SaleEntity> findSaleById(Long id) 👉 Safe Transformations: Extract nested data without breaking your flow with intermediate null checks: var city = Optional.ofNullable(client) .map(Client::getAddress) .map(Address::getCity) .orElse("Unknown"); 👉 Stream Pipelines: Using flatMap(Optional::stream) elegantly filters a stream, leaving only the present values without cluttering your code. ❌ WHERE NOT TO USE OPTIONAL (ANTI-PATTERNS): 👉 Method Parameters: Never do this. It complicates the signature, creates unnecessary object allocation, and doesn't even prevent someone from passing a null instead of an Optional! Use internal validations (Objects.requireNonNull). 👉 Calling .get() without checking: Never call Optional.get() unless you can mathematically prove it contains a value. Prefer alternatives like .orElse(), .orElseGet(), or .ifPresent(). 👉 Returning Null for an Optional: If your method returns an Optional, returning a literal null defeats the entire purpose and will cause unexpected NPEs downstream. Always return Optional.empty(). 👉 Class Fields (Attributes): Optional is not Serializable. Use a documented null or the "Null Object Pattern". 👉 Collections: Never return Optional<List<T>>. Just return an empty list (Collections.emptyList()). It's semantically correct and saves memory. Optional doesn't eradicate null, but it helps us design more honest APIs. Let's use it responsibly. 🛠️ To dive deeper, I've attached a PDF summary of the core rules for Optionals. 📄👇 What other anti-patterns have you seen when using Optionals? Let me know below! (PS: I'll leave the link to Stuart Marks's full video breakdown in the first comment). #Java #SoftwareEngineering #CleanCode #Backend #JavaDeveloper #Optional

⏳Day 26 – 1 Minute Java Clarity – Custom Exceptions Why use generic when you can be specific? 🎯 📌 What is a Custom Exception? A user-defined exception class that extends Exception or RuntimeException. 👉 Makes error messages meaningful and domain-specific. 📌 Example: // Step 1: Create custom exception class InsufficientBalanceException extends Exception {   public InsufficientBalanceException(String message) {     super(message); // passes message to Exception class   } } // Step 2: Use it in business logic class BankAccount {   double balance = 1000.0;   void withdraw(double amount) throws InsufficientBalanceException {     if (amount > balance) {       throw new InsufficientBalanceException(         "Insufficient balance! Available: ₹" + balance       );     }     balance -= amount;     System.out.println("Withdrawn ₹" + amount + " ✅");   }   public static void main(String[] args) {     BankAccount acc = new BankAccount();     try {       acc.withdraw(5000);     } catch (InsufficientBalanceException e) {       System.out.println(e.getMessage());     }   } } 📌 Checked vs Unchecked Custom Exception: // Checked – must handle at compile time class MyCheckedException extends Exception { } // Unchecked – no forced handling class MyUncheckedException extends RuntimeException { } 💡 Real-time Example: Think of a food delivery app 🍕 Generic → "Error occurred" Custom → "Restaurant is closed. Try again after 10 AM" ✅ Custom exceptions make error messages **user-friendly and actionable!** ⚠️ Interview Trap: When should you use checked vs unchecked custom exceptions? 👉 Checked → Recoverable errors (file not found, DB down) 👉 Unchecked → Programming mistakes (invalid input, null values) 💡 Quick Summary: ✔ Extend Exception for checked custom exceptions ✔ Extend RuntimeException for unchecked ✔ Always pass meaningful messages via super() ✔ Name them clearly — InsufficientBalanceException beats Exception123! 🔹 Next Topic → Java Collections Framework Did you know Netflix and banks use custom exceptions to log errors silently without crashing? Drop 🔥 if this was useful! #Java #CustomExceptions #ExceptionHandling #CoreJava #JavaProgramming #JavaDeveloper #BackendDeveloper #1MinuteJavaClarity #100DaysOfCode

🚀 Java Wrapper Classes: Hidden Behaviors That Trip Up Even Senior Developers Most developers know wrapper classes. Very few understand what happens under the hood — and that’s exactly where top companies separate candidates. Here’s a deep dive into the concepts that actually matter 1. Integer Caching Integer a = 4010; Integer b = 4010; System.out.println(a == b); // false Integer c = 127; Integer d = 127; System.out.println(c == d); // true Q.Why? Java caches Integer values in the range -128 to 127. Inside range → same object (cached) Outside range → new object (heap) 💡 Pro Insight: You can even extend this range using: -XX:AutoBoxCacheMax=<size> 2. == vs .equals() — Silent Bug Generator System.out.println(a == b); // false → reference comparison System.out.println(a.equals(b)); // true → value comparison Using == with wrapper objects is one of the most common production bugs. Rule: == → checks memory reference .equals() → checks actual value 3. hashCode() vs identityHashCode() System.out.println(a.hashCode()); System.out.println(System.identityHashCode(a)); Two objects can have: Same value → same hashCode() Different memory → different identityHashCode() 4. Silent Overflow in Primitive Conversion Integer a = 4010; byte k = a.byteValue(); // -86 What actually happens: byte range = -128 to 127 4010 % 256 = 170 170 interpreted as signed → -86 No error. No warning. This is how real-world bugs sneak into systems. 5. Powerful Utility Methods (Underrated) Integer.toBinaryString(4010); Integer.toHexString(4010); Integer.bitCount(4010); Integer.numberOfLeadingZeros(4010); Useful in: Bit manipulation Competitive programming Low-level optimization 6. Character & Boolean — Also Cached Boolean b1 = true; Boolean b2 = true; System.out.println(b1 == b2); // true Boolean → fully cached Character → cached in ASCII range 7. Character Utilities = Clean Code Character.isLetter('a'); Character.isDigit('3'); Character.isWhitespace('\t'); Character.toUpperCase('a'); The Big Picture Wrapper classes are NOT just primitives with methods. They reveal how Java handles: Memory optimization Object identity Autoboxing behavior Performance trade-offs A big thanks to my mentors Syed Zabi Ulla, peers, and the amazing developer community Oracle for continuously pushing me to go beyond basics and truly understand concepts at a deeper level. #Java #JVM #CoreJava #CodingInterview #FAANG #SoftwareEngineering #BackendDevelopment #ProgrammingTips

🚀 Hey folks! I’m back with a Java concept — let’s decode Singleton in the simplest way possible 😄 🤔 What is Bill Pugh Singleton? (pronounced like “Bill Pew” 😄) Many of you know the Singleton pattern, but did you know there are multiple ways to implement it? 👉 Let’s quickly list them: 1️⃣ Eager Initialization 2️⃣ Lazy Initialization 3️⃣ Synchronized Singleton 4️⃣ Double-Checked Locking 5️⃣ Bill Pugh Singleton (Best Practice ⭐) 6️⃣ Enum Singleton (Most Secure) 🧠 Why Bill Pugh Singleton? It was popularized by Java expert Bill Pugh as a clean + efficient solution. 👉 It uses: Static inner class JVM class loading No locks, no volatile 🔥 Key Benefits ✔ Lazy loading (created only when needed) ✔ Thread-safe ✔ No synchronized overhead ✔ High performance ✔ Clean & simple ⚙️ How It Works (Internally) Step 1: Class Load Singleton s = Singleton.getInstance(); 👉 Only outer class loads ❗ Inner class NOT loaded yet Step 2: Method Call return Holder.INSTANCE; 👉 Now JVM triggers inner class loading Step 3: Inner Class Loads private static class Holder 👉 Loaded ONLY when accessed (Lazy 🔥) Step 4: Object Creation private static final Singleton INSTANCE = new Singleton(); 👉 Created once, safely 🔒 Why It’s Thread-Safe? JVM guarantees during class loading: ✔ Only ONE thread initializes ✔ Other threads WAIT ✔ Fully initialized object is shared 👉 Comes from Java Memory Model (JMM) ⚠️ Important Concept: Partial Construction What you THINK happens: Allocate memory Initialize object Assign reference What CAN happen (Reordering ❌): Allocate memory Assign reference ⚠️ Initialize object 💥 Real Problem Thread-1: instance = new Singleton(); Thread-2: System.out.println(instance.value); 👉 Output: Expected: 42   Actual:  0 ❌ 🚨 Object is visible BEFORE full initialization 👉 This is Partial Construction 🛠️ How volatile Fixes It (in DCL) private static volatile Singleton instance; ✔ Prevents reordering ✔ Ensures visibility ✔ Guarantees fully initialized object 🔥 Why Bill Pugh Avoids This? private static class Holder {   private static final Singleton INSTANCE = new Singleton(); } 👉 JVM ensures: No reordering No partial construction Happens-before guarantee 🧵 Internal Flow Thread-1 → creates instance Thread-2 → waits Thread-3 → waits 👉 All get SAME object 🏢 Simple Analogy Main Office = Singleton Storage Room = Holder 🚪 Room stays locked 👉 Opens only when needed 👉 Item created once 👉 Everyone uses same item ⚠️ Limitations ❌ Reflection can break it ❌ Serialization can break it 👉 Use Enum Singleton to fix these 🏁 Final Takeaway 👉 Bill Pugh = Lazy + Thread Safe + No Locks 🚀 💬 If this helped you understand Singleton better, drop a 👍 #Java #Multithreading #DesignPatterns #InterviewPrep #BackendDevelopment