Java Method Overloading: Compile-Time Polymorphism

Threads state & Priority in java 🧵 After understanding what thread is and how to create one, the next question is: ➡️What state my thread is and how does the JVM schedule it? 🧠Threads States in Java A thread can be in one of these states during its lifecycle: 🔸NEW Thread is created but not yet started (start() method is not called) 🔸RUNNABLE Thread is ready to run or concurrently running 🔸BLOCKED Waiting to acquire a monitor lock (synchronized block) 🔸 WAITING Waiting indefinitely for another thread to act 🔸TIMED_WAITING Waiting for a specified time( sleep(), wait(timeout), join(timeout) ) 🔸TERMINATED Execution completed 👉A thread doesn't move linearly - it can jump between states multiple times. ---------------------------------------------------------------------- ⚡Thread Priority in Java Each thread has a priority that hints the scheduler: ✓MIN_PRIORITY — 1 ✓NORM_PRIORITY — 5(default) ✓MAX_PRIORITY — 10 ☘️Example: Thread t = new Thread(task); t.setPriority(Thread.MAX_PRIORITY); IMPORTANT ⚠️ 1.Priority is a hint, not a guarantee. 2.Behaviour is OS and JVM dependent. 3.High priority doesn't mean it will always run first. #Java #Threads #Concurrency #Multithreading #SoftwareEngineering #Backend #Programming

I wrote a blog post about "Functional Composition Patterns." If you're interested in learning how to implement them in pure Java, it's good material. You could also check out the rest of the documentation for the `dmx-fun` library. https://lnkd.in/eR5uvmHE

Hello everyone! Check out this short piece by Simon Ritter on local variable type inference in Java. Worth a read. Good Monday! #Java #BestPractices

Have you ever wondered what really happens when we compile a Java program? Most people say- “It generates a .class file and bytecode.” But that’s only the surface. When we compile a Java program, multiple structured steps are performed by the compiler (javac). It’s not a simple conversion .It’s a construction pipeline. Compilation Flow 1. Lexical Analysis Java reads your code and breaks it into tokens. 2. Syntax Parsing Validates Java grammar rules , language structure validation. 3. Semantic Analysis Checks whether the code makes logical sense: Examples: • Type correctness int x = true; // meaning wrong • Symbol existence x = 10; // x not declared • Access rules private int a; obj.a; // illegal access …and many more semantic checks (method resolution, inheritance rules, override validity, interface contracts, etc.) 4. Symbol Table Creation The compiler builds an internal metadata registry of the program. This is how it knows- what belongs where who can access what what resolves to what 5. Bytecode Generation Now the real transformation happens. int a = 10; Becomes JVM instructions: iconst_10 istore_1 This is JVM instruction code, not machine code. 6 .class File Structure Creation Compiler builds a structured binary file: .class file = ├── Magic Number (CAFEBABE) ├── Version ├── Constant Pool ├── Class Metadata ├── Fields Metadata ├── Methods Metadata ├── Bytecode Instructions └── Attributes A .class file is not just bytecode , it is a structured binary execution blueprint prepared for the JVM. It prepares code for JVM and JVM later decides how and when to generate machine code using JIT. #Java #JVM #Compiler #Bytecode #JavaInternals #Programming

Demystifying Generics in Java 🔄 Tired of ClassCastExceptions and unchecked type warnings? Java Generics are here to rescue your code, bringing type safety, reusability, and clarity to your collections and classes. In essence, Generics allow you to write classes, interfaces, and methods that operate on a "type parameter" (like <T>) instead of a specific type (like String or Integer). The compiler then enforces this type for you. Why Should You Care? Here’s the Impact: ✅ Type Safety at Compile-Time: Catch type mismatches during development, not at runtime. The compiler becomes your best friend. ✅ Eliminate Casts: Say goodbye to (String) myList.get(0). Code becomes cleaner and more readable. ✅ Write Flexible, Reusable Code: Create a single class like Box<T> that can handle a Box<String>, Box<Integer>, or any type you need. Common Questions, Answered: Q1: What’s the difference between List<?>` and `List<Object>`? A: `List<Object>` can hold any object type but is restrictive on what you can add from other lists. `List<?> (an unbounded wildcard) represents a list of some unknown type. It’s mostly for reading, as you cannot add to it (except null). It provides maximum flexibility when you only need to read/iterate. Q2: Can I use primitives with Generics? A: No. Generics only work with reference types (objects). For primitives like int, use their wrapper classes (Integer) or leverage Java’s autoboxing feature. Q3: What is type erasure? A: To ensure backward compatibility, Java removes (erases) generic type information at runtime. List<String> and List<Integer> both become just List after compilation. This is why you cannot do if (list instanceof List<String>). Generics are foundational for writing robust, enterprise-level Java code. They turn collections from a potential source of bugs into a powerful, predictable tool. Share your experiences and questions in the comments! Let's learn together. #Java #Generics #Programming #SoftwareDevelopment #Coding #TypeSafety #BestPractices #DeveloperTips

“var” in Java: less noise… or less clarity? Local Variable Type Inference (LVTI) has been in Java since JDK 10, and it’s one of those features that can either make code beautifully readable—or quietly introduce ambiguity. In this article, Simon Ritter breaks down when `var` is a *friend*: ✅ the initializer makes the type obvious   ✅ it helps split long / chained expressions into readable steps   ✅ it reduces repetition without hiding intent …and when it becomes a *foe*: ⚠️ the type isn’t obvious without an IDE   ⚠️ literals/generics inference can surprise you   ⚠️ overloads and subtle type changes can alter behavior later My takeaway: `var` is a readability tool, not a typing shortcut. Use it where local reasoning still works. #Java #OpenJDK #SoftwareEngineering #CleanCode #DeveloperProductivity

Today I focused on understanding the types of variables in Java and how their behavior changes depending on where they are declared. At first it looked simple, but while going through examples, I realized that the real difference is not the datatype — it is the scope, initialization, and memory behavior of the variable. Things that became clear: - Local variables exist only inside methods, blocks, or constructors and must be initialized before use - Their scope is limited to the method in which they are declared - Instance variables are declared inside a class but outside methods and are automatically initialized with default values by the compiler - These default values depend on datatype, such as 0 for numeric types, false for boolean, '\0' for char, and null for objects - Instance variables are accessible across all methods of the same class, showing how objects maintain state Seeing the object example made the concept clearer, an object holds its own copy of instance variables, which get real values only after initialization. The biggest realization from this topic was simple - Understanding Java is less about syntax and more about how memory, scope, and initialization actually work. Small concept, but an important foundation for everything ahead. #java #programming #learninginpublic #javabasics #codingjourney

𝐂𝐨𝐦𝐩𝐚𝐜𝐭 𝐒𝐨𝐮𝐫𝐜𝐞 𝐅𝐢𝐥𝐞𝐬 Java 25 introduces a cleaner way to write small programs—especially helpful for learning, demos, and quick experiments. You can now create a Java program 𝐰𝐢𝐭𝐡𝐨𝐮𝐭 𝐞𝐱𝐩𝐥𝐢𝐜𝐢𝐭𝐥𝐲 𝐝𝐞𝐟𝐢𝐧𝐢𝐧𝐠 𝐚 𝐜𝐥𝐚𝐬𝐬. The compiler takes care of it for you behind the scenes. 𝐉𝐚𝐯𝐚 𝐂𝐥𝐚𝐬𝐬 𝐁𝐞𝐟𝐨𝐫𝐞 𝐉𝐚𝐯𝐚25 public class ClassBeforeJava25 { public static void main(String [] args){ System.out.println("This is class Before Java 25"); List<String> list = new ArrayList<>(); list.add("Apple"); list.add("Mango"); list.add("Cat"); System.out.println("Display my list : "+ list); } } 𝐉𝐚𝐯𝐚 𝐂𝐥𝐚𝐬𝐬 𝐈𝐧 𝐉𝐚𝐯𝐚25 void main() { System.out.println("compact class In Java 25"); List<String> list = new ArrayList<>(); list.add("Apple"); list.add("Mango"); list.add("Cat"); System.out.println("Display my list : "+ list); } 🔍 𝐖𝐡𝐚𝐭’𝐬 𝐡𝐚𝐩𝐩𝐞𝐧𝐢𝐧𝐠 𝐢𝐧𝐭𝐞𝐫𝐧𝐚𝐥𝐥𝐲? - The compiler automatically generates an internal class for your code - This generated class is 𝐟𝐢𝐧𝐚𝐥 and can’t be extended - A default no-args constructor is added automatically - The generated class name is internal and not accessible in your source explore the complete examples in this GitHub repository: https://lnkd.in/gPxF4zwK #Java25 #JavaDevelopment #JVM

Day 2/100 programs 🔹 Majority Element Problem | Java Implemented an efficient solution to the Majority Element problem in Java, where the task is to find the element that appears more than ⌊ n/2 ⌋ times in an array. 💡 Approach Used: Boyer–Moore Voting Algorithm Optimized for O(n) time complexity and O(1) space complexity 🧠 Key Learnings: Importance of algorithmic thinking over brute force How voting-based logic eliminates unnecessary comparisons Writing clean and readable Java code for interview-style problems 🚀 Why it matters: This problem is a classic example of turning a mathematical insight into a highly optimized solution—commonly asked in technical interviews and competitive programming. 📌 Tech Stack: Java | DSA | Algorithms