Változó láthatóság

Lokális változók

"Üdvözlöm, szeretett tanítványom! Itt az ideje, hogy egy kicsit komolyabban foglalkozzunk a változókkal. Ezúttal azonban nem a belső szerkezetükről fogunk beszélni. Ehelyett arra fogunk összpontosítani, hogy a változók hogyan hatnak egymásra a kóddal, ahol találhatók.

"A metódusokon belül deklarált összes változót lokális változónak nevezzük . A lokális változó csak abban a kódblokkban létezik, amelyben deklarálták. Pontosabban, a deklarálás pillanatától a blokk végéig létezik. annak a kódnak, amelyben deklarálva van."

– Egyértelmű, hogy kell egy példa.

"Semmi probléma. Tessék:

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

"Még egyszer nézzük át a helyi változókhoz való hozzáférés szabályait. Itt van egy kódblokk. Mi jelzi a kezdetét és a végét?"

– Göndör fogszabályzó?

"Helyes. Ez lehet egy 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. Mondd meg, hol fog akkor létezik változó, ha egy ciklus törzsében van deklarálva?"

"Csak a hurok testében fog létezni."

"Így van. Mi több, a ciklus minden iterációja során létrejön és megsemmisül."

"Ez azt jelenti, hogy nem deklarálhat két azonos nevű helyi változót egy metódussal – a program nem fog lefordítani. De ezt megteheti, ha a változókat deklaráló kódblokkok nem fedik át egymást. "

"Megvan az oka annak, amiért te vagy a kedvencem, Amigo. Vegyünk még egy példát, hogy megszilárdítsd ezt az agyadban.

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 névre szóló helyi változót, bmert az első bváltozó nem látható abban a kódblokkban, ahol a második bváltozót deklarálták.

Paraméterek

"Ahogy korábban is mondtuk, minden módszernek lehetnek változói, amelyeket paramétereknek nevezünk. Mi a helyzet a láthatóságukkal és az élettartamukkal?"

"Hmm... meg vagyok döbbenve..."

"Itt minden nagyon egyszerű. 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).

– Más szóval, a módszer egészében és csak ott láthatók?

"Igen. 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

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

Változók egy osztályban

"Emlékezzen az 1. szint leckéire, ahol azt mondtuk, 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.

"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."

– És minek vannak ott?

"Elsőként 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 metódusunk 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."

"Mindent megértek! A lokális változók léteznek a metódus végrehajtása közben. Egy osztály példányváltozói mindaddig léteznek egy osztály objektumában, amíg az objektum létezik."

"Jól van, Amigo. Leraktuk az alapot, és a következő szinten megtudhatja az osztály tárgyainak részleteit.

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á.

"Még nincs tisztában a statikus változókkal."

"Ó, tudom, de ne aggódj. Egyelőre csak érezd jól magad. Ismerkedj meg velük. A 11. szinten elemezzük a statikus változók és módszerek szerkezetét, és megérted ezek okait korlátozásokat.

"Statikus változó (osztályváltozó) létrehozásához meg kell írni 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álták őket. 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 . más osztályokból olyan konstrukció használatával, mint:

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 külön osztályt hoztunk létre , ebbe Storageáthelyeztük 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 elérhetőek (és nem csak metódusból)."sum

– Nem teljesen értem, de ez kényelmesnek tűnik számomra.

"Így van. És néha szükséges is. Statikus változók és módszerek nélkül megrekednénk."

– Remélhetőleg lassan rájövök.

– Igen, természetesen.