What is a Method?

In Java, a method is a block of code which only runs when it is called. It's essentially a function that performs a specific task. Methods are crucial for breaking down complex problems into smaller, manageable, and reusable units.

Methods in Java

Methods enable you to organize your code, make it more readable, and avoid repetition. They promote the principle of "Don't Repeat Yourself" (DRY).

Anatomy of a Method

 // Basic Method Structure
            accessModifier returnType methodName(parameterList) {
                // Method body (code to be executed)
                return returnValue; // If the returnType is not void
            } 

• accessModifier: Determines the visibility of the method (e.g., `public`, `private`, `protected`, or default (package-private)).
• returnType: Specifies the data type of the value the method returns. If the method doesn't return a value, the return type is `void`.
• methodName: The identifier (name) of the method. Should be descriptive and follow Java naming conventions (camelCase).
• parameterList: A comma-separated list of parameters the method accepts. Each parameter consists of a data type and a variable name.
• methodBody: The code block enclosed in curly braces `{}` that contains the instructions the method executes.
• returnValue: (Optional) If the `returnType` is not `void`, the method must return a value of the specified type using the `return` keyword.

Parameters and Return Types

Methods can accept input values (parameters) and produce output values (return values).

Parameters

Parameters are variables declared within the parentheses of a method declaration. They allow you to pass data into the method.

• Formal Parameters: The parameters listed in the method's declaration are called formal parameters.
• Actual Parameters (Arguments): The values you pass to the method when you call it are called actual parameters or arguments.

 public class Example {
                public static int add(int a, int b) { // a and b are formal parameters
                    return a + b;
                }

                public static void main(String[] args) {
                    int x = 5;
                    int y = 3;
                    int sum = add(x, y); // x and y are actual parameters (arguments)
                    System.out.println("Sum: " + sum); // Output: Sum: 8
                }
            } 

Return Types

A method's return type specifies the data type of the value it returns after execution. If a method doesn't return a value, its return type is `void`.

 public class Example {
                public static double calculateArea(double radius) {
                    return Math.PI * radius * radius; // Returns a double (the area)
                }

                public static void greet(String name) { // Void method (no return value)
                    System.out.println("Hello, " + name + "!");
                }

                public static void main(String[] args) {
                    double area = calculateArea(5.0);
                    System.out.println("Area: " + area); // Output: Area: 78.53981633974483

                    greet("Alice"); // Output: Hello, Alice!
                }
            } 

Method Overloading

Method overloading allows you to define multiple methods with the same name in the same class, as long as they have different parameter lists. The Java compiler determines which method to call based on the number, types, and order of the arguments passed during the method call. This is a form of compile-time polymorphism.

Rules for Method Overloading

• Methods must have the same name.
• Methods must have different parameter lists:
  • Different number of parameters.
  • Different data types of parameters.
  • Different order of parameters.
• Return type alone is not sufficient to overload methods.
• Access modifiers alone are not sufficient to overload methods.

 public class Calculator {
                public int add(int a, int b) {
                    return a + b;
                }

                public double add(double a, double b) {
                    return a + b;
                }

                public int add(int a, int b, int c) {
                    return a + b + c;
                }

                public String add(String a, String b) {
                    return a + b;
                }

                public static void main(String[] args) {
                    Calculator calc = new Calculator();

                    System.out.println(calc.add(2, 3));       // Output: 5
                    System.out.println(calc.add(2.5, 3.7));   // Output: 6.2
                    System.out.println(calc.add(1, 2, 3));    // Output: 6
                    System.out.println(calc.add("Hello, ", "World!")); // Output: Hello, World!
                }
            } 

Why Use Method Overloading?

• Code Reusability: You can reuse the same method name for similar operations with different data types or input parameters.
• Readability: Makes the code more readable and easier to understand.
• Flexibility: Provides flexibility in how you call methods, accommodating various input scenarios.

More Examples

Example 1: Finding the Maximum of Two Numbers

 public class MaxFinder {
                public static int max(int a, int b) {
                    return (a > b) ? a : b;
                }

                public static double max(double a, double b) {
                    return (a > b) ? a : b;
                }

                public static void main(String[] args) {
                    System.out.println("Max of 5 and 10: " + max(5, 10));    // Output: Max of 5 and 10: 10
                    System.out.println("Max of 3.14 and 2.71: " + max(3.14, 2.71)); // Output: Max of 3.14 and 2.71: 3.14
                }
            } 

Example 2: Calculating the Area of Different Shapes

 public class AreaCalculator {
                public static double area(double radius) { // Circle
                    return Math.PI * radius * radius;
                }

                public static double area(double length, double width) { // Rectangle
                    return length * width;
                }

                public static double area(int side) { // Square
                    return side * side;
                }


                public static void main(String[] args) {
                    System.out.println("Area of circle with radius 5: " + area(5.0)); // Output: Area of circle with radius 5: 78.53981633974483
                    System.out.println("Area of rectangle with length 4 and width 6: " + area(4.0, 6.0)); // Output: Area of rectangle with length 4 and width 6: 24.0
                    System.out.println("Area of square with side 3: " + area(3)); // Output: Area of square with side 3: 9.0
                }
            }