Markus Eisele’s Post

🚀 𝐉𝐚𝐯𝐚 𝐓𝐞𝐜𝐡 𝐃𝐫𝐨𝐩: 𝐟𝐢𝐧𝐚𝐥 𝐯𝐬 𝐬𝐞𝐚𝐥𝐞𝐝 𝐜𝐥𝐚𝐬𝐬𝐞𝐬 In Java, we’ve used final classes for years to lock down behavior. They’re great when extension would break invariants or introduce bugs. But sealed classes change the game. 𝐟𝐢𝐧𝐚𝐥 answers: 👉 “This class must NOT be extended.” 𝐬𝐞𝐚𝐥𝐞𝐝 answers: 👉 “This class CAN be extended — but only in ways I explicitly allow.” Why this matters in real systems: - You get controlled polymorphism - The compiler knows all valid subtypes - Exhaustive switch becomes safer and cleaner - Your domain model becomes explicit, not implicit 𝐟𝐢𝐧𝐚𝐥 is about restriction. 𝐬𝐞𝐚𝐥𝐞𝐝 is about designing boundaries. If you’re modeling domains, workflows, or state machines, 𝐬𝐞𝐚𝐥𝐞𝐝 classes often express intent better than 𝐟𝐢𝐧𝐚𝐥 ever could. With 𝐬𝐞𝐚𝐥𝐞𝐝, the compiler knows all possible implementations. That means safer refactors, exhaustive switch, and clearer domain boundaries. ☕ Modern Java isn’t about more features — it’s about better constraints. #Java #SoftwareEngineering #CleanCode #DomainModel #Backend #Spring #Kotlin #JVM

Ready to take a trip down memory lane—and build something cool in the process? This tutorial walks you through how to recreate the classic Snake game in Java, complete with logic, rendering, and controls. Sample code included. #Java #GameDev #CodingProjects #ProgrammingBasics #RheinwerkComputingBlog Read here: https://hubs.la/Q03-ngrv0

🚫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

𝗟𝗟𝗗 𝗦𝗲𝗿𝗶𝗲𝘀 - 𝗣𝗼𝘀𝘁 𝟬𝟲 Your code works. Until one dependency changes and everything breaks. That’s tight coupling. 𝗗𝗲𝗽𝗲𝗻𝗱𝗲𝗻𝗰𝘆 𝗜𝗻𝘃𝗲𝗿𝘀𝗶𝗼𝗻 𝗣𝗿𝗶𝗻𝗰𝗶𝗽𝗹𝗲 (𝗗𝗜𝗣) 𝘀𝗮𝘆𝘀: 👉 Depend on 𝗮𝗯𝘀𝘁𝗿𝗮𝗰𝘁𝗶𝗼𝗻𝘀, not concrete implementations. When high-level logic depends on details, change becomes expensive. DIP flips that dependency - and systems become flexible, testable, and scalable. 📘 Full article on Medium (link in comments) #SOLID #DIP #LowLevelDesign #Java #SoftwareDesign #CleanCode

Why does Java still make “simple things” verbose—by design? Michel Charpentier’s wishlist reads like a tour of modern language ergonomics: tuples, named args, local functions, type aliases, variance. Steal the patterns: https://lnkd.in/dyu2agtD #OpenJDK #JVM #Java #ProgrammingLanguages Kotlin Multiplatform Updates and Showcases Scala Developer

Understanding `Optional` the Right Way 🚀 > “NullPointerException: the most thrown (and hated) exception in Java history.” Let’s talk about how `Optional` helps us write safer, cleaner code — when used properly👇 ✅ Why `Optional` exists: - It represents a value that might be absent — no more random `null` checks. - Encourages clear, intentional handling using methods like `isPresent()` and `orElse()`. ✅ Pro tips for clean usage: - Use `Optional` in return types — not in entity fields or constructor parameters. - Chain with `map()` and `filter()` for elegant transformations. - Avoid misusing it inside DTOs or collections (it adds unnecessary complexity). 🤔 How do you prefer handling optional values — traditional null checks or functional style? #Java #SpringBoot #ReactJS #FullStack #Coding

💡 𝗝𝗮𝘃𝗮/𝐒𝐩𝐫𝐢𝐧𝐠 𝐁𝐨𝐨𝐭 𝗧𝗶𝗽 - 𝗦𝘄𝗶𝘁𝗰𝗵 𝗘𝘅𝗽𝗿𝗲𝘀𝘀𝗶𝗼𝗻 💎 🕯 𝗧𝗿𝗮𝗱𝗶𝘁𝗶𝗼𝗻𝗮𝗹 𝗦𝘄𝗶𝘁𝗰𝗵 𝗦𝘁𝗮𝘁𝗲𝗺𝗲𝗻𝘁 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

📝 Day 12/30 – LeetCode #344 (Reverse String) | Java Although reversing a string seems simple, the constraint here is to do it in-place without using extra memory. Using built-in functions would defeat the purpose of the problem. By applying a two-pointer approach, I swapped characters from both ends of the array until they met in the middle. This resulted in a clean O(n) solution with O(1) space. This problem reinforced how even simple tasks can test understanding of constraints and memory efficiency. #LeetCode #Java #DSA #TwoPointers #Strings #Consistency #LearningInPublic

Do you know about the yield keyword in Java's switch expressions? When using switch expressions, if you need to return a value after executing multiple lines of logic, you need to use "yield" keyword to specify the value to return. It works like a smarter, more precise return for switch expressions. The name yield was chosen because it fits the concept of “producing a value” while avoiding conflicts with existing Java keywords! #yield #java #coding

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