Java Method Calling Rules: Static vs Non-Static Explained

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

🚀 Day 08: Java Streams using Strings Today I learned how to use Java Stream API with Strings in a simple and beginner-friendly way. Let me break it down 👇 🔹 Creating Streams from a String Java provides easy methods to convert a String into streams: ✅ Characters :- str.chars() ➡️ Returns an IntStream of character unicode values. ✅ Words :- Arrays.stream(str.split(" ")) ➡️ Splits the string by spaces and creates a stream of words. ✅ Lines :- str.lines() ➡️ Creates a stream of lines (very useful for multiline strings). 🔹 Primitive vs Object Streams (Very Important 💡) Streams work differently for primitive types and object types. 🔸 mapToObj() Used to convert primitive → object Example: int → Integer 🔸 boxed() Shortcut for mapToObj() Converts primitive streams into object streams 🔸 mapToInt() Used to convert object → primitive Example: Integer → int 🔹 Examples ✅ Object → Primitive int[] arr = list.stream() .mapToInt(i -> i.intValue()) .toArray(); 👉 Since int is a primitive, we use mapToInt() 👉 If we use boxed(), manual conversion is not required ✅ Object → Object String[] arr = list.stream() .toArray(i -> new String[i]); 👉 String is non-primitive, so: No boxed() needed We directly use the constructor inside toArray() 🔹 Key Takeaways 🧠 ✔ int → primitive → use mapToInt() ✔ Integer → object → use boxed() if needed ✔ String → already an object → no boxing required 📌 Learning Java Streams step by step — one day at a time! 👉 For more updates, connect and follow me regularly 🚀 ⏮️https://lnkd.in/gGEEgiUr #Java #JavaDeveloper #JavaStreams #StreamAPI #Programming #Coding #LearnJava #JavaBeginners #SoftwareDeveloper #100DaysOfCode #TechCareers #CodingJourney #DeveloperCommunity #LinkedInLearning

☕️💡 Java Wrapper Classes - Turning Primitives into Powerful Objects! 🚀📦 Ever wondered how simple primitive types like int, char, and boolean can play nicely with Java’s object‑oriented world? 🤔 That’s the magic of Wrapper Classes they wrap primitive values into objects so you can use them with collections, generics, and powerful utility methods! 📚✨ In Java, each primitive type has its own class (like Integer for int, Double for double, and Boolean for boolean). 🔹 Why it matters: Use primitives in ArrayList, HashMap, and other collections 🚀 Benefit from utility methods like parseInt() and toString() 🧰 Enjoy autoboxing & unboxing that makes conversion seamless 🔄 Whether you’re building collection‑heavy apps or diving deeper into OOP practices, mastering wrapper classes is a foundational Java skill! 💪 👉 Check out the full blog here: https://lnkd.in/gXB-B6m7 #Java #WrapperClasses #Autoboxing #ObjectOriented #CodingTips #JavaCollections #SoftwareEngineering #DeveloperLife #TechBlog #Programming 💻🔥📊

🧠 Is Java’s variable a productivity boost—or a readability trap? 👉 Local Variable Type Inference — friend or foe? The post looks at: ✅ Where variable genuinely improves developer productivity ✅ When it can reduce code clarity ✅ Practical guidelines for using it responsibly in real-world Java codebases If you work with Java and care about clean, maintainable code, this is worth a look. 🔗 Blog link: https://lnkd.in/gsexkzWe #Java #JavaDev #CleanCode #CodeQuality #SoftwareEngineering #Programming #BackendDevelopment #DeveloperProductivity #TechWriting

Let’s talk about one of the absolute workhorses of Java programming: The ArrayList. When I first started learning Java, standard Arrays confused me. "Why do I have to know exactly how many items I need before I start?" Enter the ArrayList<>. Think of a standard Java Array like a standard egg carton. It holds exactly 12 eggs. If you buy a 13th egg, you’re out of luck. It won't fit. An ArrayList is like a magical, elastic shopping bag. 🛍️ It starts small, but as you add more items, it automatically stretches to accommodate them. You don't need to worry about size limits upfront. As shown in the cheatsheet below 👇, mastering it comes down to two fundamental operations: ✅ 1. Storing (The .add() method) You throw something into the bag, and it lands right on top (at the end of the list). // Creating the elastic bag for Strings ArrayList<String> shoppingList = new ArrayList<>(); // Adding items to the end shoppingList.add("Milk"); shoppingList.add("Bread"); // The list is now: ["Milk", "Bread"] ✅ 2. Fetching (The .get() method) Because ArrayLists are ordered (like a numbered to-do list), you can grab any item instantly if you know its position number (index). Remember: Java starts counting at zero! // Grabbing the first item (Index 0) String firstItem = shoppingList.get(0); // Result: "Milk" It’s dynamic, it’s resizable, and it’s essential for any new Java developer. #JavaDeveloper #CodingFundamentals #JavaProgramming #SoftwareEngineering #MyFirstPost #LearntoCode #Technology

⚠️ Checked vs Unchecked Exceptions — Why Java Has Two Types? 🧠 Ever wondered why Java forces you to handle some exceptions but ignores others? 🤔 That’s not accidental — it’s design thinking 💡 🧠 Think of it like daily life 🚦 Forgetting your house keys 🔑 → you must handle it Slipping on a wet floor 💥 → happens unexpectedly Java models the same idea. ✅ Checked Exceptions (Expected Problems) 👉 Problems you know might happen 👉 Compiler forces you to handle them FileReader reader = new FileReader("data.txt"); // IOException You must: try-catch OR throws 📌 Examples: IOException SQLException ❌ Unchecked Exceptions (Programming Mistakes) 👉 Problems caused by code issues 👉 Compiler does NOT force handling int x = 10 / 0; // ArithmeticException 📌 Examples: NullPointerException ArrayIndexOutOfBoundsException 🎯 Key Difference Checked[ Known-risk ,Compile-time, Must handle] Unchecked [ Code-bug , Runtime , Optional] ✨ Key Takeaway Checked exceptions protect you from expected failures 🛡️ Unchecked exceptions expose programming errors 🐞 Knowing when to use which makes your code cleaner, safer, and professional 🚀 #Exceptions #java #learning #Springboot #BackendDevelopment

📘 Core Java – Day 5 Topic: Loops (for loop & simple pattern) Today, I learned about the concept of Loops in Core Java. Loops are used to execute a block of code repeatedly, which helps in reducing code redundancy and improving efficiency. In Java, the main types of loops are: 1. for loop 2. while loop 3. do-while loop 4. for-each loop 👉 I started by learning the for loop. 🔹 Syntax of for loop: for(initialization; condition; increment/decrement) { // statements } 🔹 Working of for loop: Initialization – initializes the loop variable (executed only once) Condition – checked before every iteration Execution – loop body runs if the condition is true Increment/Decrement – updates the loop variable Loop continues until the condition becomes false ⭐ Example: Simple Star Pattern using for loop for(int i = 1; i <= 5; i++) { for(int j = 1; j <= i; j++) { System.out.print("* "); } System.out.println(); } Output: * * * * * * * * * * * * * * * 🔹 Key Points: ✔ for loop is used when the number of iterations is known ✔ It keeps code structured and readable ✔ Nested for loops are commonly used in pattern programs 🚀 Building strong fundamentals in Core Java, one concept at a time. #CoreJava #JavaLoops #ForLoop #JavaProgramming #LearningJourney #Day5

📘 Java Learning – Constructors(Core Concept) While strengthening my Core Java fundamentals, I learned how constructors play a crucial role in object initialization and ensure objects behave correctly at runtime. Here are my key learnings 👇 ✅ Why Constructors Are Required • Object creation alone is not sufficient • An object must be properly initialized to respond correctly 📌 Whenever an object is created, a special block of code is executed automatically to perform initialization. This block of code is called a constructor. ➡️ Main objective of a constructor: To initialize the newly created object. ✅ Rules to Define a Constructor • Constructor name must be the same as class name • Return type is not applicable (not even void) • Constructors are executed automatically during object creation ⚠️ Return Type Misconception If a return type is declared, it is not a constructor — it becomes a normal method. 🧪 Example: void Test() // This is a method, not a constructor 📌 No compile-time or runtime error occurs, but this is not a constructor. ✅ Applicable Modifiers for Constructors Only the following modifiers are allowed: • public • private • protected • default ❌ Using any other modifier causes a compile-time error. 🧪 Example: final Test() // Compile-time error 📌 Error: modifier final is not allowed here ✅ Types of Constructors ▶️ Default Constructor • Generated by the compiler if no constructor is written • Initializes instance variables with JVM-provided default values 🧪 Example: Demo d = new Demo(); // compiler-generated constructor 📌 Provided automatically by the compiler. ▶️ Parameterized Constructor • Written by the programmer • Accepts parameters to initialize object data • Allows creating objects with different values 🧪 Example: Student s1 = new Student("Raju", 101); Student s2 = new Student("Ravi", 102); 📌 Each object gets initialized with its own data at creation time. ⭐ Important Conclusion • If no constructor is written → compiler generates default constructor • If at least one constructor is written → compiler does not generate default constructor ➡️ A class can contain either: • Compiler-generated constructor • Programmer-written constructor ❌ Not both simultaneously Understanding constructors helps ensure objects are created in a valid state and behave predictably at runtime — a critical concept for building reliable backend applications. Building strong fundamentals, one concept at a time 🚀 #Java #CoreJava #Constructors #JavaInternals #JavaFullStack #BackendDeveloper #LearningJourney

Good Monday! If you weren’t sure of the use cases of Java’s newer pattern matching features and “algebraic data types", it might be useful to read this recent Cay Horstmann’s blog post on the subject.  #Java #PatternMatching #DataOrientedProgramming https://lnkd.in/eXsrbk2p