Как возможно, что переменная может быть повторно объявлена ​​в цикле?

Question

Этот код не работает:

public class Test 
{ 
    public static void main(String[] args) 
    { 
     int i=3; 
     int i=4; 
     System.out.println(i); 
    } 
} 

Тогда почему этот код работает?

public class Test 
{ 
    public static void main(String[] args) 
    { 
     for(int a=0;a<9;a++) 
     { 
      int b=a+1; 
      System.out.println(b); 
     } 
    } 
} 

Разве мы вновь объявить b снова и снова?

Answer 1

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

Это эквивалентно записи:

{ 
     int b=1; 
     System.out.println(b); 
    } 
    { 
     int b=2; 
     System.out.println(b); 
    } 
    { 
     int b=3; 
     System.out.println(b); 
    } 
    .... 

Answer 2

срок службы int b только до итерации цикла for, поэтому каждый раз, когда вы выполняете итерацию, каждый получает новое значение с объявлением.

В первом еи

int i=3; 
    int i=4; 

вы intialising i два раза, а это может быть

int i=3; 
i=4; 

поэтому значение I будет 4, помните INT I делает его переменной, и его значение может быть переопределено в его блоке объявления

Answer 3

В

public class Test { 
    public static void main(String[] args) { 
      int i=3; 
      int i=4; 
      System.out.println(i); 
    } 

Вы объявляете же имя переменной дважды. И В

 public class Test { 
     public static void main(String[] args) { 
      for(int a=0;a<9;a++) { 
      int b=a+1; 
      System.out.println(b); 
      } 
     } 
    } 

Здесь Ь локальная переменная внутри для цикла, и вы объявляете его в начале цикла. И внутри этого цикла нет повторяющегося имени.

Answer 4

Ваш первый пример будет работать с блоком

int i=3; 
{ 
    int i=4; 
    System.out.println(i); 
} 

Это создает новый «я», что тени первый «я» в лексической области видимости блока.

Answer 5

Это происходит из-за объема переменной,

Вариант 1:

public class Test 
{ 
public static void main(String[] args) 
{ 
    int i=3; 
    int i=4; 
    System.out.println(i); 
} 
} 

В здесь есть переменная я, определенный в том же объеме в два раза.

Случай 2:

public class Test 
{ 
public static void main(String[] args) 
{ 
    for(int a=0;a<9;a++) 
    { 
     int b=a+1; 
     System.out.println(b); 
    } 
} 
} 

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

Предлагаю вам перейти через область переменных в JAVA.

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

---

Update

public class Test1 { 
public static void main(String[] args) { 

    Person p1=new Person(); 
    System.out.println("Person Object p1 before for loop "+p1); 

    for(int i=0;i<5;i++){ 
     Person p2=new Person(); 
     System.out.println("Person object "+i+" "+p2); 
    } 

    System.out.println("Person Object p1 after for loop "+p1); 

} 
} 

пустышка класс Person

class Person{ } 

Выход

Person Object p1 before for loop com.project.CVS.Person@fd13b5 
Person object 0 com.project.CVS.Person@118f375 
Person object 1 com.project.CVS.Person@117a8bd 
Person object 2 com.project.CVS.Person@471e30 
Person object 3 com.project.CVS.Person@10ef90c 
Person object 4 com.project.CVS.Person@a32b 
Person Object p1 after for loop com.project.CVS.Person@fd13b5 

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

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

Answer 6

Локальные переменные с областью цикла задаются в памяти, поскольку они инициализируются, и место памяти уничтожается, как только оно выходит из области видимости, так как предыдущая запись «b» b не может быть объявлена ​​еще раз . Но это не относится к переменной «a» с основной областью, потому что вы объявляете снова в главном, где уже есть запись переменной «a», поэтому вы не можете ее дублировать.