Java Custom Exception Handling in Java

🚀 Day 7/100 – Java Practice Challenge Continuing my #100DaysOfCode journey with another important Java concept. 🔹 Topic Covered: Exception Handling Exception handling helps to manage runtime errors and ensures the program runs smoothly without crashing. 💻 Practice Code: 🔸 Example Program public class Main { public static void main(String[] args) { int balance = 5000; try { int withdrawAmount = 6000; if (withdrawAmount > balance) { throw new Exception("Insufficient Balance!"); } balance -= withdrawAmount; System.out.println("Withdraw successful. Remaining balance: " + balance); } catch (Exception e) { System.out.println("Error: " + e.getMessage()); } finally { System.out.println("Transaction completed."); } } } 📌 Key Learnings: ✔️ Handles runtime errors effectively ✔️ Prevents application crashes ✔️ try-catch is used to handle exceptions ✔️ finally block always executes 🎯 Focus: Handles "what if something goes wrong" during program execution ⚡ Types of Exceptions: 👉 Checked Exceptions 👉 Unchecked Exceptions 🔥 Interview Insight: Exception handling is widely used in real-world applications (Banking, APIs, Microservices) to ensure reliability and stability. #Java #100DaysOfCode #ExceptionHandling #JavaDeveloper #Programming #LearningInPublic

💡 Decouple Your Tasks: Understanding the Java ExecutorService 🚀 Are you still manually managing new Thread() in your Java applications? It might be time to level up to the ExecutorService! I've been reviewing concurrency patterns recently and put together this quick overview of why this framework (part of java.util.concurrent) is crucial for building robust, scalable software. The core idea? Stop worrying about the threads and start focusing on the tasks. The ExecutorService decouples task submission from task execution. Instead of your main code managing thread lifecycles, you give the task (a Runnable or Callable) to the ExecutorService. It acts as a smart manager with a dedicated team (a thread pool) ready to handle the workload. Check out the diagram below to see how it works! 👇 Why should you use it? 1️⃣ Resource Management: Creating threads is expensive. Reusing existing threads in a pool saves overhead and prevents your application from exhausting system memory. 2️⃣ Controlled Concurrency: You control the number of threads. You can't overwhelm your CPU if you limit the pool size. 3️⃣ Cleaner Code: It separates the work (your tasks) from the mechanism that runs it (threading logic). Here is a quick example of a Fixed Thread Pool in action: Java // 1. Create a managed pool (3 threads) ExecutorService manager = Executors.newFixedThreadPool(3); // 2. Submit your work (it goes to the queue first) manager.submit(() -> { System.out.println("🚀 Processing data on: " + Thread.currentThread().getName()); }); // 3. Clean up (vital!) manager.shutdown(); Which type of Thread Pool do you find yourself using the most in your projects? (Fixed, Cached, or Scheduled?) Let's discuss in the comments! 👇 #Java #Programming #Concurrency #SoftwareEngineering #Backend #TechTips

📌 Optional in Java — Avoiding NullPointerException NullPointerException is one of the most common runtime issues in Java. Java 8 introduced Optional to handle null values more safely and explicitly. --- 1️⃣ What Is Optional? Optional is a container object that may or may not contain a value. Instead of returning null, we return Optional. Example: Optional<String> name = Optional.of("Mansi"); --- 2️⃣ Creating Optional • Optional.of(value)    → value must NOT be null  • Optional.ofNullable(value)    → value can be null  • Optional.empty()    → represents no value  --- 3️⃣ Common Methods 🔹 isPresent() Checks if value exists 🔹 get() Returns value (not recommended directly) --- 4️⃣ Better Alternatives 🔹 orElse() Returns default value String result =   optional.orElse("Default"); 🔹 orElseGet() Lazy default value 🔹 orElseThrow() Throws exception if empty --- 5️⃣ Transforming Values 🔹 map() Optional<String> name = Optional.of("java"); Optional<Integer> length =   name.map(String::length); --- 6️⃣ Why Use Optional? ✔ Avoids null checks everywhere   ✔ Makes code more readable   ✔ Forces handling of missing values   ✔ Reduces NullPointerException  --- 7️⃣ When NOT to Use Optional • As class fields   • In method parameters   • In serialization models  --- 🧠 Key Takeaway Optional makes null handling explicit and safer, but should be used wisely. It is not a replacement for every null. #Java #Java8 #Optional #CleanCode #BackendDevelopment

Building Native Image for a Java application requires configuration of reflection, proxies, and other dynamic Java mechanisms. But why is this necessary if the JVM handles all of this automatically? To answer that, we need to look at the differences between static and dynamic compilation in Java. https://lnkd.in/eVyGYHZk

🔥 Day 10 — Thread vs Runnable vs Callable in Java If you're working with concurrency in Java, you’ll constantly decide between Thread, Runnable, and Callable. Here’s a simple, practical breakdown 👇 1️⃣ Thread — The Oldest & Loudest Way Thread represents an actual execution thread. ✔ When to use - Only when you must override thread-specific behavior - Very rare in modern applications ✖ Why it's not preferred - You can’t return a result - You can’t throw checked exceptions Tight coupling: your task is also the thread Check below example: class MyThread extends Thread {   public void run() {     System.out.println("Running thread");   } } 2️⃣ Runnable — Lightweight Tasks (No Return Value) Runnable is the simplest abstraction for a task. ✔ When to use - You just need to run a piece of code - No result required For example : Runnable task = () -> System.out.println("Task running"); executor.submit(task); 3️⃣ Callable — Runnable with Superpowers ⚡ Callable<V> is Runnable’s upgraded version. ✔ Key advantages - Returns a value - Can throw checked exceptions - Works seamlessly with Future ✔ When to use - When your task computes a result - When you need exception handling For example: Callable<Integer> task = () -> 42; Future<Integer> result = executor.submit(task); 💡 Key Takeaway Stop creating your own Thread. - Use Runnable when you need simple execution, - Use Callable when you need a result or exception handling. #100DaysOfJavaArchitecture #Java #Concurrency #SoftwareArchitecture #Microservices

Learn how to use the super keyword in Java to access parent class fields, methods, and constructors for clear, maintainable code.

Learn how to use the super keyword in Java to access parent class fields, methods, and constructors for clear, maintainable code.

🚀 CyclicBarrier in Java — Small Concept, Powerful Synchronization In multithreading, coordination between threads is critical ⚡ 👉 CyclicBarrier allows multiple threads to wait for each other at a common point before continuing — ensuring everything stays in sync 🔥 💡 Think of it like a checkpoint 🏁 No thread moves forward until all have arrived! 🌍 Real-Time Example Imagine a report generation system 📊 Multiple threads fetch data from different APIs 📡 Each processes its own data ⚙️ Final report should generate only when all threads finish 👉 With CyclicBarrier, you ensure: ✅ All threads complete before aggregation ✅ No partial or inconsistent data ✅ Smooth parallel execution 💻 Quick Code Example import java.util.concurrent.CyclicBarrier; public class Demo { public static void main(String[] args) { CyclicBarrier barrier = new CyclicBarrier(3, () -> System.out.println("All threads reached. Generating final report...")); Runnable task = () -> { try { System.out.println(Thread.currentThread().getName() + " fetching data..."); Thread.sleep(1000); barrier.await(); System.out.println(Thread.currentThread().getName() + " done!"); } catch (Exception e) { e.printStackTrace(); } }; for (int i = 0; i < 3; i++) new Thread(task).start(); } } 💪 Why it’s powerful ✔️ Keeps threads perfectly synchronized ✔️ Prevents incomplete execution ❌ ✔️ Reusable for multiple phases ♻️ 🔥 Final Thought 👉 It’s a small but powerful feature — use it wisely based on your project needs to ensure the right level of synchronization without overcomplicating your design. #Java #Multithreading #Concurrency #BackendDevelopment #SoftwareEngineering

📌 TOPIC: Optional Class in Java (Java 8) The Optional class (from java.util) is used to avoid NullPointerException and handle missing values safely. 👉 Instead of using null, we use Optional to represent a value that may or may not be present. 🔸 Why use Optional? 1️⃣ Prevents NullPointerException 2️⃣ Makes code more readable 3️⃣ Forces proper handling of missing values 🔸 Creating Optional Objects import java.util.Optional; Optional<String> opt1 = Optional.of("Hello"); // value must not be null Optional<String> opt2 = Optional.ofNullable(null); // can be null Optional<String> opt3 = Optional.empty(); // empty Optional 🔸 Common Methods ✔️ isPresent() & get() Optional<String> name = Optional.of("Java"); if(name.isPresent()) { System.out.println(name.get()); } ✔️ orElse() Optional<String> name = Optional.ofNullable(null); System.out.println(name.orElse("Default Value")); 👉 Output: Default Value ✔️ ifPresent() Optional<String> name = Optional.of("Java"); name.ifPresent(n -> System.out.println(n)); Key Insight: Optional helps write cleaner and safer code by reducing direct null checks and preventing runtime errors. #Java #Optional #Java8 #Programming #Codegnan #LearningJourney #Developers My gratitude towards my mentor #AnandKumarBuddarapu #SakethKallepu #UppugundlaSairam

📌 Exception Handling in Java — Understanding Exception Propagation The diagram represents how Java manages exceptions using the call stack and identifies the appropriate handler. 🔹 Execution Flow: • An exception is thrown in "divideByZero()" • The method does not handle it → exception is propagated • "computeDivision()" receives the exception but does not handle it • The exception continues to propagate up the call stack • "main()" contains the appropriate "catch" block and handles the exception 🔹 Internal Mechanism: The JVM performs stack unwinding, examining each method in the call stack sequentially to locate a matching exception handler. If no handler is found, the program terminates and a stack trace is generated. 🔹 Key Takeaways: • Exception propagation ensures centralized and structured error handling • Not every method should handle exceptions — only where recovery is possible • Proper handling improves system stability and maintainability 🔹 Best Practices: ✔ Catch specific exceptions instead of generic ones ✔ Avoid unnecessary try-catch blocks ✔ Use meaningful logging for debugging and monitoring ✔ Rethrow exceptions with additional context when needed ✔ Design applications with clear error-handling strategies 🔹 Conclusion: Effective exception handling is not just a language feature — it is a critical part of designing robust and maintainable systems. #Java #ExceptionHandling #SoftwareEngineering #BackendDevelopment #CleanCode