Java dette søgeord

På CodeGym introduceres eleverne til Java dette nøgleord bogstaveligt talt fra de første lektioner. Med tiden bliver dens betydning tydelig. Men når vi ser tilbage, indrømmer mange mennesker sikkert over for sig selv, at de i lang tid ikke kunne forstå zen af ​​dette søgeord. Denne artikel vil trække gardinet tilbage, der dækker hemmelighederne bag dette søgeord for alle, der endnu ikke har været i stand til det... Jeg har, du har Schildts Java-reference , så på side 171 kan du se, at dette søgeord er påkrævet for en metode til at referere til det objekt, der kaldte det. Det kunne vi afslutte lektionen med. Men vi har brug for detaljer. Som regel skal du bruge dette i to tilfælde:

1. Når en instansvariabel og metode/konstruktørvariabel har samme navn;
2. Når du skal kalde en bestemt type konstruktør (f.eks. en standardkonstruktør eller parametriseret konstruktør) fra en anden type konstruktør. Dette kaldes også et eksplicit konstruktørkald.

Og det handler om det - der er kun to tilfælde, hvor dette frygtindgydende søgeord bliver brugt. Lad os nu se på disse to tilfælde i eksempler.

Eksempel 1: En instansvariabel og metodevariabel har samme navn.

Antag, at vi har en Human- klasse, der definerer et navnefelt: Lad os oprette en setter for navnevariablen ( sætteren er fuldt funktionel - der er ingen fangst her):

class Human {
    String name;


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

Bemærk, at vi sender String newName til setName- indstiller-metoden. Vi erklærede en ny variabel og kunne have navngivet den, hvad vi vil, fordi den kun vil være synlig inden for de krøllede klammer ({}), der omslutter setName- metoden . Bemærk, at sætteren har en enkelt linje:

name = newName;

Her har vi introduceret en ny variabel kaldet newName og tildelt den til objektets eksisterende navnevariabel . Mange programmører kan finde det mærkeligt at introducere en variabel med et nyt navn, når vi i sidste ende taler om det samme. Det vil sige, vi taler om navnefeltet i Human- klassen. Det er derfor, Javas skabere fandt på en måde at bekvemt bruge det samme variabelnavn på. Med andre ord, hvorfor have to navne til en variabel, der angiver det samme. Vi vil med andre ord gøre sådan noget:

class Human {
    String name;


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

Men her støder vi på et problem . Vi har nu to variable med samme navn. Det ene strengnavn tilhører klassen Human , mens det andet strengnavn tilhører dets setName- metode. Som et resultat ville JVM ikke vide, hvilken variabel du henviser til, når du skriver følgende linje i setteren:

name = name;

Java antager, at du mener den nærmeste navnevariabel , altså den fra setName- metoden: Så det viser sig, at du blot tildeler metodens navnevariabel til sig selv. Hvilket selvfølgelig ikke giver nogen mening. Derfor havde sproget brug for en måde at skelne Human- klassens navnevariabel fra navnvariablen i setName- metoden. Dette problem blev løst ved at introducere dette nøgleord, som i dette tilfælde indikerer, at du har til hensigt at referere til den variabel, der er knyttet til en instans af Human- klassen, ikke variablen i metoden: Med andre ord, dennehenviser til det kaldende objekt, som vi nævnte i begyndelsen af ​​artiklen. Som følge heraf indstiller setName- metoden personens navn på det oprettede objekt. Nedenfor er programmets kode uden at bruge dette nøgleord. Koden opretter et menneskeligt objekt og tildeler det et navn: Og her er koden med dette nøgleord:

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);
    }
}

Dette lader os således undgå at introducere nye variabler for at betegne det samme, hvilket gør koden renere og mindre rodet med ekstra variabler.

Eksempel 2: Brug af dette til et eksplicit konstruktørkald

Det kan være nyttigt at kalde en konstruktør fra en anden, når du (mærkeligt nok) har flere konstruktører, og du ikke ønsker, at den nye konstruktør skal duplikere initialiseringskode, der tidligere er skrevet i en anden konstruktør. Forvirret? Det er ikke så skræmmende, som det ser ud til. Se koden nedenfor. Den har to konstruktører til Human- klassen:

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;
    }
}

Her har vi først givet en konstruktør med to parametre: int alder og int vægt . Antag, at den har to linjer kode:

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

Senere beslutter vi os for at tilføje endnu en konstruktør med tre parametre, der tilføjer højde til de eksisterende alders- og vægtparametre. Du kan skrive den nye konstruktør sådan her:

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

Men i stedet for at gentage eksisterende kode i denne konstruktør, kan du bruge dette nøgleord til eksplicit at kalde konstruktøren med to parametre:

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

Det er, som om vi siger til konstruktøren med tre parametre:

• kald denne anden konstruktør, der har to parametre
• og tilføje en anden variabel.

Det er alt =). Endelig bemærker vi, at dette nøgleord i Java kun bruges i metoder og konstruktører. Men dette overføres implicit til alle ikke-statiske metoder (det er derfor, dette ofte kaldes en implicit parameter) og kan bruges til at henvise til det objekt, der kaldte metoden. Vær ikke bange for dette søgeord, for det er ikke skræmmende.