Почему локальные переменные не инициализируются в Java?

Question

Была ли причина, по которой разработчики Java чувствовали, что локальным переменным не следует присваивать значение по умолчанию? Серьезно, если переменным экземпляра можно присвоить значение по умолчанию, то почему мы не можем сделать то же самое для локальных переменных?

И это также приводит к проблемам, как объяснено в this comment to a blog post:

Ну это правило расстраивать при попытке закрыть ресурс в конце концов блока. Если я создам ресурс внутри попытки, но попытаюсь закрыть его в конце, я получаю эту ошибку. Если я перемещаю экземпляр вне try, я получаю еще одну ошибку, заявляя, что она должна быть в попытке.

Очень расстраивает.

Answer 1

Я думаю, что основная цель состояла в том, чтобы поддерживать сходство с C/C++. Однако компилятор обнаруживает и предупреждает вас об использовании неинициализированных переменных, которые уменьшают проблему до минимальной точки. С точки зрения производительности, немного быстрее, чтобы вы могли объявлять неинициализированные переменные, поскольку компилятору не нужно писать оператор присваивания, даже если вы переписываете значение переменной в следующем выражении.

Answer 2

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

Answer 3

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

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

Answer 4

The "problem" you link to, кажется, описывая эту ситуацию: жалоба

SomeObject so; 
try { 
    // Do some work here ... 
    so = new SomeObject(); 
    so.DoUsefulThings(); 
} finally { 
    so.CleanUp(); // Compiler error here 
} 

комментатора является то, что компилятор уклоняется в строке в разделе finally, утверждая, что so может быть инициализирован. Комментарий затем упоминает еще один способ написания кода, вероятно, что-то вроде этого:

// Do some work here ... 
SomeObject so = new SomeObject(); 
try { 
    so.DoUsefulThings(); 
} finally { 
    so.CleanUp(); 
} 

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

В любом случае, эта вторая версия кода является правильным способом ее написания. В первой версии сообщение об ошибке компилятора было правильным. Переменная so может быть неинициализирована.В частности, если конструктор SomeObject терпит неудачу, so не будет инициализирован, и поэтому будет предпринята попытка вызвать вызов so.CleanUp. Всегда вводите try раздел после вы приобрели ресурс, который завершает раздел finally.

try - finally блок после so инициализации есть только защитить экземпляр SomeObject, чтобы убедиться, что он не получает очищены независимо от того, что еще происходит. Если есть другие вещей, которые должны работать, но они не связаны ли выделена экземпляр SomeObject собственности, то они должны идти в другогоtry - блок finally, вероятно, тот, который облегает один я показал ,

Обязательные переменные, назначаемые вручную перед использованием, не приводят к возникновению реальных проблем. Это только приводит к незначительным неприятностям, но ваш код будет лучше для него. У вас будут переменные с более ограниченной областью, и try - finally блоки, которые не пытаются защитить слишком много.

Если локальные переменные имели значения по умолчанию, то so в первом примере было бы null. Это ничего бы не решило. Вместо того, чтобы получить ошибку времени компиляции в блоке finally, у вас будет NullPointerException, скрывающийся там, где может быть скрыть. Любое другое исключение может возникнуть в разделе «Сделайте некоторые работы здесь». (Или делать исключения в разделах finally, которые автоматически соединяются с предыдущим исключением? Я не помню. Тем не менее, у вас было бы лишнее исключение на пути реального.)

Answer 5

Eclipse даже дает вам предупреждения о неинициализации переменные, поэтому в любом случае это становится совершенно очевидным. Лично я думаю, что хорошо, что это поведение по умолчанию, иначе ваше приложение может использовать неожиданные значения, и вместо компилятора, бросающего ошибку, он ничего не сделает (но, возможно, даст предупреждение), а затем вы будете царапать ваша голова о том, почему некоторые вещи не совсем ведут себя так, как должны.

Answer 6

Более эффективно не инициализировать переменные, а в случае локальных переменных это безопасно, так как инициализация может отслеживаться компилятором.

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

Answer 7

Кроме того, в приведенном ниже примере, исключение может быть брошено внутри конструкции SomeObject, в этом случае «так» переменная будет пустой и призыв к очищающей будет бросать NullPointerException

SomeObject so; 
try { 
    // Do some work here ... 
    so = new SomeObject(); 
    so.DoUsefulThings(); 
} finally { 
    so.CleanUp(); // Compiler error here 
} 

Что Я, как правило, сделать это:

SomeObject so = null; 
try { 
    // Do some work here ... 
    so = new SomeObject(); 
    so.DoUsefulThings(); 
} finally { 
    if (so != null) { 
    so.CleanUp(); // safe 
    } 
} 

Answer 8

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

Answer 9

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

Для меня причина сводится к следующему: назначение локальных переменных отличается от цели переменных экземпляра. Локальные переменные должны использоваться как часть расчета; переменные экземпляра содержат состояние. Если вы используете локальную переменную без присвоения ей значения, это почти наверняка логическая ошибка.

Это говорит о том, что я мог полностью отстать, требуя, чтобы переменные экземпляра всегда были явно инициализированы; ошибка будет возникать на любом конструкторе, где результат допускает неинициализированную переменную экземпляра (например, не инициализируется при объявлении, а не в конструкторе). Но это не решение Гослинга и др. в начале 90-х годов, так что мы здесь. (И я не говорю, что они ошиблись.)

Я мог бы , но не отстать от локальных переменных по умолчанию. Да, мы не должны полагаться на компиляторы, чтобы проверить нашу логику, а другая нет, но она по-прежнему удобна, когда компилятор ловит ее. :-)

Answer 10

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

Почему бы не сделать дополнительный шаг? Сделайте шаг назад - никто не упомянул, что «предупреждение» в этом случае - очень хорошая вещь.

Вы никогда не должны инициализировать свою переменную нулевым или нулевым на первом проходе (когда вы сначала его кодируете). Либо присвойте его фактическому значению, либо не назначьте его вообще, потому что, если вы этого не сделаете, java может сказать вам, когда вы действительно испортите. Возьмите ответ Electric Monk как отличный пример. В первом случае на самом деле удивительно полезно, что он говорит вам, что если try() терпит неудачу, потому что конструктор SomeObject создал исключение, то в конечном итоге вы получите NPE. Если конструктор не может генерировать исключение, он не должен быть в try.

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

Кроме того, не лучше ли прямо указывать «int size = 0», а не «int size», и заставить следующего программиста понять, что вы намерены считать его нулевым?

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

Answer 11

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

Answer 12

я мог думать о следующих 2 причины

1. Как и большинство ответов сказал, поставив ограничение на инициализацию локальной переменной, то гарантируется, что локальная переменная получает присваивается значение, как программист хочет и обеспечивает ожидается результаты вычисляются.
2. Переменные экземпляра могут быть скрыты путем объявления локальных переменных (одно имя) - для обеспечения ожидаемого поведения локальные переменные вынуждены инициализировать значение.(Полностью избежал бы этого, хотя)

Answer 13

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