További információ a változó hatókörről

"A professzor egyszerűen nem tud kiszabadulni a kerékvágásból. A régi tanárok, akik hozzászoktak az előadásokhoz, mindig ilyenek. Nincs olyan, amit elmondhatna neked, amit ne találna meg a könyvekben. Nem úgy tanulsz meg úszni, ha hallod . az úszáselőadásokra. Az előadások csak akkor hasznosak, ha ismeri a témát, és majdnem annyit tud, mint a professzora."

– Ennek ellenére hasznosak az órái.

"Igen. Úgy értem, reméljük, hogy igen. Minél több nézőpontot hallasz a témában, annál közelebb kerülsz az igazsághoz. Ha csak egyet hallasz, nem tehetsz mást, mint elhinni vagy nem hinni. OK, nézzük térj vissza az üzlethez."

– Nézzünk egy képet, amit korábban mutattam.

┏
┃public class Variables
┃┏
┃┃{
┃┃   private static String TEXT = "The end.";
┃┃  ┗━━━━━━━━━━━━━━━━━━━┛
┃┃   public static void main (String[] args)
┃┃ ┏                         ┗━━━━━━━┛
┃┃ ┃ {
┃┃ ┃    System.out.println("Hi");
┃┃ ┃    String s = "Hi!";
┃┃ ┃  ┏┗━━━━┛
┃┃ ┃  ┃ System.out.println(s);
┃┃ ┃  ┃ if (args != NULL)
┃┃ ┃  ┃ {
┃┃ ┃  ┃    String s2 = s;
┃┃ ┃  ┃   ┗━━━━┛
┃┃ ┃  ┃  ┏
┃┃ ┃  ┃  ┃ System.out.println(s2);
┃┃ ┃  ┃  ┗
┃┃ ┃  ┃ }
┃┃ ┃  ┃ Variables variables = new Variables();
┃┃ ┃  ┃ System.out.println(variables.instanceVariable);
┃┃ ┃  ┃ System.out.println(TEXT);
┃┃ ┃  ┗
┃┃ ┃ }
┃┃ ┗
┃┃   public String instanceVariable;
┃┃  ┗━━━━━━━━━━━━━━━┛
┃┃   public Variables()
┃┃   {
┃┃      instanceVariable = "Instance variable test.";
┃┃   }
┃┃}
┃┗
┗

1. Egy metódusban deklarált változó létezik (látható) a deklaráció kezdetétől a metódus végéig.

2. A kódblokkban deklarált változó a kódblokk végéig létezik.

3. A metódus paraméterei mindaddig léteznek, amíg a metódus vissza nem tér.

4. Az objektumban lévő változók az őket tartalmazó objektum teljes élettartama alatt léteznek. Láthatóságukat speciális hozzáférés-módosítók is szabályozzák.

5. A statikus (osztály) változók a program teljes futása alatt léteznek. Láthatóságukat hozzáférésmódosítók is meghatározzák."

– Helyes. Emlékszem erre a képre.

"Remek. Hadd emlékeztesselek néhány kulcsfontosságú pontra."

"A metódusokon belül deklarált összes változó létezik (látható) attól a ponttól kezdve, ahol deklarálják őket, egészen a metódus végéig (1. példa)."

"Ha egy változót deklarálnak egy kódblokkban, az a kódblokk végéig létezik (2. példa)."

"Ha egy változó metódusparaméter, akkor a metódus teljes törzsében létezik (látható) (3. példa)."

"Ha egy változó egy példányváltozó (4. példa), akkor egy bizonyos objektumhoz kapcsolódik, és addig létezik, amíg az objektum létezik. Ha nem létezik objektum, akkor a változónak nincsenek példányai. A változóhoz hozzáférhet (pl. a változó látható) az osztály összes metódusából, függetlenül attól, hogy előtte vagy utána deklarálták. Minden objektumhoz új változó jön létre. Független a többi objektumtól. Statikus metódusokból nem férhet hozzá példányváltozóhoz . "

"Ha egy változót statikusnak deklarálunk, azaz a static kulcsszóval jelöljük meg , akkor addig létezik, amíg az osztálya létezik. A JVM általában az első használatkor betölt egy osztályt a memóriába. Ekkor történik a statikus változók inicializálása is."

"A fenti példa deklarálja a Cat osztályt, amelynek négy változója van: a, b, s (nem statikus változók) és count (statikus változó). Ha több objektumot hozunk létre ebből az osztályból (mondjuk hármat), akkor mindegyik ezek tartalmazni fogják az osztály nem statikus változóinak saját példányait. A statikus változót egy osztály minden objektuma megosztja. Technikailag még ezeken az objektumokon belül sincs, mivel már a Cat objektumok létrehozása előtt is létezett."

"Íme, mi történik, ha statikus változót deklarálunk s:"

"Rendben. Azt hiszem, értem."

– Deklarálhatsz azonos nevű változókat?

"Nem metóduson belül. A metóduson belül deklarált összes változónak egyedi névvel kell rendelkeznie. A metódus argumentumai is helyi változónak számítanak."

– Mi a helyzet a tagváltozókkal?

"A tagváltozóknak is egyedinek kell lenniük minden osztálynál."

"De van egy kivétel: a lokális változók és a tagváltozók nevei azonosak lehetnek. "

"Ha megváltoztatunk egy ilyen változót, akkor a két azonos nevű változó közül melyik változik meg?"

"Ha több látható (elérhető) változó van a kódunkban – mondjuk egy példányváltozó és egy lokális változó –, akkor a rendszer hozzáfér a helyi változóhoz."

class Main
{
    public int count = 0;     // Declare an instance variable

    public void run()
    {
        count = 15;           // Access the instance variable
        int count = 10;       // Declare a local method variable
        count++;             // Access the method variable
    }
}

"Ez a kód két számváltozót deklarál. A 3. sor egy példányváltozót , a 8. sor pedig egy helyi változót deklarál ."

"Íme, mi történik a futtatási metódus végrehajtásakor:"

"A 7. sorban elérjük a példányváltozót , és hozzárendeljük a 15-ös értéket"

"A 8. sorban deklarálunk (létrehozunk) egy új helyi változót : count. Ez maszkolja a példányváltozót. A lokális változó az, amit a metódusban szereplő összes következő kód látni fog (access)."

"Megvan."

"A helyi változó elfedi a példányváltozót. Más szóval, a lokális változót kell elérni. Azonban a példányváltozót is elérheti. Csak egy kicsit bonyolultabb."

ClassName.variableName

// Here are some examples:
Cat.catsCount

this.variableName

// Here are some examples:
this.catsCount

"Mit tud még mondani a statikus módszerekről és statikus változókról?"

"A statikus metódusok és változók nem kapcsolódnak az osztály objektumaihoz, hanem magához az osztályhoz. Ha tíz Variables objektumot hozunk létre (lásd a példát a szint elején), akkor tíz példányVariable változónk lesz (mindegyikhez egy objektum) és csak egy megosztott (statikus) változó TEXT ."

"Kérdésem van."

"Mi a különbség a statikus és a nem statikus módszerek között?"

"Nézzük meg, hogyan működik egy nem statikus módszer:"

Cat cat = new Cat();
String name = cat.getName();
cat.setAge(17);
cat.setChildren(cat1, cat2, cat3);

Cat cat = new Cat();
String name = Cat.getName(cat);
Cat.setAge(cat,17);
Cat.setChildren(cat, cat1, cat2, cat3);

"Amikor meghív egy metódust az <object> dot <method name> használatával , valójában egy osztálymetódus hívja meg, és ugyanazt az objektumot adja át az első argumentumként. A metóduson belül az objektumot 'this'-nek hívják . Minden művelet a módszert hajtják végre ezen az objektumon és adatain."

"Hűha! Szóval így működik az egész!"

"És így működik egy statikus módszer."

Cat cat1 = new Cat();
Cat cat2 = new Cat();
int catCount = Cat.getAllCatsCount();

Cat cat1 = new Cat();
Cat cat2 = new Cat();
int catCount = Cat.getAllCatsCount(null);

"Amikor meghív egy statikus metódust, nem ad át neki objektumot. Más szóval a 'this' egyenlő a nullával . Ezért a statikus metódus nem fér hozzá nem statikus változókhoz és metódusokhoz (mivel nincs átadható " ez" ezekre a módszerekre).

"Hmmm. Azt hiszem, értem. Legalább egy kicsit."

– És itt jön Diego bácsi... és a feladatai.