Respuestas:
No, Java no admite la sobrecarga del operador definido por el usuario. El único aspecto de Java que se acerca a la sobrecarga del operador "personalizado" es el manejo de + para cadenas, que da como resultado la concatenación de constantes en tiempo de compilación o la concatenación en tiempo de ejecución usando StringBuilder / StringBuffer. Sin embargo, no puede definir sus propios operadores que actúen de la misma manera.
Para un lenguaje similar a Java (y basados en JVM), que hace la sobrecarga de operadores de apoyo, usted podría mirar a Kotlin o maravilloso . Alternativamente, puede encontrar suerte con una solución de complemento del compilador de Java .
BigIntegeren Java, luego mire código similar usando BigIntegeren C # usando operadores. No veo cómo los delegados rompen los principios de OOP: debe ser mucho más preciso que eso en sus objeciones. No conozco los detalles de por qué los diseñadores de Java no incluyeron varias características, pero sospecho que hay una mezcla de presión de recursos y un deseo de mantener el lenguaje pequeño y relativamente simple.
m0como Matrixy v0, v1, v2, v3, y v4como Vectors, basta con comparar el tiempo que le lleva a correctamente interpretar la siguiente expresión matemática m0.transpose().mult(v0.add(v1.mult(v2)).cross(v3)).sub(v4);. Si se hubiera incluido el soporte para la sobrecarga del operador, podría haberse escrito como m0.transpose() * (v0 + v1 * v2).cross(v3) - v4;.
Además de todas las personas que señalan que +está sobrecargado para Strings, -también está sobrecargado para operaciones de punto flotante y entero, como son *y /.
[editar]
%también está sobrecargado para punto flotante, lo que puede ser un poco sorprendente para aquellos con un fondo C o C ++.
Java no permite la sobrecarga del operador. El enfoque preferido es definir un método en su clase para realizar la acción: en a.add(b)lugar de a + b. Puede ver un resumen de los otros bits que Java dejó de los lenguajes similares a C aquí: Características eliminadas de C y C ++
No puede hacerlo usted mismo, ya que Java no permite la sobrecarga del operador.
Con una excepción, sin embargo. + y + = están sobrecargados para los objetos String.
&, |y ^son sobrecarga para booleany tipos integrales. Y, de hecho, los operadores aritméticos y relacionales están sobrecargados para varios tipos numéricos. (Por supuesto, la semántica de las sobrecargas está mucho más cerca ...)
Como muchos otros han respondido: Java no admite la sobrecarga del operador definido por el usuario.
Quizás esto esté fuera de tema, pero quiero comentar algunas cosas que leí en algunas respuestas.
Sobre la legibilidad.
Comparar:
¡Mirar de nuevo!
¿Cuál es más legible?
Un lenguaje de programación que permita la creación de tipos definidos por el usuario, debería permitirles actuar de la misma manera que los tipos incorporados (o tipos primitivos).
Entonces, Java rompe un principio fundamental de la Programación Genérica:
Deberíamos poder intercambiar objetos de tipos incorporados con objetos de tipos definidos por el usuario.
(Quizás se esté preguntando: "¿Dijo 'objetos incorporados'?". Sí, vea aquí ).
Sobre la concatenación de cadenas:
Los matemáticos usan el símbolo + para operaciones conmutativas en conjuntos.
Entonces podemos estar seguros de que a + b = b + a.
La concatenación de cadenas (en la mayoría de los lenguajes de programación) no respeta esta notación matemática común.
a := "hello"; b := "world"; c := (a + b = b + a);
o en Java:
String a = "hello"; String b = "world"; boolean c = (a + b).equals(b + a);
Extra:
Observe cómo en Java se confunden igualdad e identidad. El símbolo == (igualdad) significa:
a. Igualdad para los tipos primitivos.
si. Verificación de identidad para tipos definidos por el usuario, por lo tanto, nos vemos obligados a usar la función equals () para igualdad.
Pero ... ¿Qué tiene esto que ver con la sobrecarga del operador?
Si el lenguaje permite que el operador sobrecargue, el usuario podría darle el significado apropiado al operador de igualdad.
==se usa para la igualdad en Java, como en C y C ++. Esto no tiene nada que ver con la sobrecarga del operador.
Uno puede probar la sobrecarga del operador de Java . Tiene sus propias limitaciones, pero vale la pena intentarlo si realmente desea utilizar la sobrecarga del operador.
Simplemente use Xtend junto con su código Java. Soporta sobrecarga del operador:
package com.example;
@SuppressWarnings("all")
public class Test {
protected int wrapped;
public Test(final int value) {
this.wrapped = value;
}
public int operator_plus(final Test e2) {
return (this.wrapped + e2.wrapped);
}
}
package com.example
class Test2 {
new() {
val t1 = new Test(3)
val t2 = new Test(5)
val t3 = t1 + t2
}
}¡En el sitio web oficial, hay una lista de los métodos a implementar para cada operador!
O bien, puede hacer Java Groovy y simplemente sobrecargar estas funciones para lograr lo que desea
//plus() => for the + operator
//multiply() => for the * operator
//leftShift() = for the << operator
// ... and so on ...
class Fish {
def leftShift(Fish fish) {
print "You just << (left shifted) some fish "
}
}
def fish = new Fish()
def fish2 = new Fish()
fish << fish2¿Quién no quiere ser / usar groovy? :RE
No, no puede usar los JAR geniales compilados en Java de la misma manera. Todavía es un error del compilador para Java.
A diferencia de C ++, Java no admite la sobrecarga del operador definido por el usuario. La sobrecarga se realiza internamente en Java.
Podemos tomar +(más) por ejemplo:
int a = 2 + 4;
string = "hello" + "world";Aquí, más agrega dos números enteros y concatena dos cadenas. Por lo tanto, podemos decir que Java admite la sobrecarga interna del operador, pero no la define el usuario.