unarios - ¿Por qué Java no ofrece sobrecarga de operadores?




sobrecarga de operadores en java pdf (10)

Algunas personas dicen que la sobrecarga de operadores en Java llevaría a la ofuscación.¿Alguna vez se detuvo esa gente para ver algunos códigos Java que hacen algunos cálculos básicos como aumentar un valor financiero en un porcentaje usando BigDecimal? .... La verbosidad de tal ejercicio se convierte en su propia demostración de la ofuscación. Irónicamente, agregar una sobrecarga de operadores a Java nos permitiría crear nuestra propia clase de moneda que haría que este código matemático fuera elegante y simple (menos confuso).

Al venir de C ++ a Java, la pregunta obvia sin respuesta es ¿por qué Java no incluyó la sobrecarga de operadores?

No es Complex a, b, c; a = b + c; Complex a, b, c; a = b + c; mucho más simple que el Complex a, b, c; a = b.add(c); Complex a, b, c; a = b.add(c); ?

¿Existe una razón conocida para esto, argumentos válidos para no permitir la sobrecarga del operador? ¿Es la razón arbitraria, o se pierde en el tiempo?


Bueno, realmente puedes dispararte en el pie con la sobrecarga del operador. Es como con los punteros las personas cometen errores estúpidos con ellos y, por lo tanto, se decidió quitar las tijeras.

Al menos creo que esa es la razón. Estoy de tu lado de todos modos. :)


Decir que la sobrecarga del operador conduce a errores lógicos de tipo que el operador no coincide con la lógica de operación, es como no decir nada. El mismo tipo de error ocurrirá si el nombre de la función no es apropiado para la lógica de operación. ¿Cuál es la solución: eliminar la capacidad de uso de la función? Esta es una respuesta cómica: "Inapropiado para la lógica de operación", cada nombre de parámetro, cada clase, función o lo que sea lógicamente inapropiado. Creo que esta opción debería estar disponible en un lenguaje de programación respetable, y aquellos que piensan que es inseguro. Oye, ambos dicen que tienes que usarlo. Vamos a tomar el C #. Inclinaron los punteros pero, por su cuenta y riesgo, hay una declaración de "código no seguro" que usted desea.


Echa un vistazo a Boost.Units: texto del enlace

Proporciona un análisis dimensional de cero sobrecarga a través de la sobrecarga del operador. ¿Cuánto más claro puede conseguir esto?

quantity<force>     F = 2.0*newton;
quantity<length>    dx = 2.0*meter;
quantity<energy>    E = F * dx;
std::cout << "Energy = " << E << endl;

en realidad daría como resultado "Energía = 4 J", que es correcto.


James Gosling comparó el diseño de Java con lo siguiente:

"Hay un principio sobre la mudanza, cuando te mudas de un apartamento a otro. Un experimento interesante es empacar tu apartamento y poner todo en cajas, luego pasar al siguiente apartamento y no desempacar nada hasta que lo necesites. Así que ' está haciendo su primera comida y está sacando algo de una caja. Luego, después de un mes o más, lo ha usado para averiguar qué cosas en su vida realmente necesita, y luego toma el resto de la Cosas: olvida lo mucho que le gusta o lo genial que es, y simplemente lo tira. Es increíble cómo eso simplifica su vida, y puede usar ese principio en todo tipo de problemas de diseño: no haga las cosas solo porque son geniales o simplemente porque son interesantes ".

Puedes leer el http://www.gotw.ca/publications/c_family_interview.htm

Básicamente, la sobrecarga del operador es excelente para una clase que modela algún tipo de punto, moneda o número complejo. Pero después de eso, te quedas sin ejemplos rápidamente.

Otro factor fue el abuso de la función en C ++ por parte de los desarrolladores que sobrecargaron operadores como '&&', '||', los operadores de reparto y, por supuesto, 'nuevo'. La complejidad resultante de combinar esto con el paso por valor y las excepciones está bien cubierta en el libro Exceptional C ++ .


Los diseñadores de Java decidieron que la sobrecarga del operador era más problemática de lo que valía. Simple como eso.

En un lenguaje donde cada variable de objeto es en realidad una referencia, la sobrecarga del operador tiene el peligro adicional de ser bastante ilógica, al menos para un programador de C ++. Compare la situación con la sobrecarga de operadores == de C # y Object.Equals y Object.ReferenceEquals (o como se llame).


Técnicamente, existe una sobrecarga de operadores en cada lenguaje de programación que puede manejar diferentes tipos de números, por ejemplo, números enteros y números reales. Explicación: el término sobrecarga significa que hay simplemente varias implementaciones para una función. En la mayoría de los lenguajes de programación, se proporcionan diferentes implementaciones para el operador +, una para los enteros, una para los reales, esto se denomina sobrecarga del operador.

Ahora, a muchas personas les resulta extraño que Java tenga una sobrecarga de operadores para el operador + para agregar cadenas, y desde un punto de vista matemático, esto sería realmente extraño, pero visto desde el punto de vista del desarrollador de un lenguaje de programación, no hay nada de malo en agregar la sobrecarga incorporada del operador. para el operador + para otras clases, por ejemplo, String. Sin embargo, la mayoría de las personas están de acuerdo en que una vez que agregue la sobrecarga incorporada para + para String, entonces generalmente es una buena idea proporcionar esta funcionalidad para el desarrollador también.

Está totalmente en desacuerdo con la falacia de que la sobrecarga del operador ofusca el código, ya que esto queda para que el desarrollador lo decida. Esto es ingenuo pensar, y para ser honesto, está envejeciendo.

+1 para agregar la sobrecarga de operadores en Java 8.


Groovy tiene sobrecarga de operadores y se ejecuta en la JVM. Si no te importa el impacto de rendimiento (que se reduce cada día). Es automático basado en nombres de métodos. por ejemplo, '+' llama al método 'más (argumento)'.


A veces, sería bueno tener sobrecarga de operadores, clases de amigos y herencia múltiple.

Sin embargo sigo pensando que fue una buena decisión. Si Java hubiera tenido una sobrecarga de operadores, nunca podríamos estar seguros de los significados de los operadores sin mirar a través del código fuente. En la actualidad eso no es necesario. Y creo que su ejemplo de uso de métodos en lugar de sobrecarga de operadores también es bastante legible. Si quieres aclarar las cosas, siempre puedes agregar un comentario sobre las frases peludas.

// a = b + c
Complex a, b, c; a = b.add(c);

Esta no es una buena razón para rechazarla, sino una práctica:

La gente no siempre lo usa responsablemente. Mira este ejemplo de la biblioteca de Python scapy:

>>> IP()
<IP |>
>>> IP()/TCP()
<IP frag=0 proto=TCP |<TCP |>>
>>> Ether()/IP()/TCP()
<Ether type=0x800 |<IP frag=0 proto=TCP |<TCP |>>>
>>> IP()/TCP()/"GET / HTTP/1.0\r\n\r\n"
<IP frag=0 proto=TCP |<TCP |<Raw load='GET / HTTP/1.0\r\n\r\n' |>>>
>>> Ether()/IP()/IP()/UDP()
<Ether type=0x800 |<IP frag=0 proto=IP |<IP frag=0 proto=UDP |<UDP |>>>>
>>> IP(proto=55)/TCP()
<IP frag=0 proto=55 |<TCP |>>

Aquí está la explicación:

El operador / se ha utilizado como operador de composición entre dos capas. Al hacerlo, la capa inferior puede tener uno o más de sus campos predeterminados sobrecargados de acuerdo con la capa superior. (Todavía puedes dar el valor que quieras). Una cadena se puede utilizar como una capa en bruto.





operator-overloading