В Java переменные должны быть объявлены во главе функции, или поскольку они необходимы?
Объявление локальной переменной final не будет влиять на сборку "мусора", это только означает, что Вы не можете изменить переменную. Ваш пример выше не должен компилировать, поскольку Вы изменяете переменную totalWeight, который был отмечен final. С другой стороны, объявление примитива (double вместо Double) final будет позволять той переменной быть встроенной в код вызова, так, чтобы мог вызвать некоторую память и повышение производительности. Это используется, когда у Вас есть много public static final Strings в классе.
В целом, компилятор и время выполнения оптимизируют, где это может. Лучше писать код соответственно и не пытаться быть слишком хитрым. Используйте final, когда Вы не захотите, чтобы переменная была изменена. Предположите, что любая легкая оптимизация будет выполнена компилятором, и если Вы волнуетесь по поводу производительности или использования памяти, используйте профилировщика для определения настоящей проблемы.
10 ответов
Объявляйте переменные как можно ближе к первому месту, где вы их используете. На самом деле это не имеет ничего общего с эффективностью, но делает ваш код более читабельным. Чем ближе переменная объявлена к тому месту, где она используется, тем меньше прокрутки / поиска вам придется выполнять при чтении кода позже. Объявление переменных ближе к первому месту, которое они используют, также естественным образом сузит их область действия .
Правильный способ - объявить переменные именно тогда, когда они впервые используются, и минимизировать их область действия, чтобы упростить понимание кода.
Объявление переменных в верхней части функций - это задержка. из C (там, где это было необходимо) и не имеет абсолютно никаких преимуществ (область видимости переменной существует только в исходном коде, в байтовом коде все локальные переменные в любом случае существуют последовательно в стеке). Просто не делайте этого, никогда.
Некоторые люди могут попытаться защитить практику, утверждая, что она «более аккуратная», но любая необходимость «организовать» код внутри метода обычно является убедительным признаком того, что метод просто слишком долго.
Из Соглашения о коде Java , Глава 6 об объявлениях :
6.3 Размещение
Поместите объявления только в начало блоков. (Блок - это любой код в фигурных скобках "{" и "}".) Не ждите объявления переменных до первого использования; это может сбить с толку неосторожный программист и мешающий код переносимость в пределах области видимости.
void myMethod () { int int1 = 0; // начало блока метода if (условие) { int int2 = 0; // начало блока "если" ... } }Единственным исключением из правил является индексы циклов, которые в Java можно объявить в операторе for:
for (int i = 0; iИзбегайте местных заявлений, скрывающих декларации на более высоких уровнях. За пример, не заявляйте то же самое имя переменной во внутреннем блоке:
int count; ... myMethod () { if (условие) { int count = 0; // ИЗБЕГАЙТЕ! ... } ... }
Определение переменной в более широком диапазоне, чем необходимо, несколько затрудняет понимание. Ограниченная область видимости сигнализирует о том, что эта переменная имеет значение только для этого небольшого блока кода, и вы можете не думать об этом при дальнейшем чтении. Это довольно важная проблема из-за крошечной кратковременной рабочей памяти, имеющейся у мозга (он сказал, что в среднем вы можете отслеживать только 7 вещей). Важна одна вещь, за которой нужно следить меньше.
Точно так же вы действительно должны стараться избегать переменных в буквальном смысле. Попробуйте назначить все один раз и объявить их окончательными, чтобы это было известно читателю. Отсутствие необходимости отслеживать, меняется что-то или нет, действительно снижает когнитивную нагрузку.
Я обнаружил, что объявление их как необходимых приводит к меньшему количеству ошибок, чем объявление их в начале. Я также обнаружил, что объявление их в минимально возможном объеме позволяет также предотвратить ошибки.
Когда я посмотрел на байт-код, сгенерированный местоположением объявления несколько лет назад, я обнаружил, что они были более или менее идентичны . Иногда были различия в зависимости от того, когда они были назначены.
Если у вас есть kabillion переменных, используемых в различных изолированных местах внутри тела функции, ваша функция слишком велика.
Если ваша функция удобного для понимания размера, нет никакой разницы между «все впереди» и «по мере необходимости».
Единственная переменная, не являющаяся авансом, может быть в теле оператора for .
for( Iterator i= someObject.iterator(); i.hasNext(); )
Я думаю, что на самом деле можно объективно доказать, что стиль объявления наверху более подвержен ошибкам.
Если вы изменяете тестовый код в любом стиле, перемещая строки вокруг random (чтобы смоделировать неудачное слияние или кто-то бездумно вырезал + вставил), тогда у стиля declare-at-the-top больше шансов на компиляцию, хотя он функционально неверен.
Я не думаю, что declare-at-the- top имеет соответствующее преимущество, не зависящее от личных предпочтений.
Итак, если вы хотите написать надежный код, научитесь предпочесть выполнение своевременного объявления.
Я видел, как люди объявляли функции вверху и внизу. Я предпочитаю верхнюю часть, где я их быстро вижу. Это вопрос выбора и предпочтений.
I я делаю то же самое в данный момент. Все переменные в коде, который я переделываю, объявлены в верхней части функции. Когда я просматривал это, я видел, что несколько переменных объявлены, но НИКОГДА не используются, или они объявлены, и с ними выполняются операции (например, анализ String , а затем установка Calendar со значениями даты / времени из строки), но затем результирующий объект Calendar НИКОГДА не используется.
Я просматриваю и очищаю их, беря объявления сверху и перемещая их вниз в функции до места ближе к тому месту, где она используется.
Это вопрос удобочитаемости и личных предпочтений, а не производительности. Компилятору все равно, и он все равно сгенерирует тот же код.