Operatorüberladung in Java
In diesem Artikel wird erläutert, ob Java das Überladen von benutzerdefinierten Operatoren unterstützt oder nicht.
Operatorüberladung in Java
Durch das Überladen von Operatoren können Operatoren in benutzerdefinierten Typen implementiert werden. Es verwendet angepasste Logik basierend auf dem Typ und der Anzahl der übergebenen Argumente.
Durch das Überladen von Operatoren können wir eine benutzerdefinierte Operationsimplementierung spezifizieren. Syntaktischer Zucker ist ein anderer Begriff dafür. Die an der Operation beteiligten Operatoren können vom Strukturtyp oder einer benutzerdefinierten Klasse sein.
Beispielsweise ist die Verwendung eines Plus-Operators + zum Addieren von zwei Zahlen und zum Verketten von zwei Zeichenketten der einfachste Fall einer Operatorüberladung.
Java unterstützt jedoch das Überladen von Operatoren nicht, außer in einem Fall, der Zeichenkettenverkettung mit dem Plus-Operator.
Hier ist das vollständige Beispiel.
import java.util.Scanner;
public class OperatorOverloading {
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
// Input the first string
System.out.println("Enter a string");
String s1 = sc.next();
// Input the second string
System.out.println("Enter another string: ");
String s2 = sc.next();
// Plus operator concatenates the two Strings
System.out.println(s1 + ' ' + s2);
// Input the first integer
System.out.println("Enter a number");
int x = sc.nextInt();
// Input the second integer
System.out.println("Enter another number");
int y = sc.nextInt();
// Plus operator adds the two numbers
System.out.println(x + y);
}
}
Ausgabe:
Enter a string
Hello
Enter another string:
World
Hello World
Enter a number
3
Enter another number
4
7
In diesem Beispiel addiert der Plus-Operator die beiden Ganzzahlen und verkettet die beiden Zeichenketten. Es ist die einzige Operatorüberladung, die Java unterstützt.
Abgesehen davon unterstützt Java kein benutzerdefiniertes Überladen von Operatoren. Der einzige Teil von Java, der dem Überladen von Operatoren nahe kommt, ist die Behandlung von + zum Verketten von Zeichenketten.
Dies führt zur Kompilierzeitverkettung von Konstanten oder zur Laufzeitverkettung. In Java können wir jedoch unsere Operatoren nicht definieren, die sich so verhalten.
Obwohl wir Strings in Java mit dem Plus-Operator verketten können, hat Java eine eingebaute concat()-Methode, die das Überladen von Operatoren überflüssig macht. Die Methode concat() hängt einen weiteren String am Ende eines gegebenen Strings an.
Wir sollten die Zeichenketten angeben, um die kombinierte Zeichenfolge in der gewünschten Reihenfolge zu erhalten.
Syntax:
String resultant = String1.concat(String2)
Die zweite Zeichenfolge wird am Ende der ersten Zeichenfolge hinzugefügt. Das folgende Beispiel verwendet die Methode concat(), um zwei Strings zusammenzusetzen.
import java.util.Scanner;
public class OperatorOverloading {
public static void main(String args[]) {
Scanner sc = new Scanner(System.in);
System.out.println("Enter a string:");
String s1 = sc.next();
System.out.println("Enter another string:");
String s2 = sc.next();
// Concatenate the two strings using concat() method
String res = s1.concat(s2);
System.out.println(res);
}
}
Ausgabe:
Enter a string:
Hello
Enter another string:
World
HelloWorld
Beachten Sie, dass wir hier nicht den Plus-Operator für die String-Verkettung verwenden und die beiden Strings dennoch mit Hilfe der concat()-Methode kombinieren können.
Gründe, warum Java das Überladen von Operatoren nicht unterstützt
Wir können die meisten eingebauten Operatoren in C++ neu definieren, aber nicht in Java. Dies hat folgende Gründe.
- Das Überladen von Operatoren erhöht die Codekomplexität. Wenn wir einen Operator in Java überladen, muss die Java Virtual Machine (JVM) in Java zusätzliche Anstrengungen unternehmen, um die tatsächliche Funktionalität des in einer bestimmten Anweisung verwendeten Operators herauszufinden. Das macht die Verarbeitung ziemlich komplex.
- Das Überladen von Operatoren führt zu Fehlern im Programm. Das Überladen von Operatoren führt zu Verwirrung unter Programmierern. Außerdem besteht beim Arbeiten mit Sprachen, die das Überladen von Operatoren unterstützen, im Vergleich zu anderen Sprachen die Möglichkeit von Fehlern. Java hat Methodenüberladung. Das Überladen von Methoden dient der Funktionalität des Überladens von Operatoren und eliminiert den Spielraum für Fehler.
- Java unterstützt das Überladen von Methoden. Das Überladen von Methoden ist das Konzept einer Klasse, die mehr als eine einzelne Methode mit demselben Namen, aber unterschiedlichen Parametern hat. Hier ist die Identifizierung der anzuwendenden Methode einfacher. Sie hängt von der Anzahl der Argumente oder dem Datentyp der Argumente ab.
Sehen wir uns ein Beispiel an.
import java.util.*;
// The class which has two methods
class DemoClass {
// This method takes two arguments
static int demo(int a, int b) {
return a + b;
}
// This method takes three arguments
static int demo(int a, int b, int c) {
return a * b * c;
}
}
class MethodOverloading {
public static void main(String[] args) {
// Passing two arguments
System.out.println(DemoClass.demo(10, 12));
// Passing three arguments
System.out.println(DemoClass.demo(11, 10, 10));
}
}
Ausgabe:
22
1100
Die Klasse DemoClass hat zwei gleichnamige Methoden, im obigen Beispiel demo. Diese beiden Methoden benötigen jedoch eine unterschiedliche Anzahl von Argumenten.
Wenn wir zwei Argumente übergeben, tritt die erste Demo-Methode in Aktion, und wenn wir drei Argumente übergeben, tritt die zweite Demo-Methode in Aktion. So funktioniert das Überladen von Methoden in Java.
Um die Sprache einfach zu halten, haben die Java-Entwickler die Funktion zum Überladen von Operatoren nicht bereitgestellt. Jeder Operator hat eine Bedeutung, die wir je nach Anforderung des Entwicklers ändern können.
Es führt zu Verwirrung, wenn mehrere Personen an demselben Projekt arbeiten. Die Java-Designer haben das Überladen von Operatoren in Java vermieden, um die Verwendung von Operatoren zu vermeiden. Es macht Java zu einer einfach zu implementierenden Sprache.
Einige Java-ähnliche Sprachen, auch bekannt als JVM-basierte Sprachen, unterstützen das Überladen von Operatoren. Dazu gehören Groovy und Kotlin.
Kotlin wurde von Jetbrains entwickelt und ist eine hochrangige und statisch typisierte Sprache. Es läuft auf der Java Virtual Machine oder JVM und kann sogar in Javascript-Quellcode kompiliert werden.
Einer der wichtigsten Fortschritte von Kotlin gegenüber Java ist, dass Kotlin im Gegensatz zu Java das Überladen von Operatoren unterstützt.
Andererseits unterstützt Groovy sowohl statische als auch dynamische Typisierung und kompiliert zu Java Virtual Machine ByteCode. Groovy unterstützt auch das Überladen von Operatoren.
Fazit
Als Antwort darauf, ob Java das Überladen von Operatoren unterstützt oder nicht, unterstützt Java das Überladen von Operatoren nicht. Nur ein Teil von Java ähnelt diesem Konzept: die String-Verkettung mit dem Plus-Operator.
Abgesehen davon können Sie in Java Ihre Operatoren nicht definieren. Einige andere JVM-basierte Sprachen wie Java unterstützen jedoch das Überladen von Operatoren.
Dazu gehören Groovy und Kotlin. Aber diese sind nicht dasselbe wie Java.