Java ArrayList Basics: Dynamic Array for Backend Development

🚀 Java Series – Day 21 📌 Inner Classes in Java (Static vs Non-Static) 🔹 What is it? An Inner Class is a class defined inside another class. Java provides different types of inner classes: • Member Inner Class (Non-static) • Static Nested Class • Local Inner Class (inside method) • Anonymous Inner Class 🔹 Why do we use it? Inner classes help in logical grouping of classes and improve code readability & encapsulation. For example: In a banking system, a "Bank" class can contain an inner class "Account" to tightly couple related logic. 🔹 Static vs Non-Static Inner Class: • Non-Static Inner Class (Member Inner Class) - Requires outer class object - Can access all members of outer class - Used when inner class depends on outer class • Static Inner Class (Static Nested Class) - Does NOT require outer class object - Can access only static members of outer class - Used for utility/helper classes 🔹 Example: class Outer { int x = 10; static int y = 20; // Non-static inner class class Inner { void display() { System.out.println("x = " + x); // can access all } } // Static inner class static class StaticInner { void display() { System.out.println("y = " + y); // only static access } } } public class Main { public static void main(String[] args) { // Non-static inner class Outer outer = new Outer(); Outer.Inner inner = outer.new Inner(); inner.display(); // Static inner class Outer.StaticInner obj = new Outer.StaticInner(); obj.display(); } } 💡 Key Takeaway: Use non-static inner classes when tightly coupled with outer class, and static inner classes for independent utility behavior. What do you think about this? 👇 #Java #InnerClass #JavaDeveloper #Programming #BackendDevelopment

🚀 Understanding Method Overloading in Java 🔥 Let's break down the concept of method overloading in Java! Method overloading allows developers to define multiple methods with the same name but different parameters, making code more flexible and readable. This means you can have multiple methods with the same name, as long as the parameters differ in type or number. ⚡️ Why does method overloading matter for developers? It helps streamline code by promoting code reusability and enhancing readability. By using method overloading, developers can create cleaner code that is easier to maintain and understand. 👨💻 Here's a step-by-step breakdown: 1️⃣ Create multiple methods with the same name 2️⃣ Ensure the parameters are different in either type or number 3️⃣ The Java compiler determines which method to execute based on the arguments provided 📝 Full code example: ``` public class Calculate { public int sum(int a, int b) { return a + b; } public double sum(double a, double b) { return a + b; } } ``` 💡 Pro tip: Avoid overloading methods with the same number and type of parameters, as it can lead to ambiguity. ⚠️ Common mistake: Forgetting that the return type of the overloaded methods can be the same. ❓ How do you use method overloading in your Java projects? Do you have any favorite tricks? Share below! 💬 🌐 View my full portfolio and more dev resources at tharindunipun.lk #JavaProgramming #MethodOverloading #CodeFlexibility #LearnToCode #DeveloperTips #CleanCode #JavaDev #CodingCommunity #TechTalks

🚀 Java Series – Day 19 📌 Multithreading in Java (Thread vs Runnable) 🔹 What is it? Multithreading is a process of executing multiple threads simultaneously to perform tasks efficiently. A thread is a lightweight unit of execution within a program. Java provides two main ways to create threads: • Extending the Thread class • Implementing the Runnable interface 🔹 Why do we use it? Multithreading helps improve performance and responsiveness. For example: In a web application, one thread can handle user requests while another processes background tasks like data saving or logging. 🔹 Thread vs Runnable: • Thread Class - Extend "Thread" - Less flexible (Java doesn’t support multiple inheritance) • Runnable Interface - Implement "Runnable" - More flexible (can extend another class) - Preferred approach in real-world applications 🔹 Example: // Using Thread class MyThread extends Thread { public void run() { System.out.println("Thread using Thread class"); } } // Using Runnable class MyRunnable implements Runnable { public void run() { System.out.println("Thread using Runnable"); } } public class Main { public static void main(String[] args) { MyThread t1 = new MyThread(); t1.start(); Thread t2 = new Thread(new MyRunnable()); t2.start(); } } 💡 Key Takeaway: Use Runnable for better flexibility and scalability in multithreaded applications. What do you think about this? 👇 #Java #Multithreading #JavaDeveloper #Programming #BackendDevelopment

Day 8 of Java Series ☕💻 Today we dive into one of the most important real-world concepts in Java — Exception Handling 🚨 👉 Exception Handling is used to handle runtime errors so that the normal flow of the program can be maintained. 🧠 What is an Exception? An Exception is an unwanted event that occurs during program execution and disrupts the normal flow of the program. ⚙️ Types of Exceptions: Checked Exceptions (Compile-time) Example: IOException, SQLException Unchecked Exceptions (Runtime) Example: ArithmeticException, NullPointerException Errors Example: StackOverflowError, OutOfMemoryError 🛠️ Exception Handling Keywords: try → Code that may throw exception catch → Handles the exception finally → Always executes (cleanup code) throw → Used to explicitly throw exception throws → Declares exceptions 💻 Example Code: Java Copy code public class Main { public static void main(String[] args) { try { int a = 10 / 0; } catch (ArithmeticException e) { System.out.println("Cannot divide by zero!"); } finally { System.out.println("Execution Completed"); } } } ⚡ Custom Exception: You can create your own exception by extending Exception class. Java Copy code class MyException extends Exception { MyException(String msg) { super(msg); } } 🎯 Why Exception Handling is Important? ✔ Prevents program crash ✔ Maintains normal flow ✔ Improves debugging ✔ Makes code robust 🚀 Pro Tip: Always catch specific exceptions instead of generic ones for better debugging! 📢 Hashtags: #Java #ExceptionHandling #JavaSeries #Programming #CodingLife #LearnJava #Developers #Tech

Day 8/100 — Mastering Strings in Java 🔤 Today I explored one of the most important topics in Core Java: Strings. Every Java developer should clearly understand these three concepts: 1️⃣ Immutability In Java, a String object cannot be changed after it is created. Any modification actually creates a new object in memory. 2️⃣ String Pool Java optimizes memory using the String Pool. When we create strings using literals, Java stores them in a special memory area and reuses them. 3️⃣ equals() vs == • equals() → compares the actual content of two strings • == → compares memory references (whether both variables point to the same object) 💻 Challenge I practiced today: Reverse a String using charAt() method. Example logic: String str = "Java"; String reversed = ""; for (int i = str.length() - 1; i >= 0; i--) { reversed += str.charAt(i); } System.out.println(reversed); Small concepts like these build strong Java fundamentals. Consistency is key in this 100 Days of Code journey 🚀 #Java #CoreJava #JavaLearning #Strings #Programming #DeveloperJourney #100DaysOfCode

🔹 Understanding Exception Handling in Java 🔹 Exception handling is a crucial concept in Java that helps manage runtime errors and ensures the smooth execution of programs without abrupt termination. Here are the three primary ways to handle exceptions in Java: ✅ 1. Try-Catch Block The most commonly used approach. The try block contains code that may cause an exception, and the catch block handles it. Multiple catch blocks can be used for different exception types. The optional finally block always executes, regardless of whether an exception occurs or not. ✅ 2. Rethrowing an Exception In this approach, an exception is caught and then thrown again using the throw keyword. This allows the exception to be handled at a higher level in the program, improving flexibility and control. ✅ 3. Ducking an Exception (Exception Propagation) Here, the exception is not handled in the current method but is passed to the calling method using the throws keyword. The responsibility of handling the exception is delegated to the caller. 🔑 Key Keywords: try → Defines code that may throw an exception catch → Handles the exception finally → Always executes throw → Explicitly throws an exception throws → Declares exceptions in method signature 📌 Important Notes: The finally block cannot exist without a try block throw transfers control similar to a return statement but for exceptions throws only declares, it does not handle exceptions 💡 Mastering exception handling helps in writing robust, error-free, and maintainable Java applications. #Java #ExceptionHandling #Programming #Coding #JavaDeveloper #LearningJourney #TapAcademy

🚀 Java Series – Day 28 📌 Reflection API in Java (How Spring Uses It) 🔹 What is it? The **Reflection API** allows Java programs to **inspect and manipulate classes, methods, fields, and annotations at runtime**. It allows operations like **creating objects dynamically, invoking methods, and reading annotations** without hardcoding them. 🔹 Why do we use it? Reflection helps in: ✔ Dependency Injection – automatically injects beans ✔ Annotation Processing – reads `@Autowired`, `@Service`, `@Repository` ✔ Proxy Creation – supports AOP and transactional features For example: In Spring, it can detect a class annotated with `@Service`, create an instance, and inject it wherever required without manual wiring. 🔹 Example: `import java.lang.reflect.*; @Service public class DemoService { public void greet() { System.out.println("Hello from DemoService"); } } public class Main { public static void main(String[] args) throws Exception { Class<?> clazz = Class.forName("DemoService"); // load class dynamically Object obj = clazz.getDeclaredConstructor().newInstance(); // create instance Method method = clazz.getMethod("greet"); // get method method.invoke(obj); // invoke method dynamically } }` 🔹 Output: `Hello from DemoService` 💡 Key Takeaway: Reflection makes Spring **dynamic, flexible, and powerful**, enabling features like DI, AOP, and annotation-based configuration without manual coding. What do you think about this? 👇 #Java #ReflectionAPI #SpringBoot #JavaDeveloper #BackendDevelopment #TechLearning #CodingTips

Day 9 Java Practice: Find the First Non-Repeated Character in a String While practicing Java, I worked on a classic string problem: 👉 Find the first non-repeated character in a given string. For example, in the string "swiss", the first character that does not repeat is 'w'. To solve this, I used a LinkedHashMap to store character counts while preserving insertion order. Then I iterated through the map to find the first character with count = 1. ================================================== // Online Java Compiler // Use this editor to write, compile and run your Java code online import java.util.*; class Main {   public static void main(String[] args) {           String s="swiss";           char[] words=s.toCharArray();           Map<Character,Integer>map=new LinkedHashMap<Character,Integer>();           for(char word:words)     {      map.put(word,map.getOrDefault(word,0)+1);     }           for(Map.Entry<Character,Integer>entry:map.entrySet())     {       if(entry.getValue()==1)       {         System.out.println("First non-repeated character in the string is:"+entry.getKey());         break;       }     }               } } Output:First non-repeated character in the string is:w This was a good exercise to understand: Character frequency counting Importance of insertion order using LinkedHashMap String traversal logic #AutomationTestEngineer #Selenium #Java #CodingPractice #ProblemSolving

𝗘𝘃𝗲𝗿 𝗻𝗼𝘁𝗶𝗰𝗲𝗱 𝘁𝗵𝗶𝘀? In Java, switch-case with Strings sometimes feels faster than if-else. At first, both look pretty similar. But internally, they don’t work the same way. 𝗪𝗶𝘁𝗵 𝗶𝗳-𝗲𝗹𝘀𝗲, 𝗝𝗮𝘃𝗮 𝗰𝗵𝗲𝗰𝗸𝘀 𝗲𝗮𝗰𝗵 𝗰𝗼𝗻𝗱𝗶𝘁𝗶𝗼𝗻 𝗼𝗻𝗲 𝗯𝘆 𝗼𝗻𝗲: if (str.equals("A")) else if (str.equals("B")) else if (str.equals("C")) So it keeps going until it finds a match. --- Switch-case does something smarter. Java converts the String into a hash and uses that to jump closer to the right case. So instead of checking everything sequentially, it narrows things down faster. --- That said… If you only have 2–3 conditions, it really doesn’t matter. The difference shows up when the number of conditions grows. --- I actually realized this while looking at a long if-else chain in one of our services 😄 --- The bigger takeaway? It’s not about memorizing syntax. It’s about understanding how things work under the hood. --- Have you ever come across something like this in Java? #java #javadeveloper #backenddevelopment #softwareengineering #coding #springboot #programming #developers #systemdesign #tech

I recently explored a subtle but important concept in Java constructor execution order. Many developers assume constructors simply initialize values, but the actual lifecycle is more complex. In this article, I explain: • The real order of object creation • Why overridden methods can behave unexpectedly • A common bug caused by partial initialization This concept is especially useful for interviews and writing safer object-oriented code. Medium Link: https://lnkd.in/gtRhpdfP #Java #OOP #SoftwareDevelopment #Programming