Variabele zichtbaarheid

Lokale variabelen

"Gegroet, mijn geliefde student! Het is tijd om wat serieuzer te worden over variabelen. Maar deze keer zullen we hun interne structuur niet bespreken. In plaats daarvan zullen we ons concentreren op hoe variabelen omgaan met de code waar ze zich bevinden.

"Alle variabelen die binnen methoden worden gedeclareerd, worden lokale variabelen genoemd . Een lokale variabele bestaat alleen in het codeblok waarin deze is gedeclareerd. Of, om preciezer te zijn, hij bestaat vanaf het moment dat hij wordt gedeclareerd tot het einde van het blok. code waarin het is gedeclareerd."

"Het is duidelijk dat ik een voorbeeld nodig heb."

"Geen probleem. Alsjeblieft:

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

'Laten we de regels voor toegang tot lokale variabelen nog een keer doornemen. Hier is een codeblok. Wat markeert het begin en het einde ervan?'

"Accolades?"

"Juist. Dit kan een methodebody zijn, de body van een lus, of gewoon een codeblok voor een voorwaardelijke instructie. Een variabele gedeclareerd in een codeblok bestaat tot het einde van dat codeblok. Vertel me, waar zal een variabele bestaat als deze wordt gedeclareerd in de body van een lus?"

"Het zal alleen in de body van de lus bestaan."

"Dat klopt. Bovendien wordt het bij elke iteratie van de lus gemaakt en vernietigd."

"Dat betekent dat je niet twee lokale variabelen met dezelfde naam in één methode kunt declareren - het programma zal niet compileren. Maar je kunt dit wel doen als de codeblokken waarin de variabelen worden gedeclareerd elkaar niet overlappen. "

"Er is een reden waarom je mijn favoriet bent, Amigo. Neem nog een voorbeeld om dit in je brein te verstevigen.

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

"We konden een tweede lokale variabele declareren, balleen omdat de eerste bvariabele niet zichtbaar is in het codeblok waarin de tweede bvariabele is gedeclareerd.

Parameters

"Zoals we al eerder zeiden, kan elke methode variabelen hebben die we parameters noemen. Hoe zit het met hun zichtbaarheid en levensduur?"

"Hmm... ik ben stomverbaasd..."

"Alles is hier vrij eenvoudig. Parameters worden gemaakt wanneer uitvoering in de methode stapt (dwz wanneer de code van de methode begint uit te voeren). Ze worden geëlimineerd wanneer de methode eindigt."

"Met andere woorden, ze zijn zichtbaar in het hele lichaam van de methode en alleen daar?"

"Ja. Voorbeeld:

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

"Zoals we eerder zeiden, argsis het slechts een variabele waarvan het type een reeks strings is. En zoals alle parameters is het overal beschikbaar binnen de body van de methode. Dat gezegd hebbende, negeren we het meestal in onze voorbeelden.

Variabelen in een klasse

"Denk aan de lessen in niveau 1, waar we zeiden dat een klasse methoden en variabelen kan hebben. Methoden worden soms instantiemethoden genoemd, en variabelen - instantievariabelen of velden.

"Wat zijn de variabelen (of velden) van een klasse ?

Het zijn variabelen die niet in een methode worden gedeclareerd, maar in een klasse."

"En waarvoor zijn ze daar?"

"Om te beginnen zijn ze toegankelijk vanaf elke (niet-statische) methode van een klasse. Grofweg zijn instantievariabelen variabelen die worden gedeeld door alle methoden van een klasse.

Voorbeeld:

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

"In dit voorbeeld hebben we twee methoden - add()en remove(). De add()methode verhoogt de instantievariabelen en en de summethode verlaagt de variabelen en . Beide methoden werken op gedeelde instantievariabelen."countremove()sumcount

"Ik begrijp het allemaal! Lokale variabelen bestaan ​​terwijl een methode wordt uitgevoerd. De instantievariabelen van een klasse bestaan ​​binnen een object van een klasse zolang dat object bestaat."

"Goed gedaan, Amigo. We hebben wat grondwerk gelegd en je leert details over objecten van een klasse in het volgende level.

Statische variabelen

"Net als methoden kunnen de variabelen in een klasse statisch of niet-statisch zijn. Statische methoden hebben alleen toegang tot statische variabelen.

"Ik heb nog geen duidelijk begrip van statische variabelen."

"Oh, dat weet ik, maar maak je geen zorgen. Raak er voorlopig gewoon vertrouwd mee. Raak er vertrouwd mee. In niveau 11 analyseren we de structuur van statische variabelen en methoden en begrijp je de redenen hiervoor. beperkingen.

"Om een ​​statische variabele (klassevariabele) te maken, moet u het statictrefwoord in zijn declaratie schrijven.

"Statische variabelen zijn niet gebonden aan een object of instantie van de klasse waarin ze zijn gedeclareerd. In plaats daarvan behoren ze tot de klasse zelf. Daarom bestaan ​​ze zelfs als er geen enkel object van de klasse is gemaakt . Je kunt verwijzen naar ze uit andere klassen met behulp van een constructie zoals:

ClassName.variableName

Voorbeeld:

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

"In het bovenstaande voorbeeld hebben we een aparte klasse gemaakt , de and- variabelen erin Storageverplaatst en statisch verklaard . Openbare statische variabelen zijn toegankelijk via elke methode in een programma (en niet alleen via een methode)."countsum

'Ik begrijp het niet helemaal, maar dit lijkt me handig.'

"Zo is het. En soms is het nodig. Zonder statische variabelen en methoden zouden we vast komen te zitten."

"Hopelijk kom ik er langzaam achter."

"Ja, natuurlijk wil je."