methods-and-functions

Author: shreyyq

docs/java/methods-and-functions/method-declaration-and-syntax.md

@@ -5,4 +5,38 @@ sidebar_label: Method Declaration and Syntax
 sidebar_position: 1
 tags: [java, methods, functions, programming, java methods, java functions]
 description: In this tutorial, we will learn about methods and functions in Java. We will learn about what methods are, how to declare and define methods, and how to call methods in Java.
----
+---
+
+
+# Method Declaration and Syntax in Java
+
+## Introduction
+
+Methods in Java are blocks of code that perform a specific task and can be called upon whenever needed. They help in organizing code, improving reusability, and making programs more modular and maintainable.
+
+## Method Declaration
+
+A method declaration in Java defines a method's name, return type, and parameters. Here's the basic syntax for declaring a method:
+
+### Syntax
+
+```java
+accessModifier returnType methodName(parameters) {
+    // method body
+}
+```
+
+### Example
+
+```java
+public int add(int a, int b) {
+    return a + b;
+}
+```
+
+### Explanation
+
+- **Access Modifier**: Defines the visibility of the method. Common access modifiers include `public`, `private`, `protected`, and the default (package-private).
+- **Return Type**: Specifies the type of value the method returns. If the method does not return any value, use `void`.
+- **Method Name**: The name of the method. It should be a valid identifier and follow camelCase naming convention.
+- **Parameters**: A comma-separated list of input parameters. Each parameter consists of a data type and a variable name.

docs/java/methods-and-functions/method-overloading-and-recursion.md

@@ -3,6 +3,141 @@ id: method-overloading-and-recursion
 title: Method Overloading and Recursion
 sidebar_label: Method Overloading and Recursion
 sidebar_position: 3
-tags: [java, methods, functions, programming, java methods, java functions, method overloading, recursion]
+tags:
+  [
+    java,
+    methods,
+    functions,
+    programming,
+    java methods,
+    java functions,
+    method overloading,
+    recursion,
+  ]
 description: In this tutorial, we will learn about method overloading and recursion in Java. We will learn about what method overloading is, how to overload methods in Java, and how to use recursion to solve problems in Java.
----
+---
+
+# Method Overloading and Recursion in Java
+
+## Introduction
+
+Methods are an essential part of Java programming. Understanding advanced concepts like method overloading and recursion can help you write more efficient and flexible code.
+
+## Method Overloading
+
+Method overloading allows multiple methods with the same name but different parameters to coexist within a class. It is a way to define multiple methods that do similar things but with different input parameters.
+
+### Syntax
+
+```java
+returnType methodName(parameterList1) {
+    // method body
+}
+
+returnType methodName(parameterList2) {
+    // method body
+}
+```
+
+### Example
+
+```java
+public class Main {
+    public static void main(String[] args) {
+        Main obj = new Main();
+
+        System.out.println(obj.add(5, 3));         // Calls add(int, int)
+        System.out.println(obj.add(2.5, 3.7));     // Calls add(double, double)
+        System.out.println(obj.add("Hello", "World")); // Calls add(String, String)
+    }
+
+    public int add(int a, int b) {
+        return a + b;
+    }
+
+    public double add(double a, double b) {
+        return a + b;
+    }
+
+    public String add(String a, String b) {
+        return a + " " + b;
+    }
+}
+```
+
+### Points to Remember
+
+- Overloaded methods must have different parameter lists (number or type of parameters).
+- Overloaded methods can have different return types, but the return type alone is not sufficient to distinguish overloaded methods.
+- Overloaded methods can have different access modifiers and throw different exceptions.
+
+## Recursion
+
+Recursion is a programming technique where a method calls itself to solve a problem. It is useful for problems that can be broken down into smaller, similar subproblems.
+
+### Syntax
+
+```java
+returnType methodName(parameters) {
+    if (baseCondition) {
+        // base case to stop recursion
+        return baseResult;
+    } else {
+        // recursive case
+        return methodName(modifiedParameters);
+    }
+}
+```
+
+### Example: Factorial Calculation
+
+```java
+public class Main {
+    public static void main(String[] args) {
+        Main obj = new Main();
+        int number = 5;
+        int result = obj.factorial(number);
+        System.out.println("Factorial of " + number + " is " + result);
+    }
+
+    public int factorial(int n) {
+        if (n <= 1) {
+            return 1;
+        } else {
+            return n * factorial(n - 1);
+        }
+    }
+}
+```
+
+### Example: Fibonacci Series
+
+```java
+public class Main {
+    public static void main(String[] args) {
+        Main obj = new Main();
+        int number = 10;
+        for (int i = 0; i < number; i++) {
+            System.out.print(obj.fibonacci(i) + " ");
+        }
+    }
+
+    public int fibonacci(int n) {
+        if (n <= 1) {
+            return n;
+        } else {
+            return fibonacci(n - 1) + fibonacci(n - 2);
+        }
+    }
+}
+```
+
+### Points to Remember
+
+- A recursive method must have a base case to terminate the recursion and prevent infinite loops.
+- Recursive solutions are often more elegant but may be less efficient due to repeated calculations and function call overhead.
+- Consider the stack depth and memory usage when using recursion, as deep recursion can lead to `StackOverflowError`.
+
+## Conclusion
+
+Method overloading and recursion are powerful concepts in Java that enhance the flexibility and functionality of your code. Method overloading allows you to define multiple methods with the same name but different parameters, improving code readability and reusability. Recursion enables you to solve complex problems by breaking them down into simpler subproblems, though it requires careful handling to ensure termination and efficiency.

docs/java/methods-and-functions/method-parameters-and-return-values.md

@@ -5,4 +5,85 @@ sidebar_label: Method Parameters and Return Values
 sidebar_position: 2
 tags: [java, methods, functions, programming, java methods, java functions, method parameters, return values]
 description: In this tutorial, we will learn about method parameters and return values in Java. We will learn about how to define methods with parameters and return values, how to call methods with arguments, and how to handle return values from methods in Java.
----
+---
+
+
+## Method Example
+
+Here are a few examples to illustrate different types of methods:
+
+### Method with No Parameters and No Return Value
+
+```java
+public void printHello() {
+    System.out.println("Hello, World!");
+}
+```
+
+### Method with Parameters and a Return Value
+
+```java
+public int multiply(int x, int y) {
+    return x * y;
+}
+```
+
+### Method with No Parameters but a Return Value
+
+```java
+public String getGreeting() {
+    return "Hello, Java!";
+}
+```
+
+### Method with Multiple Parameters
+
+```java
+public double calculateArea(double width, double height) {
+    return width * height;
+}
+```
+
+## Calling Methods
+
+To call a method, use the method name followed by parentheses. If the method requires parameters, provide the appropriate arguments within the parentheses.
+
+### Example
+
+```java
+public class Main {
+    public static void main(String[] args) {
+        Main obj = new Main();
+        
+        // Calling a method with no parameters and no return value
+        obj.printHello();
+        
+        // Calling a method with parameters and a return value
+        int result = obj.add(5, 3);
+        System.out.println("Sum: " + result);
+        
+        // Calling a method with no parameters but a return value
+        String greeting = obj.getGreeting();
+        System.out.println(greeting);
+        
+        // Calling a method with multiple parameters
+        double area = obj.calculateArea(5.5, 4.0);
+        System.out.println("Area: " + area);
+    }
+    
+    public void printHello() {
+        System.out.println("Hello, World!");
+    }
+
+    public int add(int a, int b) {
+        return a + b;
+    }
+
+    public String getGreeting() {
+        return "Hello, Java!";
+    }
+
+    public double calculateArea(double width, double height) {
+        return width * height;
+    }
+}