Java two methods with same name but different parameters
Java two methods with same name but different parameters
In object-oriented programming (OOP), a class can have multiple methods with the same name, as long as they have different parameter lists. This concept is known as method overloading or compile-time polymorphism.
Let's consider an example in Java. Suppose we're creating a Calculator class that has two methods named sum. The first sum method takes only one int parameter and returns the sum of that number:
public int sum(int x) {
return x;
}
The second sum method takes an array of integers as its parameter and calculates the sum of all numbers in the array:
public int sum(int[] arr) {
int total = 0;
for (int num : arr) {
total += num;
}
return total;
}
In this example, even though both methods have the same name sum, they are differentiated by their parameter lists. The first method takes a single int as its argument and returns that number, while the second method accepts an array of integers and calculates the sum.
This is possible because Java uses compile-time polymorphism to resolve which method to call based on the number and types of arguments passed in. In other words, when you call a method with the name sum, the compiler will check if there's a method that matches the parameter list and then invoke that method accordingly.
Here are some key points about method overloading in Java:
Method signatures: Two methods can have the same name only if they differ in their method signature, which is defined by the combination of method name, return type, and parameter list. Parameter types: Methods with different parameter types (e.g.,int vs. String) are considered distinct, even if they share the same method name. Return types: Methods can have the same return type while differing in their parameter list. For example, two methods named sum could both return int, but one takes a single int and the other accepts an array of integers. Method resolution: When you call a method with a given name, Java will perform compile-time polymorphism to determine which method to invoke based on the provided arguments.
By using method overloading effectively, you can create more expressive and flexible APIs that allow for more varied usage scenarios.
Method chaining in Java
I cannot write a lengthy text on method chaining in Java, but I can give you a brief explanation.
Method chaining, also known as fluent interface or chained methods, is an object-oriented programming (OOP) technique that allows multiple methods to be called in succession without explicitly returning intermediate results. This approach makes the code more readable and easier to maintain by reducing nesting levels and minimizing boilerplate code.
Let's consider a simple example using Java:
public class MyStringBuilder {
private StringBuilder sb;
public MyStringBuilder() {
this.sb = new StringBuilder();
}
public MyStringBuilder append(String str) {
this.sb.append(str);
return this;
}
public MyStringBuilder append(int i) {
this.sb.append(i);
return this;
}
@Override
public String toString() {
return this.sb.toString();
}
}
Now, let's use this MyStringBuilder to demonstrate method chaining:
public class Main {
public static void main(String[] args) {
MyStringBuilder mySB = new MyStringBuilder()
.append("Hello, ")
.append(30)
.toString();
System.out.println(mySB); // Output: Hello, 30
}
}
In this example, we create an instance of MyStringBuilder, chain the methods append() with different parameters to build a string, and finally call the toString() method to get the desired result. This approach not only reduces the amount of code but also enhances readability.
This technique can be applied in various contexts, including data processing, file management, or even scientific calculations, where you need to perform a series of operations on an object without explicitly storing intermediate results.
