Comments on: Why Java doesn't need operator overloading (and very few languages do, really)

By: Neil Harding

Neil Harding — Fri, 06 Nov 2009 06:28:55 +0000

I wrote a flight simulator for the Gameboy Advance, I used floats to test the math implementation (I declared all the variables as Fixed I typedef’d it to be float during development). I could then use Fixed x = 0.1; x += velocityX * sin(angle) + velocityY * cos(angle), and I had sped up the game to 60 frames a second. I seriously abused C++ on game, it was converted from assembly language to C++ and there were byte ordering issues (big endian to little endian), so I defined unions .l .w .b and it would swap the bytes round on reading .l and writing it (using assembly language instruction to swap the order, so there was not too much penalty).

By: kishore

kishore — Mon, 20 Jul 2009 01:26:19 +0000

In true object oriented sense i would expect to see state, behavior and i can’t see that with operator overloading(it does kind of support polymorphism in some sense). I’m not saying that overloading is not needed in java but may be the designers intention is to avoid confusion by keeping it close to object world. Over loading kind of breaks the abstraction.

By: Mitko

Mitko — Wed, 08 Jul 2009 09:37:40 +0000

Take examples from the natural origin of computer science: mathematics. Let’s consider the multiplication operator. The operator has meaning for numbers, matrices, vectors with a number etc. In this case it is overloaded. What does it mean? This means that operator overloading makes sense in some cases. In Mathematics it is also strictly defined how the operators work, so that everyone knows what they mean and everyone is happy with them. In the world of programming languages overloading the operators makes sense when you design a DSL (Domain specific language). In the context of this language the operators will do what they are intended to do and what they are documented to do (hopefully). Java is not designed to be platform for DSLs, that could simplify the syntax of the code. Java is platform, not only a language, and it does a great job. Who will be the successor of Java is not so clear at the moment.

By: Kengkaj

Kengkaj — Wed, 03 Jun 2009 07:50:35 +0000

I think the problem is not operator overloading per se, but abusing it can cause problem.
There is no different from normal Java method.
Like if we have method add, but when call it, it will read data from database and display it (not add anything), is Java method a problem?

By: Bert

Bert — Tue, 02 Jun 2009 16:16:27 +0000

Operator overloading might not seem to be a good idea outside arithmetics as a lot of people pointed out here. And C++ showed in a very bad way how this can be abused a lot (for a simple example just think about cout << … <- now what this supposed to do ?)
But if you have to write software in the domain of arithmetics, for example 3D applications, cryptographic software, financial software or any kind of scientific software you are really missing operator overloading in Java a lot.
Just think about something like rendering algorithms (like raytracing, pathtracing, ambient occlusion and such stuff) where you have to compute the orthonormal base.
In a language with operator overloading you can write something like:
Vector3 d = (u * Math.Cos(r1) * r2s + v * Math.Sin(r1) * r2s + w * Math.Sqrt(1.0 – r2)).normalize();
in Java you would have to write something like
Vector3 d = ((u.vecsmul(Math.cos(r1) * r2s)).vecadd(v.vecmul(Math.sin(r1) * r2s)).vecadd(w.smul(Math.sqrt(1.0 – r2)))).normalize();
or when using static methods:
Vector3 d = (Vector3.vecadd(Vector3.vecadd(Vector3.vecsmul(u, Math.cos(r1) * r2s), Vector3.vecsmul(v, Math.sin(r1) * r2s)), Vector3.vecsmul(w, Math.sqrt(1.0 – f2)))).normalize();
or doing it the simple way:
Vector3 d = new Vector3();
d.x = (u.x * Math.Cos(r1) * r2s + v.x * Math.Sin(r1) * r2s + w.x * Math.Sqrt(1.0 – r2));
d.y = (u.y * Math.Cos(r1) * r2s + v.y * Math.Sin(r1) * r2s + w.y * Math.Sqrt(1.0 – r2));
d.z = (u.z * Math.Cos(r1) * r2s + v.z * Math.Sin(r1) * r2s + w.z * Math.Sqrt(1.0 – r2));
d.normalize();
This is just a tiny example. There are much more complicated formulas and things can really get nearly unreadable when it gets more complicated.
It can also be a source of errors when translating formulas from paper in your programming language since it is not easy to see on first sight if the translated formula is the same as on paper.
Another bad things when not having operator overloading in the language is that you have to memorize the function names for doing arithmetics.
So for arithmetic stuff like arbitrary-sized large integers (Bignum in java), Fractional (int/int) number representations, Base-10 floats for rounding issues (financial software), Arbitrary-precision floating-point numbers, complex numbers, quaternions, vectors, matrices and defining your own arithmetic for cryptography (like elliptic curves) i really miss operator overloading a lot in java. And for me it is really a reason not to use it for that kind of software.

By: Daniel

Daniel — Sat, 23 May 2009 22:45:11 +0000

Paul:
“”"
… elegant uses in Smalltalk:…
“Yes fractions, making irrational numbers possible”
3/7 + 5/6.
…
“”"
But doesn’t 3/7 + 5/6 in fact mean the same as (((3/7)+5)/6) in Smalltalk (left-to-right evaluation)? I think it does, and I think this an insane design decision – screwing up one of the two most useful applications of binary operators (the other one being comparison operators).
I think Scala does much better; precedence when using methods as binary operators is worked out from their names, in a way consistent with standard arithmetic.

By: Isabelle Hawthorne

Isabelle Hawthorne — Tue, 19 May 2009 01:36:33 +0000

The operators that I often want to overload and for which overloading allows the code to be very clear and readable are: ==, != and =. (i.e. equality, inequality and assignment). These three operators can be meaningfully, intuitively and usefully applied to any kind of object.

By: Paul Beckford

Paul Beckford — Mon, 20 Apr 2009 02:51:38 +0000

Quickly flicked through this, and absolutely no one has offered any of the numerous elegant uses in Smalltalk:
Off the top of my head how about these for starters:
“Yes fractions, making irrational numbers possible”
3/7 + 5/6.
“How about complex numbers anyone?”
(2 +3i)
“Ever wanted to send several messages to the same object?”
receiver doThis, andThis, andAlsoThis.
Thats before we get to advance uses like this BNF expressed in Newspeak:
id = letter, (letter | digit) star.
I just don’t understand how people adopt such strong views, based on such limited experience. Yes I do. We all love the comfort you get from saying “I Know It Already”, even when we possibly don’t.
Ah, well such is human nature

By: Sony Mathew

Sony Mathew — Tue, 14 Apr 2009 18:26:54 +0000

As one that may have abused operator overloading in my past C++ days (never been accused) – I find them very handy. To me they are no worse than a badly documented method – meaning operator+(Object obj) is no different than add(Object obj) method – its all in the consistent contract it defines and enforces.

By: rssh

rssh — Tue, 14 Apr 2009 15:14:56 +0000

) I would love to see some good examples of operator overloading, if you have any to share…
BigDecimal, Matrices, Measurements, Money
I can’t understand why you speak about Collections. Of course arithmetic operator overloading in Collections is not good idea
But having some analog of operator []= for user-defined classes can be useful.
(And as I understand from project coin, java 7 will have overloaded array index access for collections)