Перегрузка операторов в Java
Пожалуйста, скажите, можно ли перегрузить операторов на Java? Если он используется где-нибудь в Java, вы могли бы рассказать мне об этом.
ОТВЕТЫ
Ответ 1
Нет, Java не поддерживает пользовательскую перегрузку оператора. Единственный аспект Java, который близок к «пользовательской» перегрузке оператора, — это обработка + для строк, что либо приводит к конкатенации констант, либо времени выполнения, используя StringBuilder/StringBuffer. Вы не можете определить своих собственных операторов, которые действуют одинаково.
Для Java-подобного (и на основе JVM) языка, который поддерживает перегрузку оператора, вы можете посмотреть Groovy. Кроме того, вы можете найти удачу с плагином для компилятора Java.
Ответ 2
Перегрузка операторов используется в Java для конкатенации типа String:
Однако вы не можете определить собственные перегрузки оператора.
Ответ 3
В дополнение ко всем людям, указывающим, что + перегружен для строк, — также перегружен для операций с плавающей запятой и целыми числами, как и * и / .
[править] % также перегружен для плавающей запятой, что может быть неожиданностью для тех, у кого есть фон C или С++.Ответ 4
Java не разрешает перегрузку оператора. Предпочтительным подходом является определение метода для вашего класса для выполнения действия: a.add(b) вместо a + b . Вы можете увидеть сводку остальных бит Java, оставшихся без использования C-подобных языков здесь: Функции Удалены из C и С++
Ответ 5
Вы не можете сделать это самостоятельно, так как Java не разрешает перегрузку оператора.
За одним исключением. + и + = перегружены для объектов String.
Ответ 6
Можно попробовать Перегрузка Java-операторов. Он имеет свои ограничения, но стоит попробовать, если вы действительно хотите использовать перегрузку оператора.
Ответ 7
Как многие другие ответили: Java не поддерживает пользовательскую перегрузку оператора.
Возможно, это не по теме, но я хочу прокомментировать некоторые вещи, которые я прочитал в некоторых ответах.
О читаемости.
Для сравнения:
Посмотрите еще раз! Какой из них более читабельен?
Язык программирования, который позволяет создавать пользовательские типы, должен позволять им действовать так же, как и встроенные типы (или примитивные типы).
Итак, Java нарушает фундаментальный принцип общего программирования:
Мы должны иметь возможность обменивать объекты встроенных типов с объектами пользовательских типов.
(Возможно, вам интересно: «Он сказал» объекты встроенного «?» Да, см. Здесь.)
О конкатенации строк:
Математики используют symnol + для коммутативных операций над множествами. Поэтому мы можем быть уверены, что a + b = b + a.
Конкатенация строк (в большинстве языков программирования) не учитывает эту общую математическую нотацию.
a := "hello"; b := "world"; c := (a + b = b + a); String a = "hello"; String b = "world"; boolean c = (a + b).equals(b + a); Extra:
Обратите внимание на то, как в Java равенство и идентичность сбиты с толку. Символ == (равенство) означает:
а. Равенство для примитивных типов
б. Проверка идентичности для пользовательских типов, поэтому мы вынуждены использовать функцию equals() для равенства.
Но. Что это связано с перегрузкой оператора?
Если язык позволяет перегрузке оператора, пользователь может дать правильное значение оператору равенства.
Ответ 8
Просто используйте 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 >> На официальном сайте есть список методов для каждого оператора!
Ответ 9
Или вы можете сделать Java Groovy и просто перегрузить эти функции, чтобы достичь желаемого.
//plus() => for the + operator //multiply() => for the * operator //leftShift() = for the > def fish = new Fish() def fish2 = new Fish() fish Кто не хочет/использует groovy?: D
Нет, вы не можете использовать скомпилированные JAR файлы groovy в Java таким же образом. Это все еще ошибка компилятора для Java.
Ответ 10
В отличие от C++, Java не поддерживает пользовательскую перегрузку операторов. Перегрузка выполняется внутри Java, мы можем взять + (плюс) для ex: int a = 2 + 4;, string = "hello" + "world"; Здесь плюс добавляет два целых числа и объединяет две строки. Таким образом, мы можем сказать, что Java поддерживает внутреннюю перегрузку операторов, но не определяется пользователем.
Возможно ли перегрузить операторы в Java? [Дубликат]
Итак, я хочу переопределить операторы "+" и "-", чтобы иметь возможность запуска записи следующего кода:
Point p1 = new Point(1, 2); Point p2 = new Point(3, 4); Point resAdd = p1 + p2; // answer (4, 6) Point resSub = p1 - p2; // answer (-2, -2) public Point Add(Point p1, Point p2)
6 ответов
Вы не можете сделать это на Java. Вам необходимо реализовать метод plus или add в вашем классе Point .
class Point < public double x; public double y; public Point(int x, int y)< this.x = x; this.y = y; >public Point add(Point other) < this.x += other.x; this.y += other.y; return this; >> Point a = new Point(1,1); Point b = new Point(2,2); a.add(b); //=> (3,3) // because method returns point, you can chain `add` calls // e.g., a.add(b).add(c) В изменчивом классе было бы нормально изменить существующий экземпляр, хотя лучше сделать Point неизменным значением.
Несмотря на то, что вы не можете сделать это в чистой java, вы можете сделать это с помощью java-oo компилятора плагина. Вам нужно написать метод добавления для оператора +:
public Point add(Point other)
и java-oo подключаются только к операторам desugar для этих вызовов методов.
Вы не можете сделать это в Java, потому что в Java нет перегрузки оператора.
Вы должны использовать второй вариант, который вы упомянули:
Изменить: вы можете добавить метод Add в самом классе Point
public Point Add(Point other)
В изменчивом классе было бы нормально изменить существующий экземпляр, хотя лучше сделать Point неизменным значением. (Кроме того, должен быть в нижнем регистре a в add .)
Вы не можете перегружать операторов в java. Вам понадобится обработать это в классе Point .
Это удивительный конструктор. Конечно, вы не хотите, скажем, сделать статический метод с именем, например, sum ?
В Java нет перегрузки оператора. По-видимому, по соображениям вкуса. Жаль действительно.
(Некоторые люди утверждают, что у Java есть перегрузка, из-за + с String и, возможно, с автобоксированием/распаковкой.)
Расскажите о типах значений.
Многие ранние классы (и некоторые более поздние) делают правильный беспорядок. Особенно в AWT. В AWT вы должны явно делать копии простых значений по всему месту. Почти наверняка вы хотите сделать типы значений неизменяемыми - класс должен быть окончательным, и он никогда не должен изменять состояние (как правило, все поля final , указывающие на эффективные неизменяемые свойства).
public final class Point < private final int x; private final int y; private Point(int x, int y) < this.x = x; this.y = y; >public static of(int x, int y) < return new Point(x, y); >public int x() < return x; >public int y() < return y; >public Point add(Point other) < return of(x+other.x, y+other.y); >// Standard fluffy bits: @Override public int hashCode() < return x + 37*y; >@Override public boolean equals(Object obj) < if (!(obj instanceof Point)) < return false; >Point other = (Point)obj; return x==other.x && y==other.y; > @Override public String toString() < return "("+x+", "+y+")"; >> Исходный код был запутан между int и double , поэтому я выбрал его. Если вы использовали double , вы должны исключить NaN . "Точка" имеет тенденцию подразумевать абсолютную точку, которая не имеет смысла добавлять. "Вектор" или "размерность", вероятно, будет более уместным, в зависимости от того, что вы намерены.
Я скрыл конструктор, поскольку личность не важна. Возможно, значения могут быть кэшированы. Возможно, это, скажем, общий для добавления точки в нулевую точку, поэтому не нужно создавать точки.
Возможно, вам понадобится изменчивая версия, например, для использования в качестве аккумулятора. Это должен быть отдельный класс без отношения наследования. Вероятно, не в простых случаях, но я все равно покажу:
public final class PointBuilder < private int x; private int y; public PointBuilder() < >public PointBuilder(Point point) < this.x = point.x; this.y = point.y; >public Point toPoint() < return new Point(x, y); >public PointBuilder x(int x) < this.x = x; return this; >public PointBuilder y(int y) < this.y = y; return this; >public PointBuilder add(Point other) < this.x += other.x; this.y += other.y; return this; >> Почему Java не поддерживает перегрузку операторов?
Операторы — это специальные символы, которые выполняют определенные операции над одним или несколькими операндами. В некоторых языках программирования, таких как C++ или Python, есть возможность перегрузки операторов. Это означает, что программист может изменить поведение оператора в зависимости от типа данных, с которыми он работает.
Допустим, в языках с поддержкой перегрузки операторов, вы можете использовать оператор «+» для сложения двух чисел, конкатенации двух строк или сложения двух объектов определенного типа, если для этого типа определена перегрузка оператора «+».
# Пример перегрузки оператора "+" в Python class Complex: def __init__(self, real=0, imag=0): self.real = real self.imag = imag def __add__(self, other): return Complex(self.real + other.real, self.imag + other.imag) a = Complex(1, 2) b = Complex(2, 3) c = a + b # Возможно благодаря перегрузке оператора "+"
Однако в Java такой возможности нет. Но почему?
Создатели Java, в частности Джеймс Гослинг, приняли решение не включать перегрузку операторов в язык по следующим причинам:
- Читаемость и понятность кода: Перегрузка операторов может сделать код менее читаемым и понятным. Если оператор «+» может делать совершенно разные вещи в зависимости от контекста, это усложняет понимание кода.
- Сложность языка: Перегрузка операторов добавляет дополнительную сложность в язык программирования. Java всегда стремилась быть простым и понятным языком, и перегрузка операторов могла бы нарушить это стремление.
- Ошибки: Возможность перегрузки операторов увеличивает вероятность ошибок, особенно для новичков. Ошибки могут возникнуть из-за неправильного использования перегруженных операторов или из-за неожиданного их поведения.
Таким образом, несмотря на то что перегрузка операторов может облегчить некоторые задачи и сделать код более кратким, она также может привести к более сложному и менее понятному коду. Именно поэтому в Java было принято решение не поддерживать перегрузку операторов.