Thanasis Kirmizis’ Post

Most Java devs know you can't use multiple inheritance. But do you know all the types you CAN'T extend — even without the final keyword? 🤔 The rule is simple: a class can only extend ONE parent. But Java has several types that block inheritance through different mechanisms — not always with final. Here's the full picture: → final class: The obvious one. Compiler blocks extension directly. → enum: Implicitly extends java.lang.Enum. Since Java doesn't allow multiple inheritance, no room for your class. → record (Java 16+): Implicitly final. Compiler rejects any attempt to extend it. → Arrays (int[], String[], etc.): They extend Object — confirmed by the Java Language Specification. But the JVM creates them at runtime, not as regular classes. You cannot extend them. Period. → Private constructor: No final needed. Since every child class must call super(), a private constructor silently kills inheritance. ```java class Singleton {   private Singleton() { } // blocks extension AND multiple instances   public static Singleton getInstance() { ... } } class Child extends Singleton { } // ❌ Won't compile ``` This is why the Singleton pattern gets a free "sealed" behavior — not by design choice, but as a side effect of the private constructor. The key insight: final is just ONE of the ways Java prevents inheritance. The language has multiple mechanisms, some explicit, some implicit, some enforced by the JVM itself. Understanding WHY something can't be extended makes you a better architect — not just a better coder. 🎯 📊 Java Language Specification - Arrays (JLS §10): https://lnkd.in/eSyKYpip 📊 Java Language Specification - Types and Values (JLS §4): https://lnkd.in/e5EGb-ps 📊 Java Arrays and Inheritance — Medium (Santiago Barbieri, 2024): https://lnkd.in/e9vziKWt #Java #SoftwareEngineering #BackendDevelopment #ObjectOrientedProgramming #CleanCode #JavaDeveloper #TechLeadership #Microservices

Day - 28 : Set in Java In Java, the Set interface is a part of the Java Collection Framework, located in the java.util package. It represents a collection of unique elements, meaning it does not allow duplicate values. 1) The set interface does not allow duplicate elements. 2) It can contain at most one null value except TreeSet implementation which does not allow null. 3)The set interface provides efficient search, insertion, and deletion operations. ● Example : import java.util.HashSet; import java.util.Set; public class java { public static void main(String args[]) { Set<String> s = new HashSet<>( ); System.out.println("Set Elements: " + s); } } ● Classes that implement the Set interface a) HashSet: A set that stores unique elements without any specific order, using a hash table and allows one null element. b) EnumSet : A high-performance set designed specifically for enum types, where all elements must belong to the same enum. c) LinkedHashSet: A set that maintains the order of insertion while storing unique elements. d) TreeSet: A set that stores unique elements in sorted order, either by natural ordering or a specified comparator. #Java #JavaProgramming #TreeMap #JavaDeveloper #Programming #Coding #SoftwareDevelopment #LearnJava #JavaLearning #BackendDevelopment EchoBrains

🚀 Java Series – Day 15 📌 Exception Handling in Java (try-catch-finally & Checked vs Unchecked) 🔹 What is it? Exception Handling in Java is used to handle runtime errors so that the program can continue executing smoothly. Java provides keywords to handle exceptions: • try – Code that may cause an exception • catch – Handles the exception • finally – Always executes (used for cleanup) 🔹 Why do we use it? Exception handling helps prevent program crashes and ensures better user experience. For example: In a file upload system, if a file is not found or an error occurs, instead of crashing, the program can show a proper error message and continue execution. Also, Java classifies exceptions into: • Checked Exceptions – Checked at compile time (e.g., IOException) • Unchecked Exceptions – Occur at runtime (e.g., NullPointerException, ArithmeticException) 🔹 Example: public class Main { public static void main(String[] args) { try { int result = 10 / 0; // Exception } catch (ArithmeticException e) { System.out.println("Cannot divide by zero"); } finally { System.out.println("Execution completed"); } } } 💡 Key Takeaway: Exception handling ensures robust and crash-free applications by managing errors effectively. What do you think about this? 👇 #Java #ExceptionHandling #JavaDeveloper #Programming #BackendDevelopment

🚀Heap vs Stack Memory in Java Understanding memory is very important for every Java developer. Let’s break it down clearly 👇 🔹 Stack Memory ✔ Stores method calls (stack frames) ✔ Stores local variables ✔ Stores references to objects (not the actual object) ✔ Each thread has its own stack ✔ Memory is allocated and removed automatically when method finishes ✔ Very fast access ❌ Error: StackOverflowError (Mainly due to deep or infinite recursion) 🔹 Heap Memory ✔ Stores objects and instance variables ✔ Shared among all threads ✔ Objects remain until no reference exists ✔ Managed by the Garbage Collector ✔ Slower than stack (but larger in size) ❌ Error: OutOfMemoryError (When JVM cannot allocate more heap space)

✅ Java Features – Step 21: Pattern Matching for instanceof (Java 17) ⚡ Before Java 17, using instanceof required an extra cast. Example (old style): if (obj instanceof String) { String s = (String) obj; System.out.println(s.length()); } Java 17 simplifies this with pattern matching. if (obj instanceof String s) { System.out.println(s.length()); } Now the variable s is automatically created after the type check. Why this matters Less boilerplate code Safer type checking Improved readability Fewer casting mistakes Example Object value = "Java"; if (value instanceof String str) { System.out.println(str.toUpperCase()); } Key takeaway Pattern matching reduces repetitive casting and makes type-checking logic cleaner. This is part of Java’s effort to modernize the language. Next up: Recap – Key Features from Java 8 → Java 17 🚀

📄 On paper this looks like a small syntax tweak, ✨ but in real projects it feels like a relief. 🔧 DTO mapping, 📝 logging, or ⚙️ handling different event types in a backend system — we used to write instanceof checks followed by repetitive casts everywhere. ❌ It wasn’t just ugly, it was error‑prone. ✅ Now the flow is natural: if (event instanceof PaymentEvent pe) { auditLogger.log(pe.getTransactionId()); } 💡 This isn’t just saving a line of code. 👉 It’s about intent. 👥 When a teammate reads this, they immediately see what’s happening without being distracted by boilerplate. 🚀 In practice, these “small” changes: 🔓 reduce friction 👶 make onboarding easier for juniors 🎯 help teams focus on business logic instead of ceremony 📌 My takeaway: Code is not only for machines to run, but for humans to read, share, and maintain. Readability = productivity. This way your repost feels more personal, visually appealing, and relatable to everyday coding practice.

🚀 Understanding Multithreading in Java Multithreading is one of the most powerful features in Java that allows a program to perform multiple tasks simultaneously. It improves application performance and better utilizes CPU resources. 🔹 What is Multithreading? Multithreading is a process of executing multiple threads (smallest units of a process) concurrently within a single program. Example: A web application can handle multiple user requests at the same time using threads. 🔹 Why Multithreading is Important? ✔ Improves application performance ✔ Better CPU utilization ✔ Enables parallel processing ✔ Allows responsive applications (UI not freezing) 🔹 Ways to Create Threads in Java 1️⃣ Extending the Thread class class MyThread extends Thread { public void run() { System.out.println("Thread is running..."); } } 2️⃣ Implementing the Runnable interface class MyRunnable implements Runnable { public void run() { System.out.println("Thread is running..."); } } 🔹 Key Concepts in Multithreading • Thread Lifecycle • Synchronization • Deadlock • Thread Pool • Executor Framework 🔹 Simple Example class TestThread { public static void main(String[] args) { Runnable r = () -> System.out.println("Thread executed"); Thread t1 = new Thread(r); Thread t2 = new Thread(r); t1.start(); t2.start(); } } 💡 Takeaway: Multithreading helps build scalable and high-performance applications. Understanding synchronization and thread management is essential for backend developers. #Java #Multithreading #JavaDeveloper #BackendDevelopment #Programming #SoftwareDevelopment

Explore the different memory locations in Java: understand how the stack, heap, method area, and more are used to store data and variables.

🚀Java Tip Java Tip: Use Optional to avoid NullPointerException One of the most common issues developers face in Java applications is the NullPointerException. Java 8 introduced the Optional class to help handle null values more safely and clearly. Instead of directly working with possible null values, Optional provides a container that may or may not contain a value. 🔹 Example without Optional User user = getUser(); String name = user.getName(); // May throw NullPointerException 🔹 Example using Optional Optional<User> user = getUser(); String name = user.map(User::getName).orElse("Default User"); 💡 Benefits of using Optional: Reduces chances of NullPointerException Makes code more readable and expressive Encourages better null handling practices Using Optional in modern Java applications helps developers write safer and more maintainable code. #Java #JavaTips #SoftwareDevelopment #JavaDeveloper #Programming

Java Exception Handling: One concept every Java developer must master Many beginners know Java syntax but still struggle when programs crash. That's where exception handling matters. In Java, exception handling allows you to catch runtime errors and keep the application running. Instead of failing suddenly, your code can detect problems, handle them, and continue safely. What I covered in this carousel: • What exceptions are and why they happen • try and catch explained with clear examples • The finally block and cleaning up resources • throw vs throws: When to use each • Checked vs unchecked exceptions • The Java exception hierarchy • Nested try-catch and handling multiple exceptions • How the JVM handles exceptions: Call stack basics Exception handling is not just about avoiding crashes; it's about writing production-ready code that survives real life. Good developers don't ignore errors; they build systems that handle them gracefully. I added a carousel with step-by-step explanations and code examples. Learning Java or prepping for interviews #Java #JavaProgramming #BackendDevelopment #Programming #SoftwareDevelopment