Variable visibility

Mga lokal na variable

"Pagbati, mahal kong mag-aaral! Panahon na upang maging seryoso tungkol sa mga variable. Ngunit sa pagkakataong ito ay hindi natin tatalakayin ang kanilang panloob na istraktura. Sa halip, tututuon natin kung paano nakikipag-ugnayan ang mga variable sa code kung saan sila matatagpuan.

"Lahat ng mga variable na idineklara sa loob ng mga pamamaraan ay tinatawag na mga lokal na variable . Ang isang lokal na variable ay umiiral lamang sa bloke ng code kung saan ito idineklara. O, upang maging mas tumpak, ito ay umiiral mula sa sandaling ito ay idineklara hanggang sa katapusan ng bloke. ng code kung saan ito idineklara."

"Malinaw, kailangan ko ng isang halimbawa."

"Walang problema. Heto:

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

"Suriin natin ang mga panuntunan para sa pag-access ng mga lokal na variable nang isa pang beses. Narito ang isang bloke ng code. Ano ang marka ng simula at pagtatapos nito?"

"Kulot na braces?"

"Tama. Ito ay maaaring isang katawan ng pamamaraan, ang katawan ng isang loop, o isang bloke lamang ng code para sa isang conditional na pahayag. Umiiral ang isang variable na idineklara sa isang bloke ng code hanggang sa katapusan ng bloke ng code na iyon. Sabihin mo sa akin, kung saan umiiral ang isang variable kung ito ay idineklara sa katawan ng isang loop?"

"Iiral lamang ito sa katawan ng loop."

"Tama. Higit pa rito, ito ay malilikha at masisira sa bawat pag-ulit ng loop."

"Nangangahulugan iyon na hindi ka maaaring magdeklara ng dalawang lokal na variable na may parehong pangalan sa isang paraan — hindi mag-compile ang program. Ngunit magagawa mo ito kung ang mga bloke ng code kung saan idineklara ang mga variable ay hindi magkakapatong . "

“May dahilan kung bakit ikaw ang paborito ko, Amigo. Kumuha ka ng isa pang halimbawa para patatagin ito sa utak mo.

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

"Nakapagdeklara kami ng pangalawang lokal na variable na pinangalanan blamang dahil ang unang bvariable ay hindi nakikita sa block ng code kung saan bidineklara ang pangalawang variable.

Mga Parameter

"Tulad ng sinabi namin dati, ang bawat pamamaraan ay maaaring magkaroon ng mga variable na tinatawag naming mga parameter. Paano ang kanilang visibility at panghabambuhay?"

"Hmm... nalilito ako..."

"Medyo simple ang lahat dito. Nalilikha ang mga parameter kapag ang pagpapatupad ay nakapasok sa pamamaraan (ibig sabihin, kapag ang code ng pamamaraan ay nagsimulang magsagawa). Inaalis ang mga ito kapag natapos na ang pamamaraan."

"Sa madaling salita, makikita ang mga ito sa buong katawan ng pamamaraan at doon lamang?"

"Oo. Halimbawa:

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

"Tulad ng sinabi namin kanina, argsay isang variable lamang na ang uri ay isang array ng mga string. At tulad ng lahat ng mga parameter, ito ay magagamit saanman sa loob ng katawan ng pamamaraan. Sabi nga, karaniwan naming binabalewala ito sa aming mga halimbawa.

Mga variable sa isang klase

"Alalahanin ang mga aralin sa Level 1, kung saan sinabi namin na ang isang klase ay maaaring magkaroon ng mga pamamaraan at variable. Ang mga pamamaraan ay minsan tinatawag na mga pamamaraan ng halimbawa, at mga variable — mga variable o field ng halimbawa.

"Ano ang mga variable (o mga patlang) ng isang klase ?

Ang mga ito ay mga variable na idineklara hindi sa isang pamamaraan, ngunit sa isang klase."

"At para saan sila doon?"

"Para sa mga panimula, maaari silang ma-access mula sa anumang (non-static) na paraan ng isang klase. Sa madaling salita, ang mga variable ng instance ay mga variable na ibinabahagi ng lahat ng mga pamamaraan ng isang klase.

Halimbawa:

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

"Sa halimbawang ito, mayroon kaming dalawang pamamaraan — add()at remove(). add()Dinaragdagan ng pamamaraan ang mga variable ng sumat countinstance, at remove()binabawasan ng paraan ang mga variable sumat count. Gumagana ang parehong mga pamamaraan sa mga variable na instance."

"Naiintindihan ko ang lahat ng ito! Umiiral ang mga lokal na variable habang isinasagawa ang isang pamamaraan. Ang mga variable ng instance ng isang klase ay umiiral sa loob ng isang bagay ng isang klase hangga't umiiral ang bagay na iyon."

"Magaling, Amigo. Naglagay kami ng ilang batayan, at malalaman mo ang mga detalye tungkol sa mga bagay ng isang klase sa susunod na antas.

Mga static na variable

"Tulad ng mga pamamaraan, ang mga variable sa isang klase ay maaaring static o non-static. Ang mga static na pamamaraan ay maaari lamang mag-access ng mga static na variable.

"Wala pa akong malinaw na pag-unawa sa mga static na variable."

"Oh, alam ko, pero huwag kang mag-alala. Sa ngayon, maging komportable ka lang sa kanila. Maging pamilyar sa kanila. Sa Level 11, susuriin natin ang istruktura ng mga static na variable at pamamaraan at mauunawaan mo ang mga dahilan para sa mga ito. mga paghihigpit.

"Upang gumawa ng static na variable (class variable), dapat mong isulat ang statickeyword sa deklarasyon nito.

"Ang mga static na variable ay hindi nakatali sa isang object o instance ng klase kung saan idineklara ang mga ito. Sa halip, nabibilang sila sa klase mismo. Iyon ang dahilan kung bakit umiiral ang mga ito kahit na wala ni isang object ng klase ang nalikha . Maaari kang sumangguni sa sila mula sa iba pang mga klase gamit ang isang konstruksyon tulad ng:

ClassName.variableName

Halimbawa:

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

"Sa halimbawa sa itaas, lumikha kami ng isang hiwalay Storagena klase, inilipat ang countat summga variable dito, at idineklara silang static . Maaaring ma-access ang mga pampublikong static na variable mula sa anumang paraan sa isang programa (at hindi lamang mula sa isang paraan)."

"Hindi ko lubos na naiintindihan, ngunit ito ay tila maginhawa sa akin."

"Kaya nga. At kung minsan ito ay kinakailangan. Kung wala ang mga static na variable at pamamaraan ay maiipit tayo."

"Sana, dahan-dahan kong maisip."

"Oo, siyempre gagawin mo."