Update README.md

Author: Pankaj-Str

Day_17_MethodOverriding/README.md

@@ -1,54 +1,152 @@
-# Java Method Overriding
+# Java Method Overloading
 
-Method overriding is a fundamental concept in Java's object-oriented programming (OOP) that allows a subclass to provide a specific implementation of a method that is already defined in its superclass. When a subclass defines a method with the same name, return type, and parameters as a method in its superclass, it is said to be overriding that method.
+**Tutorial Name**: Codes with Pankaj  
+**Website**: www.codeswithpankaj.com
 
-Here are the key points to understand about method overriding in Java:
+#### Introduction to Method Overloading in Java
 
-1. **Inheritance**: Method overriding is closely related to inheritance. It enables a subclass to inherit a method from its superclass and then customize or extend its behavior.
+Method overloading is one of the most fundamental features in Java that allows a class to have more than one method with the same name. This is possible by varying the method parameters. The difference in the number of parameters or the type of parameters allows the Java compiler to differentiate between the methods, despite having the same name. 
 
-2. **Rules for Method Overriding**:
-   - The method in the subclass must have the same method signature (i.e., the same name, return type, and parameter list) as the method in the superclass.
-   - The access level of the overriding method cannot be more restrictive than the access level of the overridden method. It can be the same or less restrictive.
-   - The overriding method cannot throw checked exceptions that are broader than the exceptions thrown by the overridden method. However, it can throw narrower or unchecked exceptions.
-   - The `@Override` annotation is optional but recommended for clarity. It helps you ensure that you are indeed overriding a method from the superclass.
+This feature helps in increasing the readability and reusability of the code, as you can perform similar tasks using the same method name but with different inputs.
 
-3. **Use Cases for Method Overriding**:
-   - Polymorphism: Method overriding is a key mechanism for achieving polymorphism in Java. It allows you to write code that can work with objects of different subclasses through a common interface.
-   - Customization: Subclasses can provide specialized implementations of methods to meet their specific needs.
-   - Extension: Subclasses can extend the behavior of their superclass by adding additional functionality to overridden methods.
+---
 
-Here's an example of method overriding in Java:
+#### Key Concepts of Method Overloading
+
+1. **Method Signature**: A method signature in Java consists of the method's name and its parameter list (number, type, and order of parameters). For method overloading to occur, the method signatures must differ.
+   
+2. **Return Type**: In method overloading, the return type of methods can be the same or different. However, the return type alone is not enough to distinguish between overloaded methods.
+
+3. **Parameter Variation**: Methods can be overloaded by changing the:
+   - **Number of parameters**: Methods with the same name but different numbers of parameters.
+   - **Type of parameters**: Methods with the same name but different data types for parameters.
+   - **Order of parameters**: Methods with the same name but different sequences of data types in the parameter list.
+
+---
+
+#### Example 1: Overloading by Number of Parameters
 
 ```java
-class Shape {
-    void draw() {
-        System.out.println("Drawing a shape");
+public class CodesWithPankaj {
+    // Method with two parameters
+    public int add(int a, int b) {
+        return a + b;
     }
-}
 
-class Circle extends Shape {
-    @Override
-    void draw() {
-        System.out.println("Drawing a circle");
+    // Overloaded method with three parameters
+    public int add(int a, int b, int c) {
+        return a + b + c;
     }
-}
 
-class Rectangle extends Shape {
-    @Override
-    void draw() {
-        System.out.println("Drawing a rectangle");
+    public static void main(String[] args) {
+        CodesWithPankaj obj = new CodesWithPankaj();
+        System.out.println("Sum of two numbers: " + obj.add(10, 20)); // Calls first method
+        System.out.println("Sum of three numbers: " + obj.add(10, 20, 30)); // Calls second method
     }
 }
+```
+
+**Explanation**:
+- The method `add(int a, int b)` is overloaded with another method `add(int a, int b, int c)`. 
+- The first method adds two numbers, and the second method adds three numbers. 
+- The Java compiler differentiates the methods based on the number of parameters passed during method invocation.
+
+---
+
+#### Example 2: Overloading by Type of Parameters
+
+```java
+public class CodesWithPankaj {
+    // Method to add two integers
+    public int add(int a, int b) {
+        return a + b;
+    }
+
+    // Overloaded method to add two double values
+    public double add(double a, double b) {
+        return a + b;
+    }
 
-public class MethodOverridingExample {
     public static void main(String[] args) {
-        Shape shape1 = new Circle();
-        Shape shape2 = new Rectangle();
+        CodesWithPankaj obj = new CodesWithPankaj();
+        System.out.println("Sum of two integers: " + obj.add(10, 20)); // Calls first method
+        System.out.println("Sum of two doubles: " + obj.add(10.5, 20.5)); // Calls second method
+    }
+}
+```
+
+**Explanation**:
+- Here, the method `add(int a, int b)` is overloaded with `add(double a, double b)`.
+- The first method handles integer addition, while the second method handles double addition.
+- The Java compiler uses the data type of the arguments to determine which method to invoke.
+
+---
 
-        shape1.draw(); // Calls the draw method in Circle
-        shape2.draw(); // Calls the draw method in Rectangle
+#### Example 3: Overloading by Order of Parameters
+
+```java
+public class CodesWithPankaj {
+    // Method with int and double as parameters
+    public void display(int a, double b) {
+        System.out.println("Integer: " + a + ", Double: " + b);
+    }
+
+    // Overloaded method with double and int as parameters
+    public void display(double a, int b) {
+        System.out.println("Double: " + a + ", Integer: " + b);
+    }
+
+    public static void main(String[] args) {
+        CodesWithPankaj obj = new CodesWithPankaj();
+        obj.display(10, 20.5); // Calls first method
+        obj.display(20.5, 10); // Calls second method
     }
 }
 ```
 
-In this example, `Circle` and `Rectangle` are subclasses of `Shape` and override the `draw()` method to provide their own implementations. Polymorphism is demonstrated when we create objects of the subclasses and call the `draw()` method on them. The appropriate overridden method is invoked based on the actual object type.
+**Explanation**:
+- In this example, the `display` method is overloaded by changing the order of parameters.
+- The first method takes an `int` followed by a `double`, and the second method takes a `double` followed by an `int`.
+- The Java compiler differentiates between the two methods based on the order in which the parameters are passed.
+
+---
+
+#### Rules and Considerations for Method Overloading
+
+1. **Cannot overload by return type alone**: The return type of methods does not play a role in method overloading. If two methods have the same name and parameters but different return types, it will result in a compile-time error.
+
+2. **Method Name and Parameters Must Be Different**: The method name should be the same, but the parameters must be different in some way (either by number, type, or order).
+
+3. **Automatic Type Promotion**: Java may promote one data type to another during method calls (e.g., int to float). This can sometimes lead to ambiguity if not handled carefully.
+
+4. **Performance Considerations**: Overloading methods provide flexibility but could also affect performance if not designed properly, as the JVM needs to determine the correct method at runtime.
+
+---
+
+#### Practical Use Cases of Method Overloading
+
+- **Constructor Overloading**: Often used in constructors to provide different ways to instantiate an object.
+- **Mathematical Operations**: Overloading methods like `add`, `subtract`, or `multiply` for handling various data types (e.g., `int`, `float`, `double`).
+- **Input Handling**: Different methods for handling various types of inputs (e.g., accepting strings, integers, or files).
+
+---
+
+#### Conclusion
+
+Method overloading is a powerful feature in Java that enhances code readability and reusability by allowing multiple methods with the same name but different parameters. It is widely used in real-world applications to handle various types of input and provide multiple ways to perform similar operations.
+
+In your coding journey, make sure to use method overloading when appropriate to keep your code clean, efficient, and user-friendly.
+
+---
+
+**Example Practice Questions**:
+
+1. Write a program in Java to overload a method that calculates the area of different shapes (circle, rectangle, and triangle).
+2. Create a class with overloaded methods for calculating the sum of two, three, and four numbers. Test the class with sample data.
+3. Explain why Java does not allow method overloading based solely on the return type of a method.
+
+---
+
+**References**:
+- For more examples and tutorials, visit www.codeswithpankaj.com
+