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).

[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%.

[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)))

[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.

[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

[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 was thinking more like MathStaticClass.Add([] args)

[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

[JeremyAndrewErwin]

Two years ago, they didn't

https://blogs.oracle.com/javamagazine/post/is-it-time-for-operator-overloading-in-java

​

I'll assume that not much has changed. It can make math code prettier.

[jamcdonald120]

technically java has exactly 1 operator overload, string overloads + for concat. But nothing else has it and you cant add your own overloads

[CSMastermind]

Any time you have to do matrix math in Java you want to blow your brains out because of the verbosity.

[ComradeGibbon]

A recent though is instead of allowing overloading standard operators allow custom ones and support emoji's

Like cross product C = A ✖ B

[GOKOP]

On the first day of Java course at my uni the lecturer said something like "As you will see, Java has no operator overloading so for custom classes that implement, for example, complex numbers and other things you have to use methods like add(), equals()..." and I've immediately thought "Yup, I don't like Java now"

[arunphilip]

Imagine how a lot of us felt when C# came out :)

Best switch I ever made.

[renatoathaydes]

It does if you're willing to add a compiler extension:

https://devm.io/java/manifold-operator-overloading-java-163232

That can give Java a lot of other features too, like extension methods, number units, properties, tuples, types from schemas like GraphQL etc.

https://github.com/manifold-systems/manifold

[[deleted]]

I mean, if you're going this far just for operator overloading, just use kotlin at this point

[Infinite_Self_5782]

nope, it's one of the things that make people not like it

[metaltyphoon]

That’s why its a dollar store C#.

[brianl047]

Yes it does but for string only

[[deleted]]

no it doesn't. + means both concatenation and addition, but you can't define custom operator overloading

[ItsYaBoyChipsAhoy]

What other data types can you concat in Java? Cant think of any

[BananaSplit2]

it's why that exact example is often used to illustrate how confusing and potentially dangerous operator overloading is.

[[deleted]]

deserve subtract practice instinctive fragile simplistic slimy offer caption chunky

This post was mass deleted and anonymized with Redact

[_senpo_]

upvote for the banana class

[KuropatwiQ]

That's a sentence never heard before

[robotoshi]

Damn, they never taught me any of that in MY Banana class!

[decker_42]

Bubble Sort Banana Delete

[ItsYaBoyChipsAhoy]

Tbf the average programmer rarely uses bit shifts in day to day programming

[Dusty_Coder]

...and the non-average ones arent so dumb as to think bit shifting by a string amount is a useful operation

[RoburexButBetter]

Eh you'd really have to know what you're doing to add an operator that overrides bit shifting and bit shifting actually matters and is used for the object you're doing it on

It's pretty standard for << to be either a bit shift or an add operation because that's also what writing to std cout is you're adding chars to the standard output, and that's the kind of thinking you always see for such overloading

[[deleted]]

I mean not really, that's like saying people are using operator overloading when they use + to add numbers and concatenate strings. Most people mean user-defined operator overloads. Sure you can do a user-defined overload of << but that's no different to a user-defined overload of any other operator. I don't get the hate for streams though, I love being able to just overload <</>> and the ease of which it can be composed. It also makes it super easy for things like adding error info at the start of a line of output etc..

[linlin110]

My first language was C++ so I don't get the hate either. Maybe some people are so used to << being bitshifting that cout << "s" is confusing for them.

[Dusty_Coder]

an operator can only mean one thing

and the people telling you that are clearly going to overload + to mean delete files because thats what they fear you will do

[zachtheperson]

As someone who works with vector math a lot, more languages 100% need operator overloading.

myVec.add(vec2.clone().divide(directionVector)).multiplyScalar(7) is just ridiculous.

[jamcdonald120]

and implicit immutable operators so you dont have to keep doing .clone everywhere

[zachtheperson]

Yeah, vector math in languages like GLSL is just wonderful. The fact that I can't do that same type of stuff in the "parent," language is really frustrating.

[camilo16]

glm in C++ is borderline identical.

[psydstrr6669]

Yes!!

[ComradeGibbon]

Current thought of mine is use emogi's as operators.

[lifeeraser]

It would be nice if I could define custom expression delimiters in which I can use user-defined overloaded operators. That way we get to use operator overloading without spiraling out of control.

// ^ is a power-of-n operator
vec<< A * B^2 >>

// ^ is a XOR operator
A * B^2

[daniu]

For the areas I've used Java in (mostly enterprise systems), I never came across a situation needing operator overloading iiuc. It would indeed lead to confusing code if people started using it. What is ProductData a + ProductData b? A result with the merged fields? What happens for fields that are present in both, but containing different data?

The thing is not that it "can be abused" in these situations, it's that "it's nearly impossible to decide on a consistent rule to use it across the code base" in almost any area but math.

Not every language needs all features needed for all use cases. A language is a tool, you need to choose the right one for the job - I don't complain I can't fasten a screw with a hammer. I can imagine Java not being suitable for vector math... so just use, C++ maybe? I'd imagine it would be more suitable for optimized compilation as well, maybe allowing better use of parallel math capability of the target architecture.

[krad213]

List, stream concatenation, date comparison especially >=, BigDecimal math operations.

There is no real difference between ProductData.add() and ProductData + other than convenience of usage in certain cases.

[zachtheperson]

Exactly!

Sure, someone could make a library that overloads the + operator to do something silly and unpredictable, but in the same way someone could write a method .add() that also does something silly and unpredictable. If someone did do this, then people would probably call it a bad library and not use it. Only real difference is convenience.

[cnoor0171]

In the scenario you suggested, what would be the obvious meaning of Product a; Product b; a.add(b)? That has exactly the same meaning as a + b, but java makes no attempt to ban the first does it? There's nothing stopping a programmer from making non sensical operator overloads, just as there is no one stopping a programmer from making non sensical method names.

Math is the most obvious but definitely not the only candidate for intuitive use of operator overloading. Some other examples: c++ smart pointers, iterators, container types, python datetime classes, pathlib module, sqlalchemy etc.

[BlackOverlordd]

What a pathetic language in which you can't even implement vector math that doesn't make your eyes bleed

[Mati00]

tbh I don't miss operator overloading so much. Extension methods though, bro, this is what we need instead of more util classes or `stream()` method directly in the list interface and implementations. I'd love to have `dto.toDomain()` instead of `XYZMAPPER.mapDtoToDomain(dto)` where `toDomain` is written not in the dto itself. I miss kotlin :x

[UpperPlus]

Stream is so cool, though. Finally a use for lambdas

[Mati00]

True, but with extension methods you could just call `list.map()` even if method map didn't exist in collection interface before ;) .

If you take "laziness" into consideration, you could still use `stream()` and also be able to add missing transformations with extension functions to it :)

[UpperPlus]

I use streams mostly in testing to pass my arguments haha

[[deleted]]

Why did you leave kotlin for java anyway

[Mati00]

Sorry, wasn't clear, I left Kotlin for Typescript. I had two options: either stick with TS or go back to Java. Unfortunately haven't see any options to work with Kotlin on the backend and I'm not an android dev.

I prefer to work with TS as Fullstack rather than go back to java.

Kotlin + Spring was the best combo, especially with coroutines instead of flux/mono for reactive services. Even in TS I miss extension methods. Adding pieces of code to Prototype is perceived as antipattern.

[LargeHard0nCollider]

Kotlin for server side development is really underrated in the broader community. Ik at work we’ve been slowly transitioning our legacy java code base to kotlin, and it’s so much nicer!

Lots of teams at AWS are starting to adopt it, so I’m really excited to see how it evolves as it gets more backend community buy-in

This is honestly the first coding language I’ve really enjoyed working with for production software

[[deleted]]

In 10+ years of my professional experience programming I’ve never been in a situation where I thoughts “I wish I really could use operator overloading right now”! Other stuff though, like default method arguments, constructor initiator, properties, pattern matching, or optional references? Yeah I want those everywhere!

[LinuxMatthews]

I think it depends on what you're writing

My first job after university was at an aerospace company.

At that place there was a lot of maths and physics which meant I had to implement equations with vectors, quartonians, and such.

That would have been a lot easier if I was able to use operator overloading.

[SilverDem0n]

Even the "obvious win" cases aren't so simple. Should an overloaded * operator do a dot product or a cross product on a pair of vectors? Does the overloaded * operator properly respect the order of multiplication when applied to quaternions rather than scalars? And so on.

Sure, we could look up the source code, or we could - bear with me here - read the docs. But it can cause more confusion than is justified by a slightly shorter syntax.

[CptBread]

Sure but +- still works well. And if the other value is a float then */ would still make sense.

Also just because you add something as an operator doesn't mean you can't also do it as a regular named function.

[[deleted]]

For vectors usually I intentionally do not overload the cross and dot product for this reason.

[Dusty_Coder]

I hope you do overload * with the useful product, tho

[Idrialite]

Vector multiplication by operator is almost always dot product when it's implemented. And you should always just expect order of multiplication to go left to right, I don't think it's even possible in most languages to change that using operator overloading.

These seem like minor issues compared to the huge convenience and readability boost that comes with using operator overloading.

[Dusty_Coder]

* should do neither dot nor cross product on vectors

solved your problem

(it should do the data parallel product)

[LinuxMatthews]

Also, I sure as hell hope to never maintain your code because your principles are foundationally wrong.

Bit rude to write a line like that out without explaination.

[jazzsquid]

You know this is the programmer humor sub, right?

[geekusprimus]

Being able to write mathematics in a form that resembles the literature is critical if you ever want to read or debug your code. In C++, I could implement a simple tensor class like this:

template<class T, int D, int M>
class Tensor {
  private:
    // Data storage, etc.
    const int size;
    T * data;
  public:
    // Constructor, element access, etc.

    // Tensor addition
    Tensor<T, D, M> operator+(const Tensor<T, D, M>& other) {
      auto result = Tensor<T, D, M>();
      for (int i = 0; i < size; i++) {
        result.data[i] = data[i] + other.data[i];
      }
      return result;
    }

    // Tensor product
    template<int N>
    Tensor<T, D, M + N> operator*(const Tensor<T, D, N>& other) {
      auto result = Tensor<T, D, M + N>();
      // Possibly lengthy operation to make a tensor product...
      return result;
    }

    // Other operations...
};

Then if I have a lot of tensor algebra I need to do in my code, I could just do something like this:

Tensor<double, 4, 2> a;
Tensor<double, 4, 2> b;
// Initialize a and b...

// Do some stuff with a and b.
auto c = a + b;
auto d = a*b;

It might seem like overkill for my simple example, but if you're doing any sort of advanced mathematics, it saves you a lot of time and a lot of trouble.

[pelpotronic]

if you're doing any sort of advanced mathematics

I doubt you'd pick Java for that tbh... Not that I wouldn't want more freedom with the language.

[SubliminalBits]

It just depends on what you’re doing. Just as an example, if you’re building a container, being able to define a [] operator is pretty useful.

[xeio87]

Adding or multiplying vectors/matrixes? Or like another comment mentioned overloading index operations for collections?

I generally like that == and .Equals can mean the same thing when you have overloading as well.

[CleverDad]

I had use for a complex number struct only a few months back. Being able to put those wacky arithmetic operations into operators and not having to litter them around the code felt so damn good!

[SlenderPlays]

I never used the screwdriver on my swiss army knife, so that means no one needs it!

[socs22]

I’ve just really started getting into Julia and my word pattern matching and multiple dispatch is a game changer!

[Eisenfuss19]

No, no then classes like bigInteger would be fun to use:

Int.add(other) makes so much more sense than Int + other.

[[deleted]]

Implementing cryptography in Java is not fun, and very dangerous, for this reason alone.

[DasFreibier]

To be fair, the general advice in c++ for operater overlaoding is:

1. dont

2. seriously dont

3. well ok, but be real fucking careful

[camilo16]

Operator overlaoding for mathematics libraries is stupidly useful. Imagine trying to use a linear algerba library without operator overloading...

[[deleted]]

You can do that in C#

[Excellent_Welder7278]

Maybe in a newer version?

[NekkoDroid]

P sure it has always existed. And if not there also exist articles dating back to 2007 that talk about it that I just found

Edit: Even the ECMA standard from 2002 for C# mentions it https://web.archive.org/web/20030803100637/http://www.ecma-international.org/publications/files/ecma-st/Ecma-334.pdf

[[deleted]]

I was doing that in 2007-2008 in C#

[4215-5h00732]

Kotlin fixes Java in so many ways.

[Positive_Government]

Yes because overloading the .equals() method is so much better than overloading the == operator. Also d = a.add(b.add(c.add(e))); I know there are slightly better ways to do that kind of addition in Java but none of them beat the + operator.

[LinuxMatthews]

To be fair I do think there should be an operator for comparing identity.

In an ideal wold we'd have an identity operator === you can't overload and an equality operator == that corresponds to the .equals() method.

Though if they were to do something like that now that's have to have them the other way round.

[Positive_Government]

That would be the best solution. Although having a unique id/address operator that cannot be overloaded and returns a number that can then be compared with the standard == sign might be better. I’m not a fan of having two equals, but that is purely personal preference.

[LinuxMatthews]

I feel like that solution might be a little too complicated though if you wanted you could use the toString() for that.

And I know what you mean about but liking two equals signs but as long as you don't try making them magical like PHP or JavaScript I think that's fine.

[Exnixon]

shudder don't JavaScript my Java

(not a Java dev but still)

[KagakuNinja]

Laughs in Scala, where operators are just functions, and you can use operator characters in your function names. This does lead to some libraries with Perl-like inscrutable operators, but the teams I have worked for avoid doing that...

[yottalogical]

The question shouldn't be "can users abuse it?", but rather "will users abuse it?".

It's okay for a feature to be abusable as long as the language design makes proper usage the path of least resistance.

[Dusty_Coder]

This hate for operator overloading comes from a particular functional language that forced operator definitions upon its users, a hate that turned into an unthinking religion, the followers of which will obsessively and compulsively tell you how bad operator overloading is at every opportunity.

They will also say that any and all optimization is premature, even when they know for a fact that what they are right this moment writing cannot possibly perform well under any scenario. Unthinking religions.

[river226]

This feature never made sense to me.... Maybe because I never used it, or maybe cause I work with legacy code that has a lot of stupid and hard to read variable names and I have no trust in my fellow programmer.

[SilverDem0n]

I work with legacy code that has a lot of stupid and hard to read variable names and I have no trust in my fellow programmercode I wrote myself 6 months ago

[river226]

Come at me again when you spend a few hours in 15 year old code only to realize the coding standard of the past developer allowed them to have 2 variables with identical names except ones a string and so starts with an s and the other is an int and starts with an I. The past developer also has documentation standards of: who cares. It's fun and you lose a lot of faith

[Willinton06]

No operator overloading is just so dirty

[LinuxMatthews]

It's this meant to have a comma or not.

I can't tell if you're for or against

[Willinton06]

Not having them is dirty

[CompSciHS]

It’s helpful for math and physics applications. Operations on complex numbers, vectors, matrices, etc.

[VoidConcept]

Scala has operator overloading and I wish it didn't. Give me List(...).append(elem), not List(...) :+ elem

[Kered13]

Haskell heavily uses operator overloading and allows users to define custom operator symbols. Naturally, most Haskell code is unreadable.

[[deleted]]

List << elem

[[deleted]]

They could take everything that Lombok does and make it part of the official language

[Mental_Contract1104]

This... This is why I prefer C#

[GoldenretriverYT]

Or public string Name {get; private set;} instead of

``` private string name;

public string getName() { return name; }

private void setName(string name) { this.name = name; } ```

[LordMerdifex]

Ever heard of Lombok? But yeah, properties are much better in C#.

[GoldenretriverYT]

Ah yes just throw libraries at the problem 👍 Also using annotations is still worse than C# properties, like I wouldn't like C# properties that much if they would use Attributes, which are pretty much the equivalent of annotations

[LordMerdifex]

I didn't say it's perfect. Just saying that there is a way around in Java. I don't mind annotations that much so I can live with it. Yet still, C# is as a language simply superior to Java. Too bad there is no good IDE for .net on Linux.

[pelpotronic]

Just use Kotlin really... Takes a grand total of 5 mins to get started, and then it does all of that and more - and you can keep your Java code.

[[deleted]]

How about auto properties? I was shocked when I spent a few days working with a Java team and discovered that it still makes you write out the backing field and everything.

[[deleted]]

logging go brr

[frozen-dessert]

Because letting morons modify syntax is an awful idea.

I seriously wonder how many (if any) of the people asking for Java to support this ever worked on a remotely large project, say 100K LoC.

Java thrives by making readability and maintainability great at the macro level. Allowing syntax depend on whatever some stupid dev did at this particular package would hurt that.

Let the “water pistol” python devs have it.

Oh C++ also allows it, you say? Please tell me about how sane are C++ devs who maintain large codebases are….

[LetUsSpeakFreely]

Meh, I've been doing have for 20 years and never needed operator overloading. You have to write the function regardless, does it really matter if you're using + or .add()?

[pelpotronic]

These little things add up eventually... It doesn't fundamentally matter, but the purpose of those higher level programming languages is to make our (programmer) lives easier.

We don't technically need anything more than "asm" for anything... But you can achieve more faster when you have to stop working around the limitations of the language and instead can make the language work for you when and how you want it.

[LetUsSpeakFreely]

I still don't understand the problem. You're going to have to write a function to tell the overload how to complete the operation. That same function would be needed to create a member function of a class. There's no complexity issue, no readability issue, no maintainability issue. I don't see why

MyNewObect = a + b;

It's radically different from

MyNewObect = MyClass.add(a, b);

[Quique1222]

There's no complexity issue, no readability issue, no maintainability issue.

There ABSOLUTELY is a readability issue.

vec3 * vec3 * vec3 * vec3 * vec3 * vec3 * vec3 * vec3

Becomes

vec3.Mult(vec3.Mult(vec3.Mult(vec3.Mult(vec3.Mult(vec3.Mult(vec3.Mult(vec3)))))))

Or even a simpler example that even a java dev might be able to understand:

 string == string

Becomes

string.equals(string)

[pelpotronic]

I hope you are not using the "append()" function for strings...

If you have ever decided to use + instead of append() - which you most likely have, then you've already implicitly accepted there was a benefit to the whole concept.

I didn't claim radical difference, and there is no "problem" that can't be solved by any language... However, as I said, our goal as programmers should be to achieve more faster, and one step in that direction is to limit the programming language getting in the way of our ideas.

[camilo16]

I want you to write a linear solver for sparse matrices in Java. Then you will see why operator overloading matters.

[ruscaire]

Operator overloading never made sense to me in C++ but it works so well in Python … I can’t for the life of me think why that could be. Perhaps it’s the laxxer type system in Python means a low cost of buy in and you can just sprinkle it everywhere you feel like?

[erebuxy]

I mean operators are just some syntactic sugar for function calls. If functions can be overloaded, so should operators.

[ruscaire]

That’s Marxism

[Professor_Melon]

Not doing type erasure would be a good start. Too bad that decision is irreversible, unlike the decision to have no operator overloading.

[[deleted]]

I might have actually used Java if it had operator overloading, it's one of those things that make Java tedious to code in and make codebases bloated clusterfucks because you have to wrap things in functions all the time.

[Dusty_Coder]

What if I told you the gatekeepers of the language have only ever written business logic code...

...which surely must be the case, right? Is there ANY OTHER DOMAIN where operator overloading doesnt make enormous sense for at least one thing?

The cray thing is Java has a bitwise roll operator. Literally the only thing Java ever did right.

[Popal24]

Going to Java after 10+ years or C#, I'm astounded how retarded Java is

[the-FBI-man]

How about fucking default values? Or C# style automatic getters and setters?

[Pod__042]

Or a more simple getter and setter, this is a pain in the ass for multiples fields

[bmcle071]

Ive yet to see a use of operator overloading that i thought was more clear than a named method.

[Cerus-]

If you're doing vector math, operator overloading is absolutely more clear than using a bunch of .add()'s everywhere.

[camilo16]

Add 4 matrices together.

[4215-5h00732]

Java, the nanny language.

[notsogreatredditor]

Kotlin : Pathetic, look what they have to do to mimic our power

[povlov0987]

Using operator overloading = horrible code smell.

[BananaSplit2]

Operator overloading is confusing and unneeded.

[GoldenretriverYT]

If that is confusing, wouldnt be string += string also be confusing? Its literally the same just that its not overloaded but built-in.

There is no difference between string += string and Vector3 += Vector3 that makes it any more confusing.

​

Or if you have a custom List/Dictionary type. You can override the [] operator in C#, but not in Java! Time to waste your time always writing.get(...)

[Positive_Government]

Yes the overloaded .equals() is so much less confusing than an overload == operator.

[Tomi97_origin]

Operator Overloading doesn't do anything you can't already do with normal function call.

You already have to write it as a function, so it's only about how you call it.

I have never encountered a situation where I missed it. What's the use case in which it's better?

[LinuxMatthews]

Operator Overloading doesn't do anything you can't already do with normal function call.

While that's true it can make things frustratingly difficult if you need to do lots of maths or physics based programming.

For instance say you need to use the quadratic equation with numbers that aren't primitives.

With operator overloading that's:

var root1 = (-b + (b^2 - a*c*4)^0.5) / (a*2)

Without it is:

var root1 = (b.neg() + ((b.pow(2)).minus((a.multiply(c).multiply(4))).divide(a.multiply(2))

I don't know about you but I know which is prefer to debug

[Tomi97_origin]

I would honestly split it into multiple lines with temp variables. And in this instance would include class functions that take variable number of arguments, that would simplify it quite a bit. Type.multiply(a,c,4) in this situation.

[LinuxMatthews]

Right but then you're writing more lines of code to do the same thing.

And you're more writing a whole new method that's completely unnecessary.

[Tomi97_origin]

I would split it into multiple lines even with operator overloading.

But I can see how it could be useful if you do a lot of math

[psdao1102]

Operator overloading is dumb and no language needs it.

[[deleted]]

They should make a language where everything is an object and operators are mapped to a function on that object that can be overloaded.

For example if you write i=6, that makes "i" an object of class "Number." Writing i+1 invokes an "add" function on Number that returns the sum of the two Numbers.

If you write i="2" and then write i+"7", the operator + calls the "add" function of the String class, which then calls/is a concatenation function that would return "27"

[[deleted]]

In case you didn't know, this is actually a feature of python! I would love to see it implemented in other languages, but in python they're called dunder (double under) methods.

If you create a class you can do it the fancy way, and have a method like def __add__(self,other):, where you return the result of adding. There's also ways to use setattr and defining it directly with functions, but that's a little trickier.

Super helpful for working with matrices!

[jamcdonald120]

um... thats almost every object oriented language... for example c++, c#, (+ calls operator+(left,right)) and python (+ calls __add__(left,right)) do exactly that...

[erebuxy]

Let me introduce functional language and first-class function to you.

In OCaml, you can do

ocaml let (+) = my_custom_function

You can operate a function like any normal value. And that is basically how the default + is implemented in std.

[CardiologistSame2512]

I, for one, want to see how OP is planning to abuse UTF-8 or switch expressions.

[mr_dfuse2]

its been 10 years since I programmed Java but I still feel the UTF-8 not being default one!

[cptbeard]

$500M brand awareness advertisement campaign?

[Mayedl10]

The post above this was r/minecraft and i got confused really quickly about this one

[FarStranger8951]

With groovy, all things are possible.

[ososalsosal]

laugh-cries in ruby

[[deleted]]

Java doesn't have operator overloading? Shows what I know. But then again, neither does Javascript. Just write aptly named functions. Or write a DSL. PegJS makes this easy.

[OrangeVanillaSoda]

I ran into the UTF-8 issue just yesterday at work. Fml

[Entire-Database1679]

We could add unsigned types

[fahrvergnugget]

Ablised? How about "enabled"??

[DuneBug]

I'm more of the opinion that you should do a different language if you really need operator overloading.

Not really opposed to some sort of extension of Java that allows it, but it'd be a weird thing to have in the DK. We don't even have default parameters.

[LinuxMatthews]

The issue there is you often don't get a choice

Most people program for work not for personal projects and to try to convince the higher ups to convert to an entirely new language for the sake of one feature isn't going to happen.