Pendahuluan
Metode overloading adalah teknik dalam pemrograman berorientasi objek yang memungkinkan seorang pengembang untuk memiliki beberapa metode dengan nama yang sama namun dengan parameter yang berbeda. Konsep ini sering diterapkan pada kelas, tetapi bagaimana penerapannya ketika berhubungan dengan antarmuka (interface)? Artikel ini akan membahas implementasi metode overloading pada antarmuka dengan menggunakan empat bahasa pemrograman yang mendukung fitur ini: Java, TypeScript, C# dan C++.
1. Java
Dalam Java, metode overloading dapat diterapkan pada antarmuka dengan mendefinisikan beberapa metode dengan nama yang sama tetapi parameter yang berbeda.
Java interface:
interface Calculator {
int add(int a, int b);
double add(double a, double b);
int add(int a, int b, int c);
}
Implementasi Java interface:
class SimpleCalculator implements Calculator {
@Override
public int add(int a, int b) {
return a + b;
}
@Override
public double add(double a, double b) {
return a + b;
}
@Override
public int add(int a, int b, int c) {
return a + b + c;
}
}
Contoh menggunakan Java:
public class Main {
public static void main(String[] args) {
Calculator calc = new SimpleCalculator();
System.out.println(calc.add(5, 10)); // Output: 15
System.out.println(calc.add(5.5, 10.5)); // Output: 16.0
System.out.println(calc.add(1, 2, 3)); // Output: 6
}
}
Pada contoh di atas, antarmuka `Calculator` mendefinisikan beberapa metode `add` dengan parameter yang berbeda, dan kelas `SimpleCalculator` mengimplementasikan metode-metode tersebut.
2. C#
C# juga mendukung metode overloading pada antarmuka dengan cara yang mirip dengan Java.
Implementasi menggunakan C# interface:
public interface ICalculator
{
int Add(int a, int b);
double Add(double a, double b);
int Add(int a, int b, int c);
}
Implementasi dari C# class:
public class SimpleCalculator : ICalculator
{
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;
}
}
Contoh menggunakan C#:
class Program
{
static void Main()
{
ICalculator calc = new SimpleCalculator();
Console.WriteLine(calc.Add(5, 10)); // Output: 15
Console.WriteLine(calc.Add(5.5, 10.5)); // Output: 16.0
Console.WriteLine(calc.Add(1, 2, 3)); // Output: 6
}
}
Di sini, antarmuka `ICalculator` menyediakan beberapa metode `Add`, dan kelas `SimpleCalculator` memberikan implementasi untuk setiap metode yang didefinisikan.
3. C++
Dalam C++, metode overloading dalam antarmuka dapat dilakukan dengan menggunakan pure virtual functions dalam kelas abstrak.
Berikut adalah contohnya:
class ICalculator {
public:
virtual int Add(int a, int b) = 0;
virtual double Add(double a, double b) = 0;
virtual int Add(int a, int b, int c) = 0;
};
Impelementasi dari class
class SimpleCalculator : public ICalculator {
public:
int Add(int a, int b) override {
return a + b;
}
double Add(double a, double b) override {
return a + b;
}
int Add(int a, int b, int c) override {
return a + b + c;
}
};
xxx
int main() {
SimpleCalculator calc;
std::cout << calc.Add(5, 10) << std::endl; // Output: 15
std::cout << calc.Add(5.5, 10.5) << std::endl; // Output: 16.0
std::cout << calc.Add(1, 2, 3) << std::endl; // Output: 6
return 0;
}
Di sini, `ICalculator` adalah kelas abstrak dengan metode virtual murni, yang memungkinkan metode overloading pada kelas `SimpleCalculator`.
4. TypeScript
TypeScript, sebagai bahasa yang mengkompilasi ke JavaScript, juga mendukung metode overloading. Berikut adalah contoh penerapan metode overloading pada interface di TypeScript:
interface Calculator {
add(a: number, b: number): number;
add(a: number, b: number, c: number): number;
add(a: number, b: number, c?: number): number;
}
class SimpleCalculator implements Calculator {
add(a: number, b: number, c?: number): number {
if (c !== undefined) {
return a + b + c;
} else {
return a + b;
}
}
}
const calc = new SimpleCalculator();
console.log(calc.add(5, 10)); // Output: 15
console.log(calc.add(1, 2, 3)); // Output: 6
Di sini, antarmuka `Calculator` mendefinisikan beberapa overload untuk metode `add`, dan `SimpleCalculator` mengimplementasikan metode tersebut dengan memeriksa apakah parameter opsional `c` diberikan.
Kesimpulan
Metode overloading pada antarmuka adalah konsep yang kuat dan berguna dalam pemrograman berorientasi objek, memungkinkan fleksibilitas dalam desain API. Berbagai bahasa pemrograman seperti Java, C#, C++, dan TypeScript menyediakan cara untuk menerapkan metode overloading dalam antarmuka, masing-masing dengan sintaks dan aturan yang sedikit berbeda. Memahami cara menerapkan teknik ini di berbagai bahasa dapat membantu pengembang membuat antarmuka yang lebih fleksibel dan mudah digunakan.