Java Method Overloading: Compile Time Polymorphism with Examples

DAY 18: CORE JAVA TAP Academy 🚀 Understanding Method Overloading in Java Method Overloading is one of the core concepts of Compile-Time Polymorphism in Java. It allows a class to have multiple methods with the same name but different parameter lists. Let’s break down how method overloading is observed and identified 👇 🔹 1. Method Name The method name must be the same. Example: add() can have multiple definitions within the same class. 🔹 2. Number of Parameters If the number of parameters is different, the method is overloaded. int add(int a, int b) int add(int a, int b, int c) 🔹 3. Type of Parameters Even if the number of parameters is the same, changing the data type makes it overloaded. int add(int a, int b) double add(double a, double b) 🔹 4. Order of Parameters If parameter types are the same but in a different order, it is still valid overloading. void display(int a, String b) void display(String b, int a) 🔹 5. Type Conversion (Implicit Casting) Java follows method matching rules: Exact match Widening (int → long → float → double) Autoboxing Varargs Example: void show(int a) void show(double a) If we call show(5), Java chooses the most specific match (int). 🔹 6. Ambiguity in Method Overloading Ambiguity occurs when Java cannot determine which method to call. Example: void test(int a, float b) void test(float a, int b) Calling test(10, 10) creates confusion because both methods are possible after type conversion. ⚠️ The compiler throws an error in such cases. 📌 Important Terms Related to Method Overloading ✔️ Compile-Time Polymorphism ✔️ Static Binding ✔️ Early Binding ✔️ Method Signature (method name + parameter list) ✔️ Implicit Type Promotion ✔️ Varargs ✔️ Autoboxing 💡 Key Rule to Remember Changing only the return type does NOT achieve method overloading. int sum(int a, int b) double sum(int a, int b) ❌ (Invalid) ✨ Method overloading improves code readability, flexibility, and reusability. It allows developers to perform similar operations in different ways without changing method names. Mastering this concept is essential for cracking Java interviews and writing clean object-oriented code. #Java #OOPS #Programming #SoftwareDevelopment #Coding #LearningJourney

🚀 Day 17 @ TAP Academy | Introduction to Strings in Java Today at TAP Academy, we explored a core concept of Java programming — the String! ☕💻 💡 What is a String in Java? A String is a sequence of characters enclosed within double quotes ("). In Java, a string is actually an object of the String class, not just a data type. 🧠 Simple Definition: A string is a collection of characters used to represent text in Java. ✅ Example: String name = "TAP Academy"; System.out.println(name); 📘 Output: TAP Academy 🧩 Different Ways to Create a String There are two main ways to create strings in Java 👇 1️⃣ Using String Literal String s1 = "Hello"; String s2 = "Hello"; 🟢 Java reuses the same memory in the String Constant Pool, making it efficient. 2️⃣ Using new Keyword String s3 = new String("Hello"); 🔵 Creates a new object in heap memory, even if the same value exists. ⚙️ Common String Methods Strings in Java come with many useful built-in methods that make text handling simple: MethodDescriptionExamplelength()Returns string length"TAP".length() → 3charAt()Returns character at index"Java".charAt(2) → vtoUpperCase()Converts to uppercase"tap".toUpperCase() → TAPtoLowerCase()Converts to lowercase"TAP".toLowerCase() → tapconcat()Joins two strings"TAP".concat(" Academy") → TAP Academyequals()Compares strings"Java".equals("JAVA") → false 🧠 String Characteristics ✔️ Strings are immutable – once created, they cannot be changed. ✔️ They are stored in the String Constant Pool for memory efficiency. ✔️ The String class is part of the java.lang package (imported automatically). ✔️ For mutable strings, we use StringBuilder or StringBuffer. 🔍 Example Program public class StringExample { public static void main(String[] args) { String course = "TAP Academy"; System.out.println("Length: " + course.length()); System.out.println("Uppercase: " + course.toUpperCase()); System.out.println("Character at index 4: " + course.charAt(4)); } } ✅ Output: Length: 11 Uppercase: TAP ACADEMY Character at index 4: c 💬 Why Strings Are Important ✔️ Used in almost all applications (names, messages, input/output). ✔️ Essential for working with user input, file handling, and APIs. ✔️ Foundation for text processing and data communication in Java. #TAPAcademy #JavaProgramming #StringsInJava #CoreJava #LearningJourney #InternshipExperience #CodingJourney #ProgrammingBasics #LearnToCode #BuildInPublic #JavaDeveloper #TechLearning #SoftwareDevelopment #CodingCommunity #ObjectOrientedProgramming

🚀 Day 19 at TAP Academy – Exploring Java Arrays in Depth Today’s session was focused on gaining a deeper understanding of Java Arrays and how they are used in real programming scenarios. We started with a quick recap of the limitations of arrays, such as storing only homogeneous data, fixed size allocation, and the requirement of contiguous memory. 💡 One of the key topics covered was the three different ways to create arrays in Java: 1️⃣ Standard array creation using new keyword (most commonly used in real programs). 2️⃣ Creating arrays with predefined values using new int[]{} syntax. 3️⃣ Shorthand array initialization using {} without the new keyword. We also explored how arrays can be created for different primitive data types like byte, short, int, float, double, char, and boolean, along with the corresponding Scanner methods used to take input from users. 🔤 Another interesting concept was handling character input in Java, where we learned the workaround using: scan.next().charAt(0) since Java does not provide a direct nextChar() method. 📦 The session then moved to Arrays of Strings, which highlighted how Java treats Strings as objects and how they can be stored and accessed in arrays similar to primitive types. 👨💻 One of the most important parts of the class was learning about Arrays of Objects using an Employee class example. This helped in understanding: ✔ How objects are created and stored in arrays ✔ The concept of pass-by-reference ✔ How loops can be used to optimize code and avoid repetition when dealing with multiple objects This approach makes programs scalable and efficient, allowing the same logic to work whether we handle 2 objects or thousands of objects. ⚙️ Finally, we explored Command Line Arguments (String[] args), which clarified how Java programs can receive inputs directly from the command line during execution. This concept also introduced how all command-line inputs are treated as Strings, which leads into the next important topic — Java Strings. 📚 Key Takeaways from Today’s Session: • Different ways to create arrays in Java • Arrays with primitive data types and Scanner methods • Handling character input using charAt() • Working with arrays of Strings • Creating and managing arrays of objects • Understanding command line arguments in Java • Writing optimized and scalable code using loops Every session at TAP Academy continues to strengthen my core Java concepts and programming logic, bringing me one step closer to becoming a better developer. 💻✨ #Java #Programming #JavaArrays #LearningJourney #Coding #SoftwareDevelopment #TAPAcademy #JavaDeveloper 🚀

🚀 Day 13 TAP Academy | Understanding Methods in Java 💡 What is a Method? A method is a group of statements that together perform an operation. Methods help make programs modular, clean, and easy to maintain. Think of a method as a mini-program inside your main program — you define it once and call it whenever needed. 🧠 Syntax of a Method: returnType methodName(parameters) { // Method body // Code to perform the task } ✅ Example: public int add(int a, int b) { return a + b; } Here: public → Access modifier int → Return type add → Method name (int a, int b) → Parameters return a + b; → Method body 🔹 Why Methods Are Important ✔️ Eliminate code repetition ✔️ Increase code reusability ✔️ Simplify debugging and testing ✔️ Improve program readability and structure 🔸 Types of Methods in Java Java provides different types of methods based on their behavior and purpose 👇 🧩 1️⃣ Predefined (Built-in) Methods These are already defined in Java’s standard libraries. You just have to use them. ✅ Example: System.out.println("Hello Java!"); Math.sqrt(25); // returns 5.0 📚 These methods come from predefined classes like Math, String, System, etc. 🧱 2️⃣ User-defined Methods These are created by the programmer to perform specific tasks. ✅ Example: public class Calculator { void greet() { System.out.println("Welcome to TAP Academy!"); } int add(int a, int b) { return a + b; } public static void main(String[] args) { Calculator obj = new Calculator(); obj.greet(); System.out.println("Sum: " + obj.add(5, 10)); } } ✅ Output: Welcome to TAP Academy! Sum: 15 ⚙️ Based on Return Type TypeDescriptionExampleVoid MethodDoes not return any valuevoid greet() {}Return Type MethodReturns a value after executionint add() { return a+b; } 🧠 Based on Parameters TypeDescriptionExampleWithout ParametersDoesn’t accept any inputvoid display()With ParametersTakes input valuesvoid add(int a, int b) 🔁 Method Overloading When multiple methods have the same name but different parameters, it’s called method overloading. It increases code flexibility and reusability. ✅ Example: void show() { System.out.println("No Parameters"); } void show(int a) { System.out.println("Value: " + a); } 🧩 Difference Between Built-in and User-defined Methods FeatureBuilt-in MethodsUser-defined MethodsDefined byJava LibraryProgrammerPurposeCommon operationsSpecific tasksExamplesMath.pow(), System.out.println()add(), display() #TAPAcademy #JavaProgramming #Methods #LearningJourney #InternshipExperience #JavaDeveloper #CodingJourney #ProgrammingBasics #TechLearning #LearnToCode #CodeWithJava #SoftwareDevelopment #CodingCommunity #BuildInPublic #JavaConcepts #MethodOverloading

🚀 Learning Update: Deep Dive into Java Inheritance Today’s session gave me a much clearer understanding of one of the core pillars of Object-Oriented Programming in Java — Inheritance. I learned that inheritance is the process by which one class acquires the properties and behaviors of another class. It plays a major role in code reusability, reduced development effort, and better program structure. Key concepts I learned: 🔹 Static in Java Before moving fully into inheritance, I revised the concept of static in Java: Static variables help in memory efficiency because only one copy is created for the entire class. Static blocks are used to initialize static variables and execute code before the main() method. Static methods can be called without creating objects, making them useful for class-level functionality. I also learned that static can be used with an inner class, but not with an outer class. 🔹 Inheritance in Java Inheritance allows a child class to access the fields and methods of a parent class using the extends keyword. This makes programs more structured and avoids rewriting the same logic again and again. Types of inheritance I understood: ✅ Single Inheritance – One parent and one child ✅ Multilevel Inheritance – Grandparent → Parent → Child ✅ Hierarchical Inheritance – One parent with multiple children ✅ Hybrid Inheritance – Combination of inheritance types ❌ Multiple Inheritance – Not allowed in Java because of the Diamond Problem / Ambiguity ❌ Cyclic Inheritance – Not allowed because it creates inconsistency in type hierarchy Every class in Java indirectly extends the Object class Private members do not participate in inheritance Constructors are not inherited Constructor execution between parent and child happens using constructor chaining with super() Difference between multilevel and multiple inheritance is very important 🔹 UML & Class Diagrams Another interesting takeaway was understanding how inheritance is represented using UML diagrams and how these diagrams help in the design phase of software development. This also connected with the idea of Software Development Life Cycle (SDLC), where requirement analysis and planning happen before coding begins. My takeaway: This session helped me realize that Java is not just about syntax — it is about understanding how real-world relationships are modeled in software. Strong basics in OOP concepts like inheritance are essential before moving on to polymorphism, abstraction, interfaces, exception handling, multithreading, collections, and advanced Java. Grateful for another step forward in my Java learning journey. Looking forward to learning more about constructor chaining, super keyword, and access modifiers in the next sessions. #Java #CoreJava #OOP #Inheritance #JavaProgramming #LearningJourney #SoftwareDevelopment #UML #SDLC #Programming #StudentDeveloper #CodingJourney TAP Academy

📘 Java Learning – Multithreading (Part 1: Multitasking & Thread Creation) 🚀🎯 Starting my learning journey into Java Multithreading, one of the most powerful features of Java used for executing multiple tasks simultaneously. 🔰 Multitasking Executing several tasks simultaneously is called Multitasking. There are two types of multitasking: 👉 Process Based Multitasking 👉 Thread Based Multitasking 1️⃣ Process Based Multitasking Executing several tasks simultaneously where each task is a separate independent process. Example: Running multiple applications at the same time: • Browser • Music Player • Code Editor ✔ Best suited at Operating System level 2️⃣ Thread Based Multitasking (Multithreading) Executing several tasks simultaneously where each task is an independent part of the same program. Each independent path of execution is called a Thread. ✔ Best suited for Programmatic level 🎯 Objective of Multitasking • Improve system performance • Reduce response time 📌 Applications of Multithreading Multithreading is widely used in: • Video games • Multimedia graphics • Animations • High performance applications 🔰 Multithreading Support in Java Java provides rich API support for multithreading through: • Thread • Runnable • ThreadGroup • ThreadLocal ✔ Java provides built-in APIs for multithreading, and programmers use these APIs to create and manage threads. This makes multithreading easier in Java compared to C++. 🔰 Ways to Create a Thread A thread can be defined in two ways: 1️⃣ Extending Thread class 2️⃣ Implementing Runnable interface 📌 Example – Extending Thread Class class MyThread extends Thread { public void run() { for(int i=0;i<5;i++){ System.out.println("Child Thread"); } } } public class ThreadDemo { public static void main(String[] args) { MyThread t = new MyThread(); // instantiation of thread t.start(); // starting of a thread for(int i=0;i<5;i++){ System.out.println("Main Thread"); } } } 📌 start() does NOT directly execute run(). It does: start() ↓ JVM asks Thread Scheduler ↓ New Thread Created ↓ run() executes in new thread ⭐ Key Points • start() method creates a new thread • run() contains the task executed by thread • Multiple threads execute simultaneously More concepts like Thread Scheduler, start() vs run(), Thread Lifecycle in the next post. #Java #CoreJava #Multithreading #JavaDeveloper #Concurrency #LearningJourney

🚀 Day 22 | Core Java Learning Journey 📌 Topic: Multithreading in Java Today I learned an important concept in Java — Multithreading. It helps programs perform multiple tasks simultaneously, improving performance and CPU utilization. 🔹 What is a Thread? ✔ A Thread is the smallest unit of execution within a process ✔ Multiple threads can run inside a single program ✔ Threads share the same memory but execute independently 🔹 Definition of Multithreading ✔ Multithreading is the process of executing multiple threads concurrently within a single program ✔ It improves application performance and responsiveness 🔹 Two Ways to Create Threads in Java 1️⃣ By Extending Thread Class ✔ Create a class that extends Thread ✔ Override the run() method ✔ Start execution using start() Syntax: class MyThread extends Thread { public void run() { // task } } 2️⃣ By Implementing Runnable Interface ✔ Create a class that implements Runnable ✔ Override the run() method ✔ Pass object to Thread class Syntax: class MyRunnable implements Runnable { public void run() { // task } } ✔ Runnable approach is preferred because it supports better design and flexibility. 🔹 Thread Priorities Java provides three important priority constants: ✔ MIN_PRIORITY → 1 ✔ NORM_PRIORITY → 5 (Default) ✔ MAX_PRIORITY → 10 Higher priority threads may get more CPU time, but execution order is not guaranteed. 🔹 Methods that Control / Prevent Thread Execution ✔ sleep() → Pauses thread for a specified time ✔ yield() → Temporarily pauses current thread to give chance to others ✔ join() → Makes one thread wait until another thread finishes ✔ wait() → Makes thread wait until another thread notifies it (used in synchronization) ⚠ suspend() method is deprecated because it may cause deadlocks. 🔹 Synchronization ✔ Synchronization controls access to shared resources when multiple threads run simultaneously ✔ Prevents race conditions and data inconsistency ✔ Implemented using the synchronized keyword 📌 Key Takeaways ✔ Thread → Smallest unit of execution ✔ Multithreading → Multiple threads running concurrently ✔ Threads can be created using Thread class or Runnable interface ✔ Priority affects scheduling but not guaranteed execution order ✔ Methods like sleep(), yield(), join(), wait() help manage threads ✔ Synchronization ensures safe access to shared resources Multithreading is essential for building efficient and high-performance Java applications 💻⚡ Special thanks to Vaibhav Barde Sir. #CoreJava #JavaLearning #Multithreading #JavaDeveloper #Concurrency #OOP #LearningJourney

🚀 Day 25 | Core Java Learning Journey 📌 Topic: ArrayList & LinkedList in Java Today I learned about ArrayList and LinkedList, two important classes in the Java Collections Framework that implement the Java List Interface. Both are used to store ordered collections of elements, but they use different internal data structures and have different performance characteristics. 🔹 ArrayList ✔ ArrayList is a dynamic (growable) array implementation of the List interface. ✔ It automatically resizes when elements are added or removed. ✔ It allows duplicate elements and maintains insertion order. ✔ Elements can be accessed quickly using an index. Internal Data Structure: • Uses a resizable array. 📌Key Features: ✔ Fast random access using index (get, set operations) ✔ Allows null values and duplicate elements ✔ Maintains insertion order ✔ Automatically increases capacity when needed Best Use Case: ✔ When frequent data access (reading) is required. Example Implementation: • ArrayList 🔹 LinkedList ✔ LinkedList is another implementation of the List interface. ✔ It stores elements using nodes connected through links. ✔ Each node contains data and references to other nodes. ✔ It also implements Deque, so it can be used as a queue or stack. Internal Data Structure: • Doubly Linked List Each node contains: • Data • Reference to the previous node • Reference to the next node 📌Key Features : ✔ Efficient insertion and deletion of elements ✔ Allows duplicate elements ✔ Maintains insertion order ✔ Can be used as List, Queue, or Deque 🔹Types of Linked Lists (Conceptually): • Singly Linked List – Node points to next node • Doubly Linked List – Node points to both previous and next node • Circular Linked List – Last node connects back to the first node In Java, LinkedList is implemented as a Doubly Linked List. Example Implementation: • LinkedList 📌 Key Differences ✔ ArrayList uses a dynamic array ✔ LinkedList uses a doubly linked list structure ✔ ArrayList provides faster element access ✔ LinkedList provides faster insertion and deletion 📌 Key Takeaways ✔ Both ArrayList and LinkedList implement the List interface ✔ ArrayList is best for fast access and reading data ✔ LinkedList is better for frequent insertions and deletions ✔ Choosing the right data structure improves performance and efficiency Understanding these implementations helps developers select the most suitable data structure when working with collections in Java 💻⚡ Special thanks to Vaibhav Barde Sir for explaining these concepts clearly. #CoreJava #JavaLearning #ArrayList #LinkedList #JavaCollections #JavaDeveloper #Programming #LearningJourney

🚀 Day 127 of My Java Learning Journey 🤩 Hi Friends, Today I learned how to join two lists using Stream API in Java in a clean and modern way. Instead of using loops, we can use Stream.concat() to combine two lists easily. ------------------------------------------------------------------------------------------- 💻 Code ------------> import java.util.List; import java.util.stream.Collectors; import java.util.stream.Stream; public class JoinTwoList { public static void main(String[] args) { List<Integer> list1 = List.of(1, 2, 3); List<Integer> list2 = List.of(4, 5, 6); List<Integer> joinList = Stream .concat(list1.stream(), list2.stream()) .collect(Collectors.toList()); System.out.println("Lists are Joined: " + joinList); } } ------------------------------------------------------------------------------------------- 🖥️ Output Lists are Joined: [1, 2, 3, 4, 5, 6] 🔎 Output Explanation list1.stream() converts first list into stream list2.stream() converts second list into stream Stream.concat() merges both streams Collectors.toList() converts the combined stream back into a list So both lists are joined into a single list. 📌 Important Concept 👉 Stream.concat(Stream s1, Stream s2) It is used to combine two streams into one stream. This method is very useful when working with collections in a functional programming style. 💡 Important Tip List.of() creates an immutable list. You cannot modify it (add/remove elements). If you need a modifiable list, wrap it like this: new ArrayList<>(List.of(1,2,3)); 🤔 Have You Tried This? Do you prefer: Using loops to join lists? Or using Stream API? Let me know your approach in the comments 👇 I am consistently improving my Java skills step by step. If you are also learning Java, let’s grow together 💪 #Java #JavaDeveloper #StreamAPI #Programming #CodingJourney #DevOps #BackendDevelopment #LearningEveryday #day127 #codewithyuvi #Logicalworld

🚀 Day 21 | Core Java Learning Journey 📌 Topic: Exception Handling Keywords in Java Today I learned the most important Java exception handling keywords: try, catch, finally, throw, throws — and the commonly confused finalize(). Understanding them is essential for writing clean, production-ready Java code 💡 🔹 try ✔ Wraps risky code ✔ Must be followed by catch or finally ✔ Cannot exist alone ✔ Multiple catch blocks allowed Syntax : try { // risky code } catch(Exception e) { // handling } 🔹 catch ✔ Handles exceptions from try ✔ Takes exception object as parameter ✔ Order matters (Child → Parent) ✔ Multiple catch blocks allowed 🔹 finally ✔ Always executes (whether exception occurs or not) ✔ Executes even if return statement is present ✔ Used for cleanup (files, DB, etc.) ✔ Won’t execute only if JVM crashes or System.exit() is called 🔹 throw ✔ Explicitly throws an exception ✔ Used inside method body ✔ Can throw checked & unchecked exceptions ✔ Followed by exception object throw new IllegalArgumentException("Invalid Age"); 🔹 throws ✔ Declares exception responsibility ✔ Used in method signature ✔ Mainly for checked exceptions ✔ Can declare multiple exceptions public void readFile() throws IOException { // code } 🔥 throw vs throws ✔ throw → Inside method body ✔ throws → In method declaration ✔ throw → Single exception ✔ throws → Multiple exceptions 🔹 finalize() (Important) ✔ NOT part of exception handling ✔ Belongs to Garbage Collection ✔ Defined in Object class ✔ Called before object destruction ✔ Deprecated (Java 9+) 🔥 finally vs finalize() ✔ finally → Exception handling block ✔ finalize() → GC method ✔ finally → (Almost) always runs ✔ finalize() → May or may not run 📌 Key Takeaways ✔ finally ensures cleanup ✔ throw creates exceptions ✔ throws delegates responsibility ✔ finalize() relates to memory management Small keywords — powerful concepts 💻🚀 Special thanks to Vaibhav Barde Sir . #CoreJava #JavaLearning #ExceptionHandling #JavaDeveloper #OOP #LearningJourney