Java Sealed Classes vs Final Classes for Controlled Polymorphism

💡 𝗝𝗮𝘃𝗮/𝐒𝐩𝐫𝐢𝐧𝐠 𝐁𝐨𝐨𝐭 𝗧𝗶𝗽 - 𝗦𝘄𝗶𝘁𝗰𝗵 𝗘𝘅𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻 💎 🕯 𝗧𝗿𝗮𝗱𝗶𝘁𝗶𝗼𝗻𝗮𝗹 𝗦𝘄𝗶𝘁𝗰𝗵 𝗦𝘁𝗮𝘁𝗲𝗺𝗲𝗻𝘁 The traditional switch statement has been part of Java since the beginning. It requires explicit break statements to prevent fall-through, which can lead to bugs if forgotten. Each case must contain statements that execute sequentially, making the code verbose and error-prone. 💡 𝗠𝗼𝗱𝗲𝗿𝗻 𝗦𝘄𝗶𝘁𝗰𝗵 𝗘𝘅𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻 Switch expressions were introduced in Java 14 as a more concise and safe alternative. Using the -> syntax, you eliminate the need for break statements and can directly return values. Multiple cases can be grouped with commas, and the compiler enforces exhaustiveness for better safety. ✅ 𝗞𝗲𝘆 𝗕𝗲𝗻𝗲𝗳𝗶𝘁𝘀 ◾ No break statements, safer and cleaner code. ◾ Direct value assignment, treat switch as an expression. ◾ Multiple labels with comma separation. ◾ Compiler exhaustiveness checks, fewer runtime errors. 🤔 Which one do you prefer? #java #springboot #programming #softwareengineering #softwaredevelopment

🚫Deprecation ⚠️ “This feature is outdated. Don’t use it anymore. It may be removed in future.”, So Java is basically warning developers. ✅ What finalize() does (simple) finalize() is like a last warning callback: Before an object is about to be destroyed by Garbage Collector, JVM may call finalize() once so you can do last cleanup (like closing a file or DB connection). ❌ Why people avoid it today? Because it is not guaranteed: JVM may call it late or may not call it at all and it makes GC slower ✅ Today we use: try-with-resources 🔖Frontlines EduTech (FLM) #Java #Finalize #GarbageCollector #JVM #MemoryManagement #Deprecated #BackwardCompatibility #TryWithResources #AutoCloseable #Cleaner #BestPractices #JavaDevelopment

Ever wondered what happens behind the scenes when you hit "Run" in Java? 🤔 Let’s break down how the JVM actually executes your code: 1️⃣ Compile – Your .java source code is compiled into bytecode (.class files) by the Java compiler. 2️⃣ Class Load – The JVM loads these classes into memory using the ClassLoader subsystem. 3️⃣ Bytecode Verify – Bytecode is checked for security and correctness. 4️⃣ Interpreter + JIT – The interpreter runs the bytecode line by line. Frequently used code gets compiled into native machine code by the JIT (Just-In-Time) compiler for faster execution. 5️⃣ Execute – The native code runs on the underlying hardware. 🎯 Result? Platform independence + high performance. Q1: Why does Java need both an interpreter and a JIT compiler? A: The interpreter starts execution quickly without waiting for compilation. The JIT compiler optimizes hot paths at runtime, giving the best of both startup speed and long-term performance. Q2: Is bytecode really platform-independent? A: Yes! Bytecode runs on any device with a JVM, which acts as an abstraction layer. The JVM itself is platform-specific, but your code doesn't have to be. Q3: What happens if bytecode fails verification? A: The JVM throws a VerifyError and won't execute the code. This prevents malicious or corrupt code from harming the system. #Java #JVM #Programming #SoftwareEngineering #TechExplained

🚀 Minimum Absolute Difference (Optimized Java Approach) Today I revisited a classic array problem and implemented a clean, optimized solution using sorting and a two-pass strategy. Leetcode Problem link:https://lnkd.in/gWtQD_FX 💡 Key idea: Sort the array first Adjacent elements now give the minimum possible differences Use: Pass 1 → find the minimum absolute difference Pass 2 → collect all pairs with that difference ✅ Why this approach? Easy to reason about Avoids unnecessary condition checks Optimal time complexity ⏱️ Complexity: Time: O(n log n) (sorting dominates) Space: O(1) extra (excluding output) #Java #DataStructures #Algorithms #LeetCode #ProblemSolving #CleanCode #LinkedList #Sorting #OptimizedCode

💡 Enums were too limited, inheritance was too open. So, Sealed Classes fixed both. 🔒 What are Sealed Classes? Sealed classes let you restrict which classes can extend or implement a class/interface. Instead of anyone extending your class, you explicitly allow only specific subclasses. ✅ Why this matters? • Better domain modeling (especially in DDD) • Exhaustive pattern matching (no missing cases in switch) • More secure APIs (no unintended subclassing) • Cleaner architecture boundaries 🧠 Example: public sealed class Payment permits UpiPayment, CardPayment {} public final class UpiPayment extends Payment {} public final class CardPayment extends Payment {} ————————————————————————— No random developer can extend Payment. Java compiler enforces your design rules. 💡 Think of Sealed Classes as: Enums + Inheritance + Compile-time safety Java is evolving fast, Sealed Classes are a big step towards safer and more expressive APIs. Are you using Sealed Classes in production yet? 👇 #Java #Java17 #SealedClasses #BackendDevelopment #Microservices #SystemDesign #Programming

📘 Day 3: Understanding Compiler, JVM & Java Execution – In Detail Today I connected the full Java execution flow, not just definitions — from source code to output. 🔹 Role of Compiler (javac) The compiler checks: ✔ Syntax correctness ✔ Class, method, interface declarations ✔ Data types & variables ✔ Converts .java → bytecode (.class) ✔ Ignores comments 🔹 What happens during Execution? 1️⃣ Bytecode is loaded into JVM 2️⃣ Class Loader loads classes 3️⃣ Memory Allocation happens Method Area → class & static info Heap → objects & arrays Stack → local variables & method calls PC Register → current instruction Native Method Area 4️⃣ Execution Engine runs the code Interpreter executes line by line JIT Compiler optimizes repeated code 5️⃣ Output is produced 🎯 🔹 What is JVM? JVM is an Application / Process-based Virtual Machine that executes Java bytecode and makes Java platform-independent. 🔹 JDK vs JRE (Crystal Clear) ✅ JDK = JRE + Development Tools (javac, java, javadoc, javap) ✅ JRE = JVM + Java Libraries + Runtime support ❌ JRE does NOT contain compiler 🔹 Why JIT Compiler is Important? It converts frequently used bytecode into native machine code → faster execution ⚡ This session helped me understand why Java is secure, portable, and efficient, not just memorize terms. Consistent learning > Rote learning. Day 3 completed 🚀 #Java #Compiler #JVM #JDK #JRE #CoreJava #MCA #LearningJourney #ComputerScience #InterviewPrep

Java Jump Scares Series #4 When clean code lies - Autoboxing Consider the following code snippet: ```java static void run(Long x) { System.out.println("Long"); } static void run(Integer x) { System.out.println("Integer"); } run(10); ``` We would expect the Integer version to be invoked — after all, 10 fits naturally into an Integer, but Java prints Long! Why does this happen? Method overloading in Java is resolved entirely at compile time and follows a strict conversion hierarchy defined by the Java Language Specification: - int → Integer → autoboxing - int → long → Long → primitive widening + boxing Primitive widening is preferred over autoboxing. The compiler didn’t guess wrong — it just understood Java better than we did. ☕👻 #JavaDeveloper #BackendEngineer #SoftwareEngineer #JavaProgramming #JVM #APIDesign #CodeQuality #ProgrammingPitfalls

🚀 Container With Most Water | Java | Two Pointer Approach I solved the “Container With Most Water” problem using an optimized Two Pointer technique in Java. The goal is to find two lines that together with the x-axis form a container, such that the container holds the maximum amount of water. 🧠 Approach: Start with two pointers at both ends of the array. Calculate the width between them. The height is determined by the smaller of the two values. Update the maximum area. Move the pointer pointing to the smaller height inward. This greedy strategy works because the area depends on both width and minimum height, and moving the smaller height gives a chance to find a larger area. ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) Practicing DSA problems daily to improve logical thinking and optimization skills. #Java #DSA #TwoPointer #ProblemSolving #CodingJourney #LeetCode #DataStructures

Day31 - LeetCode Journey Solved LeetCode 392: Is Subsequence in Java ✅ This was a clean and intuitive problem focused on understanding relative order in strings. The goal was simple: check whether one string appears as a subsequence of another without disturbing character order. I used the classic two-pointer approach. One pointer moves through the smaller string, the other through the larger one. Whenever characters match, we move ahead. If we can fully traverse the smaller string, it’s a valid subsequence. What I liked about this problem is how it reinforces the idea that not every problem needs extra space or complex logic. Sometimes, careful traversal is all you need. Key takeaways: • Strengthened understanding of two-pointer technique • Improved handling of ordered string traversal • Focused on writing minimal and efficient logic • Reinforced thinking around constraints and edge cases ✅ All test cases passed ✅ Another solid string problem added to the list Consistency over intensity. One problem at a time 💪 #LeetCode #Java #DSA #Strings #TwoPointers #ProblemSolving #Algorithms #CodingJourney #InterviewPreparation #DailyPractice

Building a high-performance database in Java is impossible! That's the title of a talk I'm giving on Tuesday in Prague. Join me at CZ JUG to see how QuestDB ingests millions of rows/sec using "unorthodox" Java. I’m taking you into the sausage factory: 1. Zero-GC Java 2. SIMD: Vectorization and our own JIT compiler. 3. Raw Speed: Mechanical sympathy over abstractions. I’ll also answer the #1 question: Why the heck didn't you just use C̶+̶+̶ Rust? See you there! (link in comments)