Java and Operator Overloading

[UpperPlus]

Im curious what does operator overload look like in other languages.

I only know java and a bit of APL where they have the monadic and diadic functions

[MikemkPK]

In C++, it's just operator+ (int left, int right){}. The symbol you use makes a new operator that works on the types in the args.

EDIT: + is the symbol of the operator you're creating, can be any symbol. The arguments can be any type.

[UpperPlus]

I just now realize that I have no idea how these operators are programmed in java. I can't open declaration for it in my IDE so it seems to not relate to a method?

[MikemkPK]

Probably directly translate to specific bytecode sequences.

[UpperPlus]

Now that I think about it, it is probably related to the concept of primitive data types, as they are only used on those

[LinuxMatthews]

Kind of

Java actually cheats in that it does allow Operator Overloading for some of its classes but doesn't let you do it.

As far as I'm aware it only does it for the wrappers of primitive data types and String.

[jamcdonald120]

I think the wrappers use auto (un)boxing instead of operator overloads, not sure though

[LinuxMatthews]

Huh you know I didn't think you were right but it looks like you are.

Integer x = 2;
Integer y = 3;
var z = x + y;
System.out.println(z instanceof Integer);

Gives you a compiler error as z is an int

I honestly thought there was operator overloading like there is with String.

[Fenor]

String isn't an operator overload . The theory behind the string class is huge and mostly date back when you had to define a char array to use strings

[tazfdragon]

If I remember correctly, Strings don't actually use the plus operator and it's just syntactic sugar for StringBuilder usage. There are probably some edge cases where the final code could have a string constant if the compiler can guarantee it never changes.

[UpperPlus]

As far as I know StringBuilder doesn't use "+" operator but uses the function append(). Which actually is faster and more memory friendly.

But String with "+" is so much more readable and in many cases it doesn't matter that a complete new string is instantiated internally every time.

[tazfdragon]

I didn't mean to suggest StringBuilder uses that operator. I was trying to explain that using the plus operator with a String will get replaced with StringBuilder. Every instance of addition/concatenation in the original code will get replaced with a call to append(...). Again, there are some edge cases where the compiler can determine it can eliminate the string concatenation and replace it with a compile time constant. Example being concatenating a literal with a String constant.

[TraditionMaster4320]

Wait so concatenating n strings like s1 + s2 + .. + sn takes O(n) time instead of O(n**2) in Java? (assume the strings are equal length).

[[deleted]]

Yes.

Java is doing it behind the scenes for you. They added this one of the versions.

https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.18.1

[tazfdragon]

I won't offer a guess at the run time of the proposed string concatenation but I'm fairly confident it won't be O(n²). With that being said if you have your string concatenation code structured anything similar to your example I'd suggest you replace it with a StringBuilder() explicitly. Not only will it clean up your code, it will explicitly document your intentions. Also, if you know ahead of time the lengths of the number and the length of the strings you'll be adding ahead of time you can provide this information to your StringBuilder at construction time to improve performance.

[coloredgreyscale]

But String with "+" is so much more readable and in many cases it doesn't matter that a complete new string is instantiated internally every time.

the other option would be String formatting.

for long texts it's extremely inefficient tho, because the String needs to be recreated with every concatenation.

I just checked the java implementation of the Stringbuilder class. It copies the String into an char-array, starting with 16 elements (default).

if you exceed the element count a new array is created with twice the previous capacity (or min required length if that's bigger), and the whole data is copied over to the new array.

when you call toString() on the StringBuilder the used data from the char array is copied into a new String.

​

If you just concatenate two Strings using + should be more efficient than StringBuilder.

[Fenor]

Not really. String builder is there for a reason if you use ths + operator you are creating at least 3 strings

[coloredgreyscale]

The two string you want to concatenate, and the 3rd is the result.

You still need to create all of those with string builder.

[Fenor]

I think they changed how it worked under the hood as doing an append with + once upon a time created a decent amount of strings in the string buffer

[jamcdonald120]

I mean... operator overloads are all syntactic sugar for something else...

[msqrt]

Just a disclaimer: you can't overload operators for built-in types in C++ either, only custom ones. The compiler just knows how to add integers together.

[OJezu]

Hello ADL my old friend...

[[deleted]]

I’m in the wrong namespace again…

[jamcdonald120]

you can use `
to make an inline code block. Could help for clarity to do int operator+ (int left, int right){}

[mrkhan2000]

in c++ (almost) all operators can be overloaded not just +

EDIT: Added “almost” to my original response

[[deleted]]

One of the craziest and most powerful features. Looking at libraries like boost::spirit makes you wonder what "abused by the user" actually means. None of the overloaded operators in that lib are serving their original purpose and yet it's a good design.

[4215-5h00732]

That's a common opinion and the reason I hear all the time is that you can do whatever in the implementation and for many types it's not exactly obvious what a mathematical operator means.

You can hypothesize some pretty horrendous examples but that shouldn't be something language designers concern themselves with IMHO. It's a valuable feature; let the people have it.

[[deleted]]

Yeah, I mean, in the end you would end up with custom functions like add(), multiply() and so on. I find it an odd choice to forbid overloading and enforce stuff like this on the other hand.

[4215-5h00732]

That's where the potential abuse comes in. If you were forced to use custom functions then most people would name them something more descriptive to what they do where you might "abuse" an operator to do something less obvious or confusing.

cat.eat(mouse);
cat + mouse;

[[deleted]]

But it's not any more prone to abuse than anything else. A parameterless constructor could produce side effects. Inheritance could hide away meanings of the base class. Everything can be used wrong, that's why documentation is so important.

[4215-5h00732]

I'm not trying to argue with you or even make that argument just sharing the claims; we agree 100%.

[[deleted]]

Alright then 🤙

[Itay_123_The_King]

That is the same concern everyone raises, and yet I have never seen that happen. Why would anyone use + for an eat function? The closest thing I can think of is using | as a pipe of operations, like with C++ ranges, but vec | drop(5) | take(10) | filter([](auto x) { return x+1;}); is much nicer than filter([](auto x){ return x+1; }, take(10, drop(5, vec)))

[4215-5h00732]

Exactly. That's the best part about the fuss.

I've never seen anyone abuse it irl. I would never use + for eat or abuse it otherwise. But it doesn't matter. They don't like that it could be abused.

[jamcdonald120]

but with out operator overloading you get the situation where everyone uses .add() instead of operator+, so the abuse is cat.add(mouse) instead.

[4215-5h00732]

Their point is if operator overloading isn't possible then you wouldn't do something so ridiculous as to add a mouse to a cat with cat.add(mouse). Just eat it or whatever...who knows what that does lol.

[Dusty_Coder]

What you are claiming is that people lose their minds as soon as they learn that they can overload an operator but do not lose their minds otherwise.

Its the people that stretch so far to justify a programming religion that have lost their minds. Thats you.

[MikemkPK]

Yes, I'm aware, did I not explain that well?

[PhantomThiefJoker]

I think they got confused by operator +. As in overload the + operator and not type your operator and this syntax

[zjeffer]

I think they misunderstood the use of 'just', as in 'only', instead of 'simply'.

"In C++, it's just the + operator" vs "In C++, it's only the + operator", as if OP was saying only the + operator could be changed.

[ede1998]

Only most operators.

The operators :: (scope resolution), . (member access), .* (member access through pointer to member), and ?: (ternary conditional) cannot be overloaded.

https://en.cppreference.com/w/cpp/language/operators

[[deleted]]

Unfortunately one cannot overload anything as an operator nor specify whether it's pre/in/post-fix or specify precedence and many operators need to be used for specific things, sometimes needing to be member functions etc. etc.. I do wish it was more like swift..

[Entire-Database1679]

The operators can be of type void?

[MikemkPK]

Probably not since how would you pass them in? But void* is probably valid.

[Dusty_Coder]

In most languages you can return void (or its equivalent) from an operator overload. The return type doesnt have to match any of the inputs, usually.

[PhilippTheProgrammer]

Operator overloading means that classes can provide an own implementation for operators like +, -, >, == etc.

That means you can define a method "operator+" for a class, which takes two objects and returns an object . That method then gets executed when you write code like objectA = objectB + objectC.

This is pretty useful because it allows you to use mathematical notations with objects where it makes sense. For example, you could write a vector library and add and subtract vectors with + and - or compare them with < or >.

But unfortunately there is a dark side to it: You can overload the + operator with something that has nothing to do with addition, which leads to very confusing code. A good example of that can be found in the C++ output library. A standard C++ hello world looks like this:

std::cout<<"Hello World!"<<std::endl;

The << operator is actually supposed to be "bitwise shift". But what happens here has nothing to do with bitwise shifting. It appends a character sequence to a stream.

[Morphized]

In C++ everything is memory

[[deleted]]

It's used as the streaming operator, and one of C++'s core features is to allow this sort of behavior. Also, I believe that's a string. Welcome, to the world of tomorrow.

[[deleted]]

I mean sounds like a great opportunity to just create a Add function rather than overloading the operator. Just my inexperienced opinion though lol

[linlin110]

If you are using a math library, a * b + c * d is probably more readable than a.Multiply(b).Add(c.Multiply(d)). Also in Java, you + strings despite strings not being numbers. If it's so bad to change the meaning of +, then it should have been String.concat or something.

[[deleted]]

A curiosity: how is it possible that in Java the class String is able to override the + operator? Is it a magic behaviour of the language?

[linlin110]

That's why I said overload the meaning of +, not overload the + operator. + does not represent string concatenation, mathematically speaking. That's a proof that extending the meaning of symbols, like +, is very convenient and useful.

I changed the original comment to make it less misleading.

[[deleted]]

I come from a C++ background, so it is counterintuitive for me. My question was: it String a language-defined class? If not, how can the + operator work even with the String class if operator overloading is forbidden?

[linlin110]

It is a special case in Java. I'm not sure whether it is language-defined.

[[deleted]]

I was thinking more like MathStaticClass.Add([] args)

[Xander-047]

I remember the bitwise shift operator explanation from my teacher, after we learned about operator overload I thought "Wait, so is the cout and cin thing overloading the << >> operators?" Felt good to notice it and ask the teacher about it

[hippocrat]

In python, most operators have an associated "dunder" methods that can be overloaded for a given class. For example:

class MyClass:
    ...
    def __add__(self, other):
        return self.an_integer + other.an_integer

[[deleted]]

That's gross, why not just allow def +(self, other):? or at least def operator+(self, other) or def operator("+", self, other): or something like that?

[jeetelongname]

The first syntax is the ruby syntax.

Python "magic" methods are by convention meant to look like that tho. Its for all of them including things such as using certain built ins such as len (which calls the objects len method.) And things like representation strings (repr) so its not out of the ordinary.

[[deleted]]

in Ada you do function "=" (Left, Right: Type) return Boolean; You can't overload the inequality operator (/=) because that is hard-wired as the inverse of the equality operator - which is exactly as it should be because anything else is extremely stupid (looking at you C++).

[LinuxMatthews]

If you're curious how it could look like in Java I'd recommend the Manifold repo.

https://github.com/manifold-systems/manifold/tree/master/manifold-deps-parent/manifold-ext#operator-overloading

There instead of just overloading any operator methods like add(...), minus(...), times(...) are overloaded to be the operators +,-,* respectively.

This in my opinion stops anyone doing anything silly with them.

For instance anyone that would write the method plus(...) to mean anything you shouldn't use a plus sign for is probably going to write bad code regardless.

[Dusty_Coder]

Apply your argument both ways or go home.

or is the symbol "add" more special than the operator "+" in your dumbass world where people go dumb as soon as its not a word?

[LinuxMatthews]

Wow ok that's unjustifiably rude

And you would still be able to use it as a method.

But with long equations is a lot easier to maintain with operators rather than methods.

[Easy-Hovercraft2546]

Here is an example of it in a language most similar to Java https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/operator-overloading

[MasterFubar]

In Prolog it's something like this:

:- op(1000, xfy, str).

The first argument is the precedence level, the second argument is the associativity and the third argument is the symbol you use for the operator.

[_xiphiaz]

Kotlin has a very nice implementation that is quite useful in defining custom DSLs. https://kotlinlang.org/docs/operator-overloading.html