Перегрузка операторов в Java

Подскажите пожалуйста, возможно ли перегрузить операторы в Java? Если это используется где-нибудь в Java, не могли бы вы рассказать мне об этом.

Нет, Java не поддерживает пользовательскую перегрузку операторов. Единственный аспект Java, который приближается к «пользовательской» перегрузке операторов, - это обработка + для строк, которая приводит либо к конкатенации констант во время компиляции, либо к конкатенации во время выполнения с использованием StringBuilder / StringBuffer. Вы не можете определить свои собственные операторы, которые действуют таким же образом, хотя.

Для Java-подобных (и JVM основе) языка , который делает перегружать поддержки оператора, вы можете посмотреть на Котлин или Groovy . В качестве альтернативы, вам может повезти с плагином Java .

Перегрузка оператора используется в Java для конкатенации типа String:

String concat = "one" + "two";

Однако вы не можете определить собственные перегрузки операторов.

В дополнение ко всем людям, указавшим, что +перегружено для строк, -также перегружено как для операций с плавающей запятой, так и для целочисленных операций, как есть *и /.

[edit] %также перегружен для чисел с плавающей запятой, что может быть сюрпризом для тех, кто имеет C или C ++ фон.

Java не допускает перегрузки операторов. Предпочтительным подходом является определение метода в вашем классе для выполнения действия: a.add(b)вместо a + b. Вы можете увидеть краткую информацию о других битах, которые Java не учитывает в C-подобных языках, здесь: Функции, удаленные из C и C ++

Вы не можете сделать это самостоятельно, поскольку Java не допускает перегрузки операторов.

Однако за одним исключением. + и + = перегружены для объектов String.

Как и многие другие ответили: Java не поддерживает пользовательскую перегрузку операторов.

Может быть, это не по теме, но я хочу прокомментировать некоторые вещи, которые я прочитал в некоторых ответах.

О читабельности.
Для сравнения:

1. с = а + б
2. c = a.add (b)

Посмотри снова!
Какой из них более читабелен?

Язык программирования, который позволяет создавать пользовательские типы, должен позволять им действовать так же, как встроенные типы (или примитивные типы).

Таким образом, Java нарушает фундаментальный принцип общего программирования:
мы должны иметь возможность обмениваться объектами встроенных типов с объектами пользовательских типов.
(Вам может быть интересно: «Он сказал« объекты встроенного »?». Да, смотрите здесь .)

О конкатенации строк:

Математики используют символ + для коммутативных операций над множествами.
Таким образом, мы можем быть уверены, что a + b = b + a.
Конкатенация строк (в большинстве языков программирования) не соответствует этой обычной математической записи.

a := "hello";
b := "world";
c := (a + b = b + a);

или в Java:

String a = "hello";
String b = "world";
boolean c = (a + b).equals(b + a);

Дополнительно:
обратите внимание, как в Java смешиваются равенство и идентичность. Символ == (равенство) означает:
a. Равенство для примитивных типов.
б. Проверка идентичности для пользовательских типов, поэтому мы вынуждены использовать функцию equals () для равенства.
Но ... Какое это имеет отношение к перегрузке операторов?
Если язык допускает перегрузку оператора, пользователь может придать правильное значение оператору равенства.

Можно попробовать перегрузку оператора Java . У него есть свои ограничения, но стоит попробовать, если вы действительно хотите использовать перегрузку операторов.

Просто используйте Xtend вместе с вашим Java-кодом. Поддерживает перегрузку операторов:

    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
    }

}

На официальном сайте есть список способов реализации для каждого оператора!

Или вы можете сделать Java Groovy и просто перегружать эти функции для достижения того, что вы хотите

//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

Кто не хочет быть / использовать заводной? : D

Нет, вы не можете использовать скомпилированные Groovy JAR в Java таким же образом. Это все еще ошибка компилятора для Java.

В отличие от C ++, Java не поддерживает пользовательскую перегрузку операторов. Перегрузка выполняется внутри Java.

Мы можем взять +(плюс) например:

int a = 2 + 4;
string = "hello" + "world";

Здесь, плюс добавляет два целых числа и объединяет две строки. Таким образом, мы можем сказать, что Java поддерживает внутреннюю перегрузку операторов, но не определяется пользователем.