Java ezt a kulcsszót

A CodeGym-en a tanulók az első óráktól kezdve megismerkednek a Java-val, ez a kulcsszó szó szerint. Idővel a jelentése világossá válik. De visszatekintve valószínűleg sokan elismerik maguknak, hogy sokáig nem tudták megérteni ennek a kulcsszónak a zenjét. Ez a cikk lerántja a rolót a kulcsszó titkairól azok számára, akik még nem tudták megtenni... Megvan Schildt Java referenciája , akkor a 171. oldalon láthatja, hogy ez a kulcsszó szükséges ahhoz, hogy egy metódus hivatkozzon az azt meghívó objektumra. Ezzel be is fejezhetnénk a leckét. De konkrétumokra van szükségünk. Általános szabály, hogy ezt két esetben kell használni :

1. Ha egy példányváltozónak és a metódus/konstruktorváltozónak ugyanaz a neve;
2. Amikor egy adott típusú konstruktort (például alapértelmezett konstruktort vagy paraméterezett konstruktort) kell meghívnia egy másik típusú konstruktorból. Ezt explicit konstruktorhívásnak is nevezik.

És nagyjából ennyi – mindössze két olyan eset van, amikor ezt a félelmetes kulcsszót használják. Most nézzük meg ezt a két esetet példákon keresztül.

1. példa: Egy példányváltozónak és a metódusváltozónak ugyanaz a neve.

Tegyük fel, hogy van egy Human osztályunk, amely meghatároz egy névmezőt: Hozzon létre egy settert a névváltozóhoz ( a beállító teljesen működőképes – itt nincs fogás):

class Human {
    String name;


    public void setName(String newName) {
        name = newName;
    }
}

Ne feledje, hogy a String newName karakterláncot a setName setter metódusnak adjuk át. Deklaráltunk egy új változót, és tetszés szerint elnevezhettük, mert csak a setName metódust körülvevő kapcsos zárójelekben ({}) lesz látható. Vegye figyelembe, hogy a beállító egyetlen sorral rendelkezik:

name = newName;

Itt bevezettünk egy új változót newName néven , és hozzárendeltük az objektum meglévő névváltozójához . Sok programozó furcsának találhatja egy változót új néven bevezetni, amikor végül ugyanarról a dologról beszélünk. Vagyis az Ember osztály névmezőjéről beszélünk . Ezért találtak ki egy módot a Java készítői ugyanazon változónév kényelmes használatára. Más szóval, miért van két neve ugyanazt a változót jelölő változónak. Más szavakkal, valami ilyesmit szeretnénk csinálni:

class Human {
    String name;


    public void setName(String name) {
        name = name;
    }
}

De itt egy problémába ütközünk . Most két azonos nevű változónk van. Az egyik String név a Human osztályhoz, míg a másik String név a setName metódusához tartozik . Ennek eredményeként a JVM nem tudja, melyik változóra hivatkozik, amikor a következő sort írja be a setterbe:

name = name;

A Java feltételezi, hogy a legközelebbi névváltozóra gondolsz , azaz a setName metódusból származóra : Így kiderül, hogy egyszerűen csak hozzá rendeled a metódus névváltozóját . Aminek persze semmi értelme. Ezért a nyelvnek szüksége volt valamilyen módra, hogy megkülönböztesse a Human osztály névváltozóját a setName metódus névváltozójától . Ezt a problémát a this kulcsszó bevezetésével oldottuk meg , ami ebben az esetben azt jelzi, hogy a Human osztály egy példányához társított változóra kíván hivatkozni , nem pedig a metódus változójára: Más szóval, eza hívó objektumra utal, amint azt a cikk elején említettük. Ennek eredményeként a setName metódus beállítja a személy nevét a létrehozott objektumon. Az alábbiakban a program kódja látható a kulcsszó használata nélkül . A kód létrehoz egy emberi objektumot, és nevet rendel neki: És itt van a kód ezzel a kulcsszóval :

public class Solution {
    public static void main(String[] args) {
        Human human1 = new Human();
        human1.setName("Vinny");
        human1.print();
    }
}
class Human {
    String name;
    public String getName() {
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    void print() {
        System.out.println(name);
    }
}

Így elkerülhetjük, hogy új változókat vezessünk be ugyanazon dolog jelölésére, így a kód tisztább lesz, és kevésbé lesz tele többletváltozókkal .

2. példa: Ennek használata explicit konstruktorhíváshoz

Egyik konstruktor meghívása egy másikból hasznos lehet, ha (furcsa módon) több konstruktora van, és nem szeretné, hogy az új konstruktor megkettőzze a korábban egy másik konstruktorban írt inicializációs kódot. Zavaros? Nem olyan ijesztő, mint amilyennek látszik. Nézd meg az alábbi kódot. Két konstruktora van a Human osztályhoz:

class Human {
    int age;
    int weight;
    int height;

    Human(int age, int weight) {
        this.age = age;
        this.weight = weight;
    }
    Human(int age, int weight, int height) {
        // Call the constructor with two parameters
        this(age, weight);
        // and then initialize the missing variable
        this.height = height;
    }
}

Itt először egy konstruktort adtunk meg két paraméterrel: int age és int weight . Tegyük fel, hogy két kódsora van:

this.age = age;
this.weight = weight;

Később úgy döntünk, hogy hozzáadunk egy másik konstruktort három paraméterrel, hozzátéve a magasságot a meglévő kor és súly paraméterekhez. Az új konstruktort így írhatod:

this.age = age;
this.weight = weight;
this.height = height;

De ahelyett, hogy megismételné a meglévő kódot ebben a konstruktorban, használhatja a this kulcsszót a konstruktor explicit meghívására két paraméterrel:

this(age, weight);
// and then initialize the missing variable:
this.height = height;

Mintha azt mondanánk a háromparaméteres konstruktornak:

• hívja meg ezt a másik konstruktort, amelynek két paramétere van
• majd adjunk hozzá egy másik változót.

ennyi =). Végül megjegyezzük, hogy a Java-ban ez a kulcsszó csak metódusokban és konstruktorokban használatos. De ez implicit módon átkerül minden nem statikus metódushoz (ezért ezt gyakran implicit paraméternek nevezik), és felhasználható a metódust hívó objektumra való hivatkozásra. Ne féljen ettől a kulcsszótól, mert ez nem ijesztő.