@Milhous: десятичный формат округления превосходный:
Вы также можете использовать
DecimalFormat df = new DecimalFormat("#.00000"); df.format(0.912385);
, чтобы убедиться, что у вас есть конечные 0.
blockquote>Я бы добавил, что этот метод очень хорош в обеспечении реального числового механизма округления - не только визуально, но и при обработке.
Гипотетическая: вам нужно реализовать округление в программу GUI. Чтобы изменить точность / точность результата, просто измените формат каретки (т. Е. В скобках). Так что:
DecimalFormat df = new DecimalFormat("#0.######"); df.format(0.912385);
вернется как результат:
0.912385
DecimalFormat df = new DecimalFormat("#0.#####"); df.format(0.912385);
вернется как результат:
0.91239
DecimalFormat df = new DecimalFormat("#0.####"); df.format(0.912385);
будет return в качестве выхода:
0.9124
[EDIT: также, если формат каретки похож на («# 0. ############»), и вы вводите десятичную, например 3.1415926, для аргументации, DecimalFormat не производит никакого мусора (например, конечных нулей) и вернет:
3.1415926
.. если вы так наклонены. Конечно, это немного многословно для симпатии некоторых разработчиков, но эй, у него низкий объем памяти во время обработки и очень легко реализуется.]Таким образом, красота DecimalFormat заключается в том, что она одновременно обрабатывает внешний вид строки, а также уровень точности округления. Эрго: вы получаете два преимущества по цене одной реализации кода. ;)
Нет, Java не поддерживает пользовательскую перегрузку оператора. Единственный аспект Java, который близок к «пользовательской» перегрузке оператора, - это обработка + для строк, что либо приводит к конкатенации констант, либо времени выполнения, используя StringBuilder / StringBuffer. Вы не можете определить свои собственные операторы, которые действуют одинаково.
Для Java-подобного (и JVM-языка), который делает , поддерживает перегрузку оператора, вы можете посмотрите на Groovy . Кроме того, вы можете найти удачу с Java-компилятором плагина .
Можно попробовать перегрузку 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
Кто не хочет быть / использовать groovy? : D
Нет, вы не можете использовать скомпилированные groovy JARs в Java таким же образом. Это все еще ошибка компилятора для Java.
&
, |
и ^
являются перегрузками для boolean
и целых типов. И действительно, арифметические и реляционные операторы перегружены для различных числовых типов. (Конечно, семантика перегрузок намного ближе ...)
– Stephen C
13 November 2013 в 12:51
Как многие другие ответили: Java не поддерживает пользовательскую перегрузку оператора.
Возможно, это не по теме, но я хочу прокомментировать некоторые вещи, которые я прочитал в некоторых ответах.
О читаемости. Сравнить:
Посмотрите еще раз! Какой из них более читабельен?
Язык программирования, который позволяет создавать пользовательские типы, должен позволять им действовать так же, как и встроенные типы (или примитивные типы).
Итак, Java нарушает фундаментальный принцип универсального программирования: Мы должны иметь возможность обменивать объекты встроенных типов с объектами определяемых пользователем типов. (Возможно, вам интересно: «Был ли он скажем, «объекты встроенного»? »Да, см. здесь .)
О конкатенации строк:
Математики используют symnol + для коммутативных операций на множествах. Поэтому мы можем быть уверены, что 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. Равенство для примитивных типов b. Проверка идентичности для пользовательских типов, поэтому мы вынуждены использовать функцию equals () для равенства. Но ... Как это связано с перегрузкой оператора? Если язык позволяет перегрузке оператора, пользователь может дать правильное значение оператору равенства.
==
используется для равенства в Java, как в C и C ++. Это не имеет ничего общего с перегрузкой оператора.
– Hot Licks
11 October 2014 в 01:01
Java не позволяет перегрузку оператора. Предпочтительным подходом является определение метода для вашего класса для выполнения действия: a.add(b)
вместо a + b
. Вы можете увидеть сводку остальных бит Java, оставшихся вне C-подобных языков здесь: Функции Удалены из C и C ++
В дополнение ко всем людям, указывающим, что +
перегружен для строк, -
также перегружен для операций с плавающей запятой и целыми числами, как и *
и /
.
[edit] %
также перегружен для плавающей запятой, что может быть неожиданностью для тех, у кого есть фон C или C ++.
Перегрузка оператора используется в Java для конкатенации типа String:
String concat = "one" + "two";
Однако вы не можете определить свои собственные перегрузки оператора.
class Program
{
delegate void D1();
delegate string D2();
static string X() { return null; }
static void Y(D1 d1) {}
static void Y(D2 d2) {}
static void Main()
{
Y(X);
}
}
, void Q(Expression<Func<string>> f){}
string M(int x) { ... }
...
int y = 123;
Q(()=>M(y++));
и [f3] являются перегрузками для [f4] и целочисленных типов. И действительно, арифметические и реляционные операторы перегружены для различных числовых типов. (Конечно, семантика перегрузок гораздо ближе ...)
– Stephen C
13 November 2013 в 12:51
BigInteger
в Java, а затем посмотрите на аналогичный код, используяBigInteger
в C #, используя операторы. Я не вижу, как делегаты нарушают принципы ООП - вам нужно быть гораздо точнее, чем в ваших возражениях. Я не знаю подробностей о том, почему разработчики Java не включали в себя различные функции, но я подозреваю, что есть смесь давления ресурсов и желание сохранить язык небольшим и относительно простым. – Jon Skeet 15 May 2013 в 09:47