A változókkal való munka árnyalatai

Állandók

"Amigo, tudtad, hogy Java-ban nem lehet minden változót megváltoztatni?"

"Hogy van ez, Kim? Valóban, maga a "változó" szó a változásról beszél.

"Ehhez nincs kétség. Sok más programozási nyelvhez hasonlóan a Java-nak is vannak konstansai , vagyis olyan változói, amelyek értékeit nem lehet megváltoztatni . És maga a "konstans" szó is állandóságról beszél."

– És mire valók?

"Általában valamilyen alapvető dologra használják őket, mint például a Pinapok száma vagy száma az év hónapjaiban. Elvileg a programozó bármilyen változót konstanssá tehet, ha úgy dönt, hogy ezt teszi. tehát szükséges."

– Úgy érted, mint egy név, egy autó színe vagy a hét egy napjának neve?

"Jó ötleted van. Bármit, amin nem szabad változtatni."

– És hogyan néznek ki ezek a konstansok a Java nyelven?

final"A Java egy speciális kulcsszóval rendelkezik final:

final Type name = value;

"Mi történik, ha létrehoz egy állandót, majd megpróbálja hozzárendelni egy másik értéket?"

"Ez a helyes kérdés, amit fel kell tenni! A helyes válasz pedig a következő: ha más értéket próbálsz hozzárendelni egy változóhoz final, akkor a programod egyszerűen nem fog lefordítani."

"Mi van, ha deklarálsz egy finalváltozót, de nem adsz hozzá értéket?"

"Nincs értelme ezt csinálni, ezért Java-ban sem megengedett. A finalváltozót deklaráláskor inicializálni kell, vagyis értéket kell hozzá rendelni. Ez alól a szabály alól van egy kivétel: mozgathatod az inicializálást statikus osztályváltozót egy konstruktorba, de erről később megtudhatja.

"Egyébként nem minden, ami van final, konstans. A kulcsszavak számának csökkentése érdekében a Java fejlesztők finalnem csak konstansok deklarálására használják ezt a szót. finalMetódusokra és akár osztályokra is vonatkozhatnak. A metódusok, amelyek deklaráltan finalnem bírálhatók felül, és egy osztály finalnem örökölhetőnek nyilvánították ."

"Ööö... Felülbírálva? Öröklött? Milyen nyelven beszélsz most?"

"Az objektum-orientált programozás nyelve. Hamarosan rá fog jönni. Addig csak élvezze a gyönyörű terminológiát."

"Rendben. Szóval finallehet tenni a változók, osztályok és metódusok elé, és ez a kulcsszó bizonyos értelemben megváltoztathatatlanná teszi őket?"

"Igen. Ezenkívül a finalmódosító bármely változó elé hozzáadható: helyi változók, metódusparaméterek, osztálymezők és statikus osztályváltozók.

"Itt van a fontos dolog, amit meg kell jegyezni: finalmielőtt a változónév csak védelmet jelent a változó bármilyen változása ellen . Ha egy változó egy objektumra való hivatkozást tárol, akkor az objektum továbbra is megváltoztatható."

– Nem egészen értem.

"Hamarosan meg fogod érteni. Íme egy példa:

final int[] data = {1, 2, 3, 4, 5, 6};

data = {6, 7, 8, 9};

data[0] = 0;
data[1] = 0;
data[2] = 0;

"Értem. Ez trükkös."

Globális állandók

– Mit gondol, mik a globális állandók?

"Azt hiszem, a globális konstansok valószínűleg olyanok, mint a globális változók, csak konstansok?"

"Pontosan. Ha globális konstansokat kell deklarálnia a programban, hozzon létre statikus osztályváltozókat , és tegye őket publicés final. Az ilyen változók nevének egy speciális stílusa van: csupa nagybetűvel írják őket, aláhúzásjellel. külön szavakat.

Példák:

class Solution
{
   public static final String SOURCE_ROOT = "c:\\projects\\my\\";
   public static final int DISPLAY_WIDTH = 1024;
   public static final int DISPLAY_HEIGHT = 768;
}

Változó árnyékolás

"Ahogy korábban mondtam, nem hozhat létre több helyi változót ugyanazzal a névvel egyetlen metódusban. Különböző metódusokban igen."

"Tudom!"

"De valószínűleg nem tudod, hogy az osztály változóinak és a metódusban lévő helyi változóknak ugyanaz a neve.

Példa:

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

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

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

"A metódusban adddeklaráltunk egy helyi változót, melynek neve sum. A metódus végéig árnyékolja (vagy maszkolja ) a sumpéldányváltozót."

– Hmm... azt mondanám, hogy bizonyos értelemben ez az elvárt viselkedés.

this"De ezzel még nincs vége a történetnek. Kiderült, hogy ha egy példányváltozót egy lokális változó árnyékol, továbbra is van mód a példányváltozóra hivatkozni a metóduson belül. Ezt úgy tesszük, hogy a kulcsszót a neve elé írjuk :

this.name

"Íme egy példa, ahol a névütközés sikeresen feloldásra került:

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

   public void add(int data)
   {
     int sum = data * 2;
     this.sum = this.sum + data;
     count++;
   }
}

this.count, this.sum
this.count, this.sum
this.count, this.sum
this.count, this.sum
this.count, this.sum
this.count, this.sum, data
this.count, this.sum, data, sum
this.count, this.sum, data, sum
this.count, this.sum, data, sum
this.count, this.sum

A countés sumváltozók mindenhol elérhetők kulcsszóval vagy anélkül this. Azokon a sorokon, ahol a sumhelyi változó árnyékolja a sumpéldányváltozót, a példányváltozó csak a kulcsszó sumhasználatával érhető el .this

– Nyilvánvaló, hogy ezt gyakorolnom kell.

– Majd elintézel.

"Mi van akkor, ha egy statikus osztályváltozó árnyékolva van, nem csak egy (nem statikus) példányváltozó? Nem érheti el a következőn keresztül this?"

"Igazad van. Ez a kulcsszó nem fog működni. Az osztálynéven keresztül kell hivatkoznod rá:

ClassName.name

Példa:

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

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

Solution.count, Solution.sum
Solution.count, Solution.sum
Solution.count, Solution.sum
Solution.count, Solution.sum
Solution.count, Solution.sum
Solution.count, Solution.sum, data
Solution.count, Solution.sum, data, sum
Solution.count, Solution.sum, data, sum
Solution.count, Solution.sum, data, sum
Solution.count, Solution.sum

count"Figyelem: a és a statikus változókat mindenhol elérheti sumaz osztálynév Solutionelőtagként való használatával vagy anélkül. Azokban a sorokban, ahol a sumlokális változó beárnyékolja a sumpéldányváltozót, az osztályváltozóhoz sumcsak Solutionelőtagként való hozzáférés esetén van lehetőség.

Változók a forcikluson belül

for"És még egy apró, de érdekes tény. Van egy olyan hely is, ahol egy változót különleges módon deklarálnak – a cikluson belülről beszélek ." Általában egy forciklusban van egy counterváltozó zárójelben. És mi lesz ennek a változónak a láthatósága? Végül is nem a hurok testében van. Ez az egész módszer? Vagy nem?"

for"Már hallottam valamit erről. Ha jól értem, a ciklus fejlécében deklarált változó csak a ciklus törzsében és a ciklus fejlécébenfor látható ."

"Jól van, Amigo. De azért nézz egy példát ennek az anyagnak a megerősítésére:

public static void main(String[] args)
{
   int a = 0;

   for (int i = 0; i < 10; i++)
   {
     System.out.println(i);
   }

   System.out.println("end");
}

a
a
a, i
a, i
a, i
a
a
a

"Tehát azt mondod, hogy a kódomban több ciklust is írhatnék egymás után egy azonos nevű számlálóváltozóval, és nem lesz probléma?"

"Nem lenne probléma. Nézze:

public static void main(String[] args)
{
   int a = 0;

   for (int i = 0; i < 10; i++)
   {
     System.out.println(i);
   }

   for (int i = 0; i < 10; i--)
   {
     System.out.println(i);
   }

   System.out.println("end");
}

a
a
a, i
a, i
a, i
a
a
a, i
a, i
a, i
a
a
a