Ошибка при инициализации какого-либо значения в локальной переменной? [Дубликат]

На практике все переменные должны быть инициализированы перед их использованием.

Я не могу думать о времени, когда вы захотите использовать переменную перед установкой ее значения (если вы не сравниваете ее с нуль).

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

Ну, в случае локальной переменной ясно, что означает «раньше», поскольку поток программы между объявлением (в методе) и ссылкой последователен. В случае полей, объявленных вне метода, компилятор никогда не знает, какой код будет использоваться, когда он не сможет сгенерировать ошибку, поскольку, возможно, какой-либо другой метод будет инициализировать поле до его использования.

Не совсем верно. Локальные переменные должны быть инициализированы только в качестве ссылки. Локальная переменная может быть оставлена ​​неинициализированной, если ее не ссылать. Например:

int x;  // Valid
int y;
println("y=" + y);  // Not valid since y's value has never been assigned

В Java переменные класса и экземпляра принимают значение по умолчанию (null, 0, false), если они не инициализируются вручную. Однако локальные переменные не имеют значения по умолчанию. Если локальной переменной не присвоено значение, компилятор откажется компилировать код, который его читает. IMHO, это приводит к выводу, что инициализация локальной переменной с некоторым значением по умолчанию (например, null, которое может привести к NullPointerException позже), когда оно объявлено, на самом деле плохо. Рассмотрим следующий пример:

Object o;
if (<some boolean condition>)
  o = <some value>;
else
  o = <some other value>;
System.out.println(o);

Инициализация o с нулем совершенно не нужна, поскольку компилятор Java проверяет во время компиляции, что любой путь кода инициализирует o (с нулевым или некоторое ненулевое значение) перед чтением переменной. Это означает, что компилятор откажется компилировать строку System.out.println(o);, если вы прокомментируете любую из двух инициализаций переменной o в фрагменте кода выше.

Это выполняется для Java и возможно, только для Java. Я не знаю о языке, как C #. Тем не менее, в хорошем старом C (и, возможно, C ++), всегда рекомендуется инициализировать переменные при объявлении их AFAIK. Такие «старые школьные» языки программирования могут быть причиной того, что рекомендация всегда инициализировать переменные появляется в книгах и дискуссиях о современных языках, таких как Java, где компилятор отслеживает, была ли инициализирована переменная или нет.

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

И как основное правило, мы всегда должны инициализировать любую переменную перед использованием Это. В противном случае это может привести к ошибке, например, nullPointer и т. Д.

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

Поэтому, когда стек закончит значение локального метода, поэтому они должны быть инициализированы явно (когда мы их используем) 2] Они не должны быть инициализированы неявно (с помощью null, 0 или false), например, переменные экземпляра