Can you explain the following concepts in Java in plain word and provide a easy-to-understand example code to illustratePass-by-value Pass-by-referenceF RecursionG Overloading

A. Pass-by-value: When you pass a variable as an argument to a method, the method creates a copy of the value of that variable and works with that copy. This means that any changes made to the variable inside the method do not affect the original variable outside the method.

Example code:

public static void main(String[] args) {
  int x = 5;
  changeValue(x);
  System.out.println(x); // Output: 5
}

public static void changeValue(int num) {
  num = 10;
}

In this example, we create a variable x with a value of 5. We then call the changeValue method and pass x as an argument. Inside the method, we change the value of num to 10. However, when we print out the value of x outside the method, it is still 5. This is because the method only worked with a copy of the value of x.

B. Pass-by-reference: When you pass an object as an argument to a method, the method works with the same object that was passed in, rather than a copy of it. This means that any changes made to the object inside the method will affect the original object outside the method.

Example code:

public static void main(String[] args) {
  ArrayList<String> list = new ArrayList<>();
  list.add("apple");
  list.add("banana");
  changeList(list);
  System.out.println(list); // Output: [orange, banana]
}

public static void changeList(ArrayList<String> arr) {
  arr.set(0, "orange");
}

In this example, we create an ArrayList called list with two elements: "apple" and "banana". We then call the changeList method and pass list as an argument. Inside the method, we change the first element of arr to "orange". When we print out list outside the method, it now contains "orange" and "banana", because the method worked with the original list.

C. Recursion: Recursion is a technique in which a method calls itself repeatedly until a certain condition is met. This can be useful for solving problems that can be broken down into smaller, similar sub-problems.

Example code:

public static int factorial(int n) {
  if (n == 1) {
    return 1;
  } else {
    return n * factorial(n - 1);
  }
}

In this example, we create a method called factorial that takes an integer n. If n is equal to 1, we return 1. Otherwise, we return n multiplied by the result of calling factorial with n - 1. This means that factorial(5) would call itself with factorial(4), which would call itself with factorial(3), and so on, until it reaches factorial(1) and returns 1. The final result would be 5 * 4 * 3 * 2 * 1 = 120.

D. Overloading: Overloading is when a class has two or more methods with the same name but different parameters. This allows you to perform different operations with the same method name, depending on the arguments that are passed in.

Example code:

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

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

In this example, we create two methods called add. One takes two integers and returns their sum, while the other takes two doubles and returns their sum. This allows us to use the same method name for addition operations on both integers and doubles. For example, we could call add(2, 3) and get 5, or call add(2.5, 3.5) and get 6.0.