Unlocking Java Generics for Type Safety and Structure

It’s easy to forget how much chaos Java had before generics… until you look at code that still relies on raw types. Once you see how type parameters actually shape safety and structure in collections, it becomes obvious why this feature changed everything. If you want a clean walkthrough of the fundamentals that many devs gloss over, this article lays it out clearly. https://bit.ly/4rlvIbG

I’ve written a simple blog breaking down the real difference between blocking, parking, and virtual threads in Java — and explaining what exactly gets paused (OS thread vs continuation) when your code “waits.” https://lnkd.in/g5DxUNMW

Interfaces also allow a class to follow multiple contracts at the same time. Unlike classes, where a class can extend only one parent class, a class in Java can implement multiple interfaces. Things that became clear : • a class can implement more than one interface • each interface can define a different set of behaviours • the implementing class must provide implementations for all the methods • this approach allows combining different capabilities in a single class • it helps achieve flexibility while avoiding multiple inheritance of classes A simple example shows how multiple interfaces can be implemented : interface ICalculator { void add(int a, int b); void sub(int a, int b); } interface IAdvancedCalculator { void mul(int a, int b); void div(int a, int b); } class CalculatorImpl implements ICalculator, IAdvancedCalculator { public void add(int a, int b) { System.out.println(a + b); } public void sub(int a, int b) { System.out.println(a - b); } public void mul(int a, int b) { System.out.println(a * b); } public void div(int a, int b) { System.out.println(a / b); } } This structure allows the class to support operations defined by multiple interfaces while keeping responsibilities organized. #java #oop #programming #learning #dsajourney

Solved LeetCode 78 – Subsets using Backtracking | Java Today I solved the classic Subsets problem, which focuses on generating all possible subsets (power set) of a given array. 1) Problem: Given an integer array nums with unique elements, return all possible subsets. 2) Key Insight: For every element, we have two choices: • Include the element • Exclude the element This creates a decision tree and results in 2ⁿ subsets. 3) Approach Used: I used Recursion + Backtracking Steps: Start from index 0 Add current subset to result (use copy) Include element → recurse Remove element (backtrack) Exclude element → recurse

✅ Java Features – Step 14: var (Java 10) ☕ Java 10 introduced var for local variable type inference. Instead of writing: Map<String, List<String>> userRoles = new HashMap<>(); You can write: var userRoles = new HashMap<String, List<String>>(); The compiler automatically infers the type. Important Rules: var works only for local variables Type is decided at compile time It does NOT make Java dynamically typed Good Use Case: var names = List.of("Mariya", "Anu", "Raj"); Cleaner and more readable. When NOT to Use: var data = process(); If the type is not obvious, it hurts readability. Key Insight var reduces verbosity, but clarity should always come first. Next up: Java 11 – New String Methods 🚀

Another way abstraction is implemented in Java is through interfaces. Interfaces define a set of methods that a class must implement, but they do not provide the actual implementation. Things that became clear : • an interface represents complete abstraction • methods declared inside an interface are implicitly public and abstract • a class uses the implements keyword to follow the rules defined by an interface • the implementing class must provide the body for all the methods • interfaces help create loose coupling between components A simple example shows the idea: interface ICalculator { void add(int a, int b); void sub(int a, int b); } class CalculatorImpl implements ICalculator { public void add(int a, int b) { System.out.println(a + b); } public void sub(int a, int b) { System.out.println(a - b); } } In this structure the interface defines what operations should exist, while the implementing class decides how those operations work. This approach makes it easier to design flexible and maintainable systems. #java #oop #programming #learning #dsajourney

In Part 4 of Magnus Smith’s Functional Optics for Modern Java series, he explores traversals and pattern rewrites. Learn how the Focus DSL’s TraversalPath makes navigating and composing collections in Java more readable, fluent, and powerful. 🔗 Read more: https://buff.ly/DszWTCN #Java #FunctionalProgramming #DSL #SoftwareEngineering #CodeOptimisation #TechInsights

🚀 Day 78 of- #100DaysOfCode Today’s problem: Check if the Sentence Is Pangram A pangram is a sentence that contains every letter of the English alphabet at least once. 🔹 Approach I Used: Loop from 'a' to 'z' Check if each character exists in the given string If any character is missing → return false If all characters are present → return true 💻 Java Solution: 🧠 Time Complexity: O(26 * n) → Since we check 26 letters and contains() takes O(n) Simplified: O(n) 📌 Space Complexity: O(1) (No extra data structure used) 💡 What I Learned: Sometimes simple brute-force solutions are clean and efficient enough. Always analyze time complexity even for small loops like 26 characters.

Understanding the final Keyword in Java In Java, the final keyword is used to restrict modification. Once something is declared as final, it cannot be changed in the future. 🔹 Final Variable A variable declared as final becomes a constant. Its value cannot be modified after initialization. 🔹 Final Method A method declared as final cannot be overridden by subclasses. 🔹 Final Class A class declared as final cannot be extended (inherited by another class). 💡 The final keyword helps improve security, immutability, and code reliability in Java applications. #Java #Programming #JavaDeveloper #Coding #OOP #LearningJava #ComputerScience

Day 1 – Pattern Problem (Right Angle Star Pattern) ⭐ Today I practiced a basic pattern problem using Java then my understanding of nested loops. This program prints a right-angled triangle star pattern like this: Explanation: ->I used an outer loop to control the number of rows. ->I used an inner loop to print stars in each row. ->The number of stars increases with each row. ->This helped me understand how nested loops work together. ->Concepts Used: ->Nested loops ->Pattern logic ->Loop control