Változó láthatóság

1. Lokális változók

Beszéljünk komolyabban a változókról. De ezúttal nem a belső felépítésüket tárgyaljuk. Ehelyett arra összpontosítunk, hogy a változók hogyan lépnek kapcsolatba a kóddal, ahol találhatók.

A metódusokon belül deklarált összes változót helyi változónak nevezzük . A lokális változó csak abban a kódblokkban létezik, amelyben deklarálva van. Pontosabban, attól a pillanattól kezdve létezik, amikor deklarálják, annak a kódblokknak a végéig, amelyben deklarálják.

Az egyszerűség kedvéért nézzünk egy példát:

public static void main(String[] args)
{
   int a = 5;
   if (a < 10)
   {
     int b = 10;
     while (true)
     {
       int x = a + b;
       System.out.println(x);
     }
     System.out.println(b);
   }

}

a
a
a
a, b
a, b
a, b
a, b, x
a, b, x
a, b
a, b
a
a

Beszéljünk még egyszer a helyi változók eléréséről. Itt van egy kódblokk, amely kapcsos kapcsos zárójelekből áll: ez lehet metódustörzs, egy ciklus törzse, vagy csak egy kódblokk egy feltételes utasításhoz. A kódblokkban deklarált változó a kódblokk végéig létezik.

Ha egy változót a ciklus törzsében deklarálunk, akkor az csak a ciklus törzsében fog létezni. A ciklus minden iterációja során létrejön és megsemmisül.

Példa:

public static void main(String[] args)
{
   int a = 5;
   if (a < 10)
   {
     int b = 10;
     System.out.println(b);
   }

   if (a < 20)
   {
     int b = 20;
     System.out.println(b);
   }
}

a
a
a
a, b
a, b
a
a
a
a
a, b
a, b
a

Csak azért tudtunk deklarálni egy második nevű helyi változót, b mert az első b változó nem látható abban a kódblokkban, ahol a második bváltozót deklarálták.

2. Paraméterek

Mint korábban említettük, minden metódusnak lehetnek változói, amelyeket paramétereknek nevezünk. Mi a helyzet a láthatóságukkal és az élettartamukkal?

Minden egyértelmű. A paraméterek akkor jönnek létre, amikor a végrehajtás belép a metódusba (azaz amikor a metódus kódja elindul). A módszer végén megszűnnek. A módszer egészében láthatóak.

Példa:

public static void main(String[] args)
{
   int a = 5;
   if (a < 10)
   {
     int b = 10;
     while (true)
     {
       int x = a + b;
       System.out.println(x);
     }
     System.out.println(b);
   }

}

args
args, a
args, a
args, a
args, a, b
args, a, b
args, a, b
args, a, b, x
args, a, b, x
args, a, b
args, a, b
args, a
args, a

Mint korábban említettük, argsez csak egy változó, amelynek típusa karakterláncok tömbje. És mint minden paraméter, ez is mindenhol elérhető a módszer törzsében. Ennek ellenére általában figyelmen kívül hagyjuk a példáinkban.

3. Változók egy osztályban

Emlékszel az 1. szint leckéiből, hogy egy osztálynak lehetnek metódusai és változói. A metódusokat néha példánymetódusoknak, a változókat pedig példányváltozóknak vagy mezőknek nevezik. Ezek tulajdonképpen szinonimák a Java nyelven.

Melyek egy osztály változói (vagy mezői)?

Ezek olyan változók, amelyeket nem egy metódusban, hanem egy osztályban deklarálnak.

Az osztály bármely (nem statikus) metódusából elérhetők. Durván szólva a példányváltozók olyan változók, amelyeket egy osztály összes metódusa megoszt .

Példa:

public class Solution
{
   public int count = 0;
   public int sum = 0;

   public void add(int data)
   {
     sum = sum + data;
     count++;
   }

   public void remove(int data)
   {
     sum = sum - data;
     count--;
   }
}

count
count, sum
count, sum
count, sum
count, sum, data
count, sum, data
count, sum, data
count, sum
count, sum
count, sum
count, sum, data
count, sum, data
count, sum, data
count, sum
count, sum

Ebben a példában két módszerünk van – add()és remove(). A add()metódus növeli a sumés countpéldányváltozókat, a remove()metódus pedig csökkenti a sum és countváltozókat. Mindkét módszer megosztott példányváltozókon működik.

Lokális változók léteznek a metódus végrehajtása közben. Az osztály példányváltozói mindaddig léteznek egy osztály objektumán belül , amíg az objektum létezik. A következő szinten megtudhatja az osztály objektumainak részleteit.

4. Statikus változók

A metódusokhoz hasonlóan az osztály változói lehetnek statikusak vagy nem statikusak. A statikus metódusok csak statikus változókhoz férhetnek hozzá.

A 11. szinten elemezzük a statikus változók és módszerek szerkezetét, és meg fogja érteni e korlátozások okait.

Statikus változó (osztályváltozó) készítéséhez be kell írnia a statickulcsszót a deklarációjába.

A statikus változók nincsenek annak az osztálynak az objektumához vagy példányához kötve, amelyben deklarálva vannak. Ehelyett magához az osztályhoz tartoznak. Ezért léteznek még akkor is, ha az osztályból egyetlen objektum sem jött létre . Hivatkozhat rájuk más osztályokból egy konstrukcióval, például:

ClassName.variableName

Példa:

public class Solution
{
   public void add(int data)
   {
     Storage.sum = Storage.sum + data;
     Storage.count++;
   }

   public void remove(int data)
   {
     Storage.sum = Storage.sum - data;
     Storage.count--;
   }
}

public class Storage
{
   public static int count = 0;
   public static int sum = 0;
}

Storage.count, Storage.sum
Storage.count, Storage.sum
Storage.count, Storage.sum, data
Storage.count, Storage.sum, data
Storage.count, Storage.sum, data
Storage.count, Storage.sum
Storage.count, Storage.sum
Storage.count, Storage.sum
Storage.count, Storage.sum, data
Storage.count, Storage.sum, data
Storage.count, Storage.sum, data
Storage.count, Storage.sum



Storage.count, Storage.sum
Storage.count, Storage.sum
Storage.count, Storage.sum

A fenti példában létrehoztunk egy külön Storageosztályt, áthelyeztük  abba a count és változókat, és statikusnak nyilvánítottuk őket . A nyilvános statikus változók a program bármely metódusából (és nem csak metódusból) elérhetők.sum