Java Functional Interface: Runnable Example

💡 𝗝𝗮𝘃𝗮 𝗖𝗮𝘀𝘁𝗶𝗻𝗴: 𝗖𝗼𝗺𝗽𝗶𝗹𝗲-𝗧𝗶𝗺𝗲 𝘃𝘀 𝗥𝘂𝗻𝘁𝗶𝗺𝗲 𝗘𝘅𝗰𝗲𝗽𝘁𝗶𝗼𝗻𝘀 — 𝗘𝘅𝗽𝗹𝗮𝗶𝗻𝗲𝗱 𝗟𝗼𝗴𝗶𝗰𝗮𝗹𝗹𝘆 Many developers wonder why an invalid cast sometimes results in a ClassCastException at runtime, even when it looks obvious at compile time. The key reason: 👉 The 𝗰𝗼𝗺𝗽𝗶𝗹𝗲𝗿 𝗼𝗻𝗹𝘆 𝗸𝗻𝗼𝘄𝘀 𝘁𝗵𝗲 𝗿𝗲𝗳𝗲𝗿𝗲𝗻𝗰𝗲 𝘁𝘆𝗽𝗲, not the 𝗮𝗰𝘁𝘂𝗮𝗹 𝗼𝗯𝗷𝗲𝗰𝘁 𝘁𝘆𝗽𝗲 at compile time. Because of polymorphism, the compiler must assume that a subclass might exist that makes the cast valid—and therefore defers the decision to runtime. However, when you add stronger guarantees like final (or sealed classes), the compiler gains 𝗰𝗼𝗺𝗽𝗹𝗲𝘁𝗲 𝗰𝗲𝗿𝘁𝗮𝗶𝗻𝘁𝘆 and can reject the cast at 𝗰𝗼𝗺𝗽𝗶𝗹𝗲 𝘁𝗶𝗺𝗲. 📌 Takeaway: Java’s compiler is not dumb—it’s cautious. Give it enough information, and it becomes very smart. Understanding why this happens is far more powerful than memorizing rules. Check: https://lnkd.in/g88yhKev #Java #OOP #SoftwareEngineering #JavaConcepts #ClassCastException #LearningByUnderstanding

Abstract Class vs Interface in Java – Quick Tip Abstract Class: Can have methods with or without code. Supports shared behavior. A class can extend only one. Interface: Usually methods without code. Defines a contract. A class can implement multiple. Remember: Abstract → “is-a” Interface → “can-do” Mastering this helps you write clean, reusable, and maintainable code! 💻 #Java #OOP #SOLID #BackendDevelopment #ProgrammingTips

Missed posting yesterday. Used the time to revise Java fundamentals. Revision in Java isn’t about rereading syntax. It’s about rediscovering why things work the way they do. Yesterday’s revision focused on: • How memory is managed inside the JVM • Why equals() matters beyond comparisons • How exceptions propagate through method calls • The real difference between == and .equals() These topics feel small — until they cause real bugs. Frameworks change. APIs evolve. But Java fundamentals stay relevant. Revising basics is not going backward. It’s upgrading how you think. Back today. Building on stronger foundations. #Java #CoreJava #JVM #BackendDevelopment #SoftwareEngineering #LearningInPublic #BuildInPublic

A stream in java is a sequence of objects, its just a way to get data out of a collection. Collection interface in java has the stream method so all collections support stream. Arrays dont have a stream method we can make a stream out of an array by using Arrays util class's stream static method. Stream is used to process data from a collection in a declarative way much like we do chaining of array methods in JS/TS. We can have finite or infinite streams. #Java #Backend #SoftwareEngineering

Hi everyone 👋 Today let’s understand one of the most asked Java multithreading keywords 👇 📌 Java Keyword Series – volatile The volatile keyword is used in multithreading to ensure visibility of changes across threads. 🔹 Why do we need volatile? In multithreading, each thread may have its own local cache (working memory). If one thread updates a variable, other threads might not immediately see the updated value. 👉 volatile ensures that: The variable is always read from main memory Changes made by one thread are immediately visible to other threads 🔹 What volatile guarantees ✅ Visibility ❌ Not Atomicity Important: volatile int count = 0; count++; This is NOT thread-safe ❌ Because count++ is not atomic. 🔹 In Simple Words volatile ensures that all threads always see the latest value of a variable. #Java #Multithreading #VolatileKeyword #CoreJava #InterviewPreparation #BackendDevelopment

Excellent article by Jonas Norlinder with a deep dive on the existing garbage collectors, and insight on improvements coming in Java 26. https://lnkd.in/dpyr82Jy #Java #Spring #SpringBoot #Kotlin #GarbageCollector

Clean and efficient Java code matters. Here’s how Collectors.summingDouble helps you compute total salary using Streams with ease. Link to Video: https://lnkd.in/giFt8G_2

🔥 DAY 17 – Cleaner Java with Streams Java Streams make collection handling elegant. Example: List<String> names = users.stream() .map(User::getName) .collect(Collectors.toList()); Why use Streams? ✔ Less boilerplate ✔ Functional style ✔ Cleaner logic But don’t overuse it for complex logic. Readable > Fancy. #Java #CleanCode

"Architecting Knowledge" - Java Wisdom Series Post #7: CompletableFuture - Don't Block Your Future 👇 You're using `CompletableFuture`, but still blocking. Here's the problem. Why This Matters: Calling `.get()` or `.join()` on a `CompletableFuture` defeats its entire purpose. You're forcing the calling thread to wait, turning async code back into synchronous blocking code. The power of CompletableFuture is in chaining operations with `thenApply`, `thenCompose`, `thenCombine` - letting the framework handle threading. Key Takeaway: Return `CompletableFuture` from your methods. Let the caller decide when to block. Your job is to build the async pipeline, not collapse it. #Java #JavaWisdom #CompletableFuture #AsyncProgramming #Concurrency #Performance Ever caught yourself calling .get() and wondered why async was slow? Share your async journey! All code examples on GitHub - bookmark for quick reference: https://lnkd.in/dJUx3Rd3