Java dette nøkkelordet

På CodeGym blir elevene introdusert til Java dette nøkkelordet bokstavelig talt fra de første timene. Over tid blir betydningen tydelig. Men når vi ser tilbake, innrømmer nok mange for seg selv at de i lang tid ikke kunne forstå zen av dette søkeordet. Denne artikkelen vil trekke gardinen tilbake og dekke hemmelighetene til dette søkeordet for alle som ennå ikke har vært i stand til å gjøre det... Jeg har du Schildts Java-referanse , så på side 171 kan du se at dette nøkkelordet kreves for at en metode skal referere til objektet som kalte det. Vi kunne avsluttet leksjonen med det. Men vi trenger detaljer. Som regel må du bruke dette i to tilfeller:

1. Når en forekomstvariabel og metode/konstruktørvariabel har samme navn;
2. Når du trenger å kalle en bestemt type konstruktør (for eksempel en standard konstruktør eller parameterisert konstruktør) fra en annen type konstruktør. Dette kalles også et eksplisitt konstruktørkall.

Og det er omtrent det – det er bare to tilfeller der dette fryktelige søkeordet brukes. La oss nå se på disse to tilfellene i eksempler.

Eksempel 1: En forekomstvariabel og metodevariabel har samme navn.

Anta at vi har en Human- klasse som definerer et navnefelt: La oss lage en setter for navnevariabelen ( setteren er fullt funksjonell - det er ingen hake her):

class Human {
    String name;


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

Merk at vi sender String newName til setName setter-metoden. Vi erklærte en ny variabel og kunne ha kalt den hva vi vil fordi den vil bare være synlig innenfor de krøllede klammeparentesene ({}) som omslutter setName- metoden . Merk at setteren har en enkelt linje:

name = newName;

Her har vi introdusert en ny variabel kalt newName og tilordnet den til objektets eksisterende navnevariabel . Mange programmerere kan finne det rart å introdusere en variabel med et nytt navn når vi til slutt snakker om det samme. Det vil si at vi snakker om navnefeltet i Human- klassen. Det er derfor Javas skapere har tenkt ut en måte å enkelt bruke det samme variabelnavnet på. Med andre ord, hvorfor ha to navn på en variabel som angir det samme. Med andre ord, vi ønsker å gjøre noe slikt:

class Human {
    String name;


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

Men her møter vi et problem . Vi har nå to variabler med samme navn. Ett strengnavn tilhører Human- klassen, mens det andre strengnavnet tilhører dens setName- metode. Som et resultat vil JVM ikke vite hvilken variabel du refererer til når du skriver følgende linje i setteren:

name = name;

Java antar at du mener den nærmeste navnevariabelen , dvs. den fra setName- metoden: Så det viser seg at du ganske enkelt tildeler metodens navnevariabel til seg selv. Noe som selvfølgelig ikke gir noen mening. Derfor trengte språket en måte å skille Human -klassens navnevariabel fra navnvariabelen i setName- metoden. Dette problemet ble løst ved å introdusere dette nøkkelordet, som i dette tilfellet indikerer at du har til hensikt å referere til variabelen knyttet til en forekomst av Human- klassen, ikke variabelen i metoden: Med andre ord, dennerefererer til det kallende objektet, som vi nevnte i begynnelsen av artikkelen. Som et resultat setter setName -metoden personens navn på det opprettede objektet. Nedenfor er programmets kode uten å bruke dette nøkkelordet. Koden lager et menneskelig objekt og tildeler det et navn: Og her er koden med dette nøkkelordet:

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

Dermed lar dette oss unngå å introdusere nye variabler for å betegne det samme, noe som gjør koden renere og mindre rotete med ekstra variabler.

Eksempel 2: Bruk av dette for et eksplisitt konstruktørkall

Å kalle en konstruktør fra en annen kan være nyttig når du har (merkelig nok) flere konstruktører og du ikke vil at den nye konstruktøren skal duplisere initialiseringskode tidligere skrevet i en annen konstruktør. Forvirret? Det er ikke så skummelt som det virker. Se på koden nedenfor. Den har to konstruktører for 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 gitt en konstruktør med to parametere: int alder og int vekt . Anta at den har to linjer med kode:

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

Senere bestemmer vi oss for å legge til en annen konstruktør med tre parametere, og legger høyde til de eksisterende alders- og vektparametrene. Du kan skrive den nye konstruktøren slik:

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

Men i stedet for å gjenta eksisterende kode i denne konstruktøren, kan du bruke dette nøkkelordet for å eksplisitt kalle konstruktøren med to parametere:

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

Det er som om vi sier til konstruktøren med tre parametere:

• kall denne andre konstruktøren som har to parametere
• og legg deretter til en annen variabel.

Det er alt =). Til slutt merker vi at i Java brukes dette nøkkelordet bare i metoder og konstruktører. Men dette sendes implisitt til alle ikke-statiske metoder (det er derfor dette ofte kalles en implisitt parameter) og kan brukes til å referere til objektet som kalte metoden. Ikke vær redd for dette søkeordet, for dette er ikke skummelt.