Java challengers #1: перегрузка методов в jvm / блог компании otus / хабр

Ясное и естественное обозначение: методы против перегрузки оператора?

Мы сравним ниже, для разных случаев, «тот же» код в Java и С++, чтобы иметь представление о том, какой стиль кодирования более ясен.

Натуральные сравнения:

Обратите внимание, что A и B могут быть любого типа в С++, если предусмотрены перегрузки оператора. В Java, когда A и B не являются примитивами, код может стать очень запутанным даже для примитивно-подобных объектов (BigInteger и т.д.)..

Применения естественного массива/контейнера и подписка на подписку:

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

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

Мануалы с естественными расширенными типами

В приведенных ниже примерах используется объект , найденный с использованием первых ссылок, найденных в Google, для » объект Java Matrix» и » С++ Матричный объект»:

И это не ограничивается матрицами. Классы и Java страдают от той же запутанной многословности, тогда как их эквиваленты в С++ так же понятны, как и встроенные типы.

Конкатенация текста:

Хорошо, в Java вы можете использовать тоже… Но, подождите секунду: Это перегрузка оператора, не так ли? Разве это не обман???

: — D

Примеры

В этом случае оператор сложения перегружается, чтобы разрешить добавление к пользовательскому типу в C ++ :

Time operator+(const Time& lhs, const Time& rhs) {
  Time temp = lhs;
  temp.seconds += rhs.seconds;
  temp.minutes += temp.seconds  60;
  temp.seconds %= 60;
  temp.minutes += rhs.minutes;
  temp.hours += temp.minutes  60;
  temp.minutes %= 60;
  temp.hours += rhs.hours;
  return temp;
}

Сложение — это бинарная операция , что означает наличие двух операндов . В C ++ передаваемые аргументы — это операнды, а объект — это возвращаемое значение.

Операция также может быть определена как метод класса, замененный скрытым аргументом; Однако это заставляет левый операнд иметь тип :

// The "const" right before the opening curly brace means that |this| is not modified.
Time Time::operator+(const Time& rhs) const {
  Time temp = *this;  // |this| should not be modified, so make a copy.
  temp.seconds += rhs.seconds;
  temp.minutes += temp.seconds  60;
  temp.seconds %= 60;
  temp.minutes += rhs.minutes;
  temp.hours += temp.minutes  60;
  temp.minutes %= 60;
  temp.hours += rhs.hours;
  return temp;
}

Обратите внимание, что унарный оператор, определенный как метод класса, не получит явного аргумента (он работает только с ):

bool Time::operator!() const {
  return hours ==  && minutes ==  && seconds == ;
}

Оператор «меньше» (<) часто перегружается для сортировки структуры или класса:

class Pair {
 public
  bool operator<(const Pair& p) const {
    if (x_ == p.x_) {
      return y_ < p.y_;
    }
    return x_ < p.x_;
  }

 private
  int x_;
  int y_;
};

Как и в предыдущих примерах, в последнем примере перегрузка оператора выполняется внутри класса. В C ++ после перегрузки оператора «меньше» (<) для сортировки некоторых классов можно использовать стандартные функции сортировки.

В C ++ перегрузка оператора не является обязательной …

В C ++ перегрузка операторов для встроенных типов невозможна (и это хорошо), но определяемые пользователем типы могут иметь определяемые пользователем перегрузки оператора.

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

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

В сочетании с программированием шаблонов перегрузка операторов становится хорошо известным шаблоном проектирования. Фактически, вы не можете далеко продвинуться в STL без использования перегруженных операторов и операторов перегрузки для вашего собственного класса.

Итак … Хорошо … Тогда почему это невозможно в Java?

Потому что Джеймс Гослинг сказал так:

Пожалуйста, сравните текст Гослинга выше со Страуструпом ниже:

Будет ли перегрузка операторов полезной для Java?

Некоторые объекты могут значительно выиграть от перегрузки операторов (конкретные или числовые типы, такие как BigDecimal, комплексные числа, матрицы, контейнеры, итераторы, компараторы, парсеры и т.д.).

В C++ вы можете воспользоваться этим преимуществом благодаря скромности Страуструпа. В Java вы просто облажались из-за Гослинга личный выбор,.

Может ли он быть добавлен в Java?

Причинами, по которым теперь не добавляется перегрузка операторов в Java, может быть сочетание внутренней политики, аллергии на эту функцию, недоверия разработчиков (вы знаете, диверсантов, которые, похоже, преследуют Java команды …), совместимость с предыдущими JVM, время для написания правильной спецификации и т. д.

Так что не ждите, пока эта функция …

Но они делают это на C # !!!

Да уж…

Хотя это далеко не единственное различие между двумя языками, этот не может не удивить меня.

По-видимому, люди C #, с их «каждый примитив является , а происходит от Object», правильно понял с первой попытки.

И они делают это на другие языки !!!

Несмотря на все FUD против используемой определенной перегрузки операторов, ее поддерживают следующие языки: Scala , , , F # =, C # , D , ALGOL 68 , Smalltalk , , , C++, Ruby , Haskell , MATLAB , Eiffel , Lua , Clojure , Fortran 9 , , Ada , Delphi 2005 …

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

Пища для размышлений …

Пример 6: Операторы равенства и отношений

class RelationalOperator {
    public static void main(String[] args) {

        int number1 = 5, number2 = 6;

        if (number1 > number2)
        {
                System.out.println("number1 больше, чем number2.");
        }
        else
        {
                System.out.println("number2 больше, чем number1.");
        }
    }
}

Когда вы запустите программу, в которой используются операторы сравнения Java, на экран выведется:

number2 больше, чем number1.

Здесь мы использовали оператор «>», чтобы проверить, больше ли number1, чем number2.

Так как number2 больше, чем number1, результатом выражения number1 > number2 будет false.

Кроме операторов отношений, есть оператор сравнения типов instanceof, который сравнивает объект и определенный тип.

Например:

Рекурсивные методы

И последнее, что
мы рассмотрим на этом занятии – это рекурсивные методы, то есть, методы,
которые вызывают сами себя. Да, да, так тоже можно делать. Давайте я сначала
приведу пример работы рекурсивного метода, а, затем, мы разберемся как это
работает.

static void up_and_down(int n) {
    System.out.println("Уровень вниз " + n);
    if (n < 4) up_and_down(n + 1);
    System.out.println("Уровень вверх " + n);
}

и вызовем его:

up_and_down(1);

Запустим эту программу,
и увидим следующее:

Уровень
вниз 1

Уровень
вниз 2

Уровень
вниз 3

Уровень
вниз 4

Уровень
вверх 4

Уровень
вверх 3

Уровень
вверх 2

Уровень
вверх 1

Почему все так
получилось? Давайте разберемся.

Стек вызова
функций

Смотрите, когда
вызывается какой-либо метод, он помещается в стек вызова методов (чтобы знать,
какие методы в каком порядке были вызваны). Сначала в этом стеке находится
метод main(), далее, из
него вызывается метод up_and_down(1). Что
происходит дальше? Этот метод выводит на экран строку «Уровень вниз 1» и
проверяет условие 1<4 – да, и идет вызов такого же метода, но уже с
аргументом n+1=2. Причем
работа первого метода up_and_down(1) и второго up_and_down(2) совершенно
независимы друг от друга! Второй метод также выводит строку «Уровень вниз 2» и
проверяет условие 2<4. Оно срабатывает и идет вызов следующего метода up_and_down(3). Здесь
происходит все то же самое. Наконец, когда мы достигаем up_and_down(4), условие 4<4
не срабатывает и дальнейшего вызова метода up_and_down не происходит и
выполняется следующая строчка метода, которая выводит строку «Уровень вверх 4».
Что будет дальше? Дальше метод up_and_down(4) завершается
и вызов передается методу up_and_down(3) в
соответствии со стеком вызова. Но этот метод уже выполнил первые две строчки,
поэтому выполняется третья, которая выводит «Уровень вверх 3». Он также
завершается, вызов переходит к методу up_and_down(2), он по
аналогии выводит третью строку «Уровень вверх 2», передает управление up_and_down(1), он выводит
«Уровень вверх 1» и на этом работа рекурсии завершается. Вот так работают
рекурсивные методы.

Кстати, обратите
внимание, если бы у нас не было вот этого условия, то рекурсия ушла бы вниз,
пока стек методов не переполнился бы (возникла бы ошибка stack overflow), поэтому при
реализации рекурсивных методов нужно внимательно относиться к глубине их вызова
– она не должна быть большой

Видео по теме

#1 Установка пакетов и первый запуск программы

#2 Структура программы, переменные, константы, оператор присваивания

#3 Консольный ввод/вывод, импорт пакетов

#4 Арифметические операции

#5 Условные операторы if и switch

#6 Операторы циклов while, for, do while

#7 Массивы, обработка элементов массива

#8 (часть 1) Строки в Java, методы класса String

#8 (часть 2) Строки — классы StringBuffer и StringBuider

#9 Битовые операции И, ИЛИ, НЕ, XOR

#10 Методы, их перегрузка и рекурсия

… Даже в стандартных интерфейсах Java

В качестве другого примера рассмотрим интерфейс в Java:

Предполагается, что вы клонируете объект, реализующий этот интерфейс. Но ты можешь солгать. И создать другой объект. На самом деле этот интерфейс настолько слаб, что вы можете вернуть другой тип объекта вообще, просто для удовольствия:

Поскольку интерфейс может быть abused/obfuscated,, должен ли он быть запрещен по тем же основаниям, что и перегрузка оператора C++?

Мы могли бы перегрузить метод класса , чтобы он возвращал строковый час дня. Следует ли также запретить перегрузку ? Мы могли бы саботировать , чтобы он возвращал случайное значение, изменять операнды… и т. д..

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

И вообще, что тут запутанного?

Теперь, когда мы знаем, что код может быть саботирован даже с помощью первозданных методов Java, мы можем спросить себя о реальном использовании перегрузки операторов в C++?

Ясная и естественная нотация: методы против перегрузки оператора?

Ниже мы сравним для разных случаев код «same» в Java и C++, чтобы иметь представление о том, какой стиль кодирования более понятен.

Естественные сравнения:

Обратите внимание, что A и B могут быть любого типа в C++, если предусмотрены перегрузки оператора. В Java, когда A и B не являются примитивами, код может стать очень запутанным, даже для примитивных объектов (BigInteger и т

д.)…

Натуральный массив/контейнер методом индексации:

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

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

Естественные продвинутые типы манипуляции

В приведенных ниже примерах используется объект , найденный с помощью первых ссылок, найденных в Google для «Java Matrix object» и » C++ Matrix object «:

И это не ограничивается матрицами. Классы и Java страдают той же запутанной многословностью, в то время как их эквиваленты в C++ столь же ясны, как и встроенные типы.

Конкатенация текста:

Хорошо, в Java Вы тоже можете использовать … Но подождите секунду: это перегрузка оператора, не так ли? Разве это не обман???

:- D

Что все-таки запутывает?

Теперь, когда мы знаем, что код можно саботировать даже через нетронутые методы Java, мы можем задаться вопросом о реальном использовании перегрузки операторов в C++?

Понятная и естественная запись: методы против перегрузки операторов?

Ниже мы сравним, для разных случаев, «один и тот же» код в Java и C++, чтобы иметь представление о том, какой стиль кодирования более понятен.

Естественные сравнения:

Обратите внимание, что A и B могут быть любого типа в C++, если предусмотрены перегрузки операторов. В Java, когда A и B не являются примитивами, код может стать очень запутанным, даже для примитивных объектов (BigInteger и т.д.) ..

Естественные массивы/контейнерные средства доступа и подписка:

В Java мы видим, что для каждого контейнера, выполняющего одно и то же (доступ к его содержимому через индекс или идентификатор), у нас есть другой способ сделать это, что сбивает с толку.

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

Естественные продвинутые типы манипуляций

В приведенных ниже примерах используется объект , найденный с использованием первых ссылок, найденных в Google для » объект Java Matrix » и » объект c ++ Matrix «:

И это не ограничивается матрицами. Классы и в Java страдают от той же запутанной многословности, в то время как их эквиваленты в C++ столь же понятны, как и встроенные типы.

Конкатенация текста:

Хорошо, в Java вы также можете использовать … Но, подождите секунду: это перегрузка операторов, не так ли? Разве это не обман?

Общий код?

Одни и те же операнды, модифицирующие общий код, должны использоваться как для встроенных модулей/примитивов (которые не имеют интерфейсов в Java), так и для стандартных объектов (которые не могут иметь правильный интерфейс), и пользовательских объектов.

Например, вычисление среднего значения двух значений произвольных типов:

Даже C и Java имеют (жестко запрограммированную) перегрузку оператора

В C реальное поведение оператора будет меняться в соответствии с его операндами. Например, добавление двух целых чисел отличается от добавления двух удвоений или даже одного целого и одного двойника. Существует даже весь арифметический домен указателя (без кастинга вы можете добавить к указателю целое число, но вы не можете добавить два указателя…).

В Java нет арифметики указателя, но кто-то все еще нашел конкатенацию строк без оператора , было бы смешно достаточно, чтобы оправдать исключение в «перегрузке оператора — это зло».

Это просто, что вы, как C (по историческим причинам) или Java (для личных причин, см. ниже), вы не можете предоставить свои собственные.

Перегрузка методов

Перегрузка методов в Java — случай, когда в классе присутствуют два и более метода с одинаковым именем, но различными параметрами. Данный процесс отличен от переопределения методов. При переопределении методов, метод характеризуется аналогичным именем, типом, числом параметров и т.д.

Рассмотрим пример, который был представлен выше при определении минимальных чисел целочисленного типа. Так допустим, мы хотим определить минимальное число двойного типа. В данном случае будет представлена концепция перегрузки для создания двух и более методов с одинаковым именем, но различными параметрами.

Рассмотренный пример поясняет вышесказанное.

Пример

В итоге будет получен следующий результат:

Методы перегрузки делают программу читаемой. Таким образом, представлены два метода с одинаковым именем, но различными параметрами. В результате чего мы получили минимальные int число и число double типа.

Пример 8: Логические операторы Java

class LogicOperator {
    public static void main(String[] args) {

        int number1 = 1, number2 = 2, number3 = 9;
        boolean result;

        // Хотя бы одно из выражений должно быть истинным, чтобы результат был истиной
        result = (number1 > number2) || (number3 > number1);
        // результат — истина, так как (number1 > number2) истинно
        System.out.println(result);

// Все выражения должны быть истинными, чтобы результат был true
        result = (number1 > number2) && (number3 > number1);
        // Результат будет ложным(false), так как (number3 > number1) ложно
        System.out.println(result);
    }
}

Когда вы запустите программу, на экран выведется:

true
false

Приоритет операторов в Java

Приоритет операторов определяет группирование терминов в выражении. Это влияет как вычисляется выражение. Некоторые операторы имеют более высокий приоритет, чем другие; например оператор умножения имеет более высокий приоритет, чем оператор сложения:

Например, x = 7 + 3 * 2. Здесь x присваивается значение 13, не 20, потому что оператор «*» имеет более высокий приоритет, чем «+», так что сначала перемножается «3 * 2», а затем добавляется «7».

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

Категория	Оператор	Ассоциативность
Постфикс	() [] . (точка)	Слева направо
Унарный	++ — — ! ~	Справа налево
Мультипликативный	* / %	Слева направо
Аддитивный	+ —	Слева направо
Сдвиг	>> >>>	Слева направо
Реляционный	> >=	Слева направо
Равенство	== !=	Слева направо
Побитовое «И» («AND»)	&	Слева направо
Побитовое исключающее «ИЛИ» («XOR»)	^	Слева направо
Побитовое «ИЛИ» («OR»)	\|	Слева направо
Логическое «И» («AND»)	&&	Слева направо
Логическое «ИЛИ» («OR»)	\|\|	Слева направо
Условный	?:	Справа налево
Присваивание	= += -= *= /= %= >>=	Справа налево
Запятая	,	Слева направо

В следующем уроке поговорим об управлении циклом в программировании на Java. В этом уроке будут описаны различные типы циклов, как циклы могут быть использованы в разработке программ, и для каких целей они используются.

Обсуждение перегрузки оператора

Теперь, когда мы увидели справедливые сравнения между кодом C++, использующим перегрузку операторов, и тем же кодом в Java, мы можем теперь обсудить «перегрузку операторов» как концепцию.

Перегрузка оператора существовала еще до появления компьютеров

Даже за пределами компьютерных наук существует перегрузка операторов: например, в математике такие операторы, как , , и т.д. Перегружены.

Действительно, значение , , и т.д. Изменяется в зависимости от типов операндов (чисел, векторов, квантовых волновых функций, матриц и т.д.).

Большинство из нас, как часть наших научных курсов, изучили множество значений для операторов, в зависимости от типов операндов. Мы нашли их смущающими, их?

Перегрузка оператора зависит от его операндов

Это самая важная часть перегрузки операторов: как и в математике или физике, операция зависит от типов ее операндов.

Итак, знайте тип операнда, и вы будете знать эффект операции.

Даже C и Java имеют (жестко запрограммированную) перегрузку операторов

В С реальное поведение оператора будет меняться в зависимости от его операндов. Например, добавление двух целых чисел отличается от добавления двух двойных или даже одного целого и одного двойного. Существует даже целая арифметическая область указателя (без приведения можно добавить к указателю целое число, но нельзя добавить два указателя …).

В Java нет арифметики указателей, но кто-то все еще нашел, что конкатенация строк без оператора была бы достаточно нелепой, чтобы оправдать исключение в кредо «перегрузка оператора — зло».

Просто вы, как C (по историческим причинам) или Java (для личные причинысм. ниже) кодер, вы не можете предоставить свой собственный.

В C++ перегрузка операторов не является обязательной …

В C++ перегрузка операторов для встроенных типов невозможна (и это хорошо), но определяемые пользователем типы могут иметь определяемые пользователем перегрузки оператора.

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

Дело в том, что методы , , предназначены для Java (то есть квазистандартный), Перегрузка операторов C++ является настолько большой частью C++, что становится такой же естественной, как исходные операторы C или ранее упомянутые методы Java.

В сочетании с шаблонным программированием перегрузка операторов становится широко известным шаблоном проектирования. На самом деле, вы не сможете зайти слишком далеко в STL без использования перегруженных операторов и перегрузки операторов для вашего собственного класса.

… но этим нельзя злоупотреблять

Перегрузка оператора должна стремиться соблюдать семантику оператора. Не вычитайте в операторе (как в «не вычитать в функции » или «возвращать в методе «).

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

10 ответов

Лучший ответ

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

Или взгляните на Scala.

По крайней мере, так я и делаю.

starblue
16 Окт 2009 в 12:47

Некоторое время назад у меня было аналогичное требование для использования BigInteger. Это зависит от того, какую жертву производительности вы хотите принести:

Для тестового кода (без требований к производительности) я создал парсер:

Для производственного кода я попытался использовать умный конструктор:

Но, в конце концов, люди, как правило, довольно привыкли к тупому коду и даже предпочитают его: у вас нет перегрузки оператора в jave, так что живите с ним и не пытайтесь создать «умную» абстракцию.

В любом случае, проверьте, что работает с вашей командой.

РЕДАКТИРОВАТЬ: Я не комментировал конкретно ваш пример. Но очевидно, что вызов 42, FORTY_TWO не делает код очень понятным, независимо от вашего подхода. Выбор собственного имени для константы имеет большое значение для прояснения кода:

vdr
16 Окт 2009 в 12:50

Я думаю, мы все можем быть очень счастливы, что перегрузка операторов не вообще поддерживается в java.

Кто хочет поддерживать такую вещь?

gia
16 Окт 2009 в 14:27

mart
22 Май 2012 в 15:33

Мне нравится идея vdr о языке. Но вы можете пропустить парсинг и создать действительно простой eval. Вот пример eval на основе стека. Сложить за 15 минут и далеко не идеально, но идею вы поняли.

z5h
16 Окт 2009 в 14:51

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

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

Jesper
16 Окт 2009 в 12:17

В Java нет возможности перегрузить оператор. Почему бы тебе не перейти на C # ?! знак равно

Или попробуйте написать на Java методы с более короткими именами:

Cipi
16 Окт 2009 в 12:22

Если вы имеете дело только с числовыми значениями, стандартные классы-оболочки (Integer, Double и т. Д.) Будут автоматически распакованы до своих примитивных типов при использовании в выражениях. Совершенно верно следующее:

Fredrick Pennachi
16 Окт 2009 в 13:12

Самый простой способ — это присвоить переменной подвыражения с значимыми именами.

Возможно, вы даже захотите вычислить bsquared и ac4 (fourac?).

Это работает как содержательные комментарии, а также сокращает длину строк исходного текста.

Thorbjørn Ravn Andersen
16 Окт 2009 в 16:51

Я был похож на вас, теперь я нахожу имена классов удобной документацией для самодокументируемого кода. Вам придется самостоятельно найти выход из трудностей, связанных с маркерами комментариев, поскольку это установившаяся практика в Java. Что касается того, к чему стремятся ваши намерения, то в итоге получается своего рода облако. Теперь, если бы я был где-то рядом с информацией, которую необходимо защитить, последнее, чего я хотел бы, — это чтобы данные клиента передавались в облако с помощью небольшого компактного кода. Я расширяю все, работая с постпроцессором на C и работая в нативных вызовах для всего на Java, что я на самом деле намерен защищать.

То, что я вижу в вашем исходном посте, хотя и не для того, чтобы принимать чью-то сторону, — это то, что можно назвать довольно серьезным усилием кода, таким образом:

Какое горе черт возьми, это не только запрос конфетного кода и его выполнение, но и наверняка никуда не приведет в массивных параллельных системах, выполняющих критический код, если вы не написали и компилятор, и домен безопасности, на котором выполняется вышеупомянутое. Я не являюсь и не собираюсь быть даже слегка шутливым — доверие — это то, о чем вы читаете в 18:00, и его любят ваши конкуренты, которые хотят отнять у вас обед. Есть десятки языков, которые делают то, о чем вы просите, почему вы спрашиваете об этом в обсуждениях Java?

Может быть, пришло время познакомиться с лингвистикой, которая делает это == нет недостатка в api и их сторонниках, которые это делают. Код должен быть самодокументированным, для Java это имя класса как то, что он делает.

Nicholas Jordan
16 Окт 2009 в 22:52

Итак … Хорошо … Тогда почему это невозможно в Java?

Потому что Джеймс Гослинг сказал так:

Пожалуйста, сравните текст Гослинга выше со Страуструпом ниже:

Будет ли перегрузка операторов полезной для Java?

Может ли он быть добавлен в Java?

Так что не ждите, пока эта функция …

Но они делают это на C # !!!

Да уж…

Хотя это далеко не единственное различие между двумя языками, этот не может не удивить меня.

По-видимому, люди C #, с их «каждый примитив является , а происходит от Object», правильно понял с первой попытки.

И они делают это на другие языки !!!

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

Пища для размышлений …

Код запутывает?

Этот аргумент является ошибкой.

… даже в стандартных интерфейсах Java

Для другого примера, давайте посмотрим interface в Java:

Вы должны клонировать объект, реализующий этот интерфейс. Но ты мог бы лгать. И создать другой объект. На самом деле, этот интерфейс настолько слаб, что вы можете вернуть объект другого типа, просто для удовольствия:

Поскольку интерфейс может быть злоупотреблен/запутан, должен ли он быть запрещен по тем же причинам, что и перегрузка оператора C++?

Мы можем перегрузить метод класса , чтобы он возвращал строковый час дня. Следует ли запретить перегрузку ? Мы можем саботировать , чтобы он возвращал случайное значение, изменял операнды … и т.д. И т.д.

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