Java detta nyckelord

På CodeGym introduceras eleverna till Java detta nyckelord bokstavligen från de första lektionerna. Med tiden blir dess innebörd tydlig. Men när vi ser tillbaka, erkänner förmodligen många för sig själva att de under lång tid inte kunde förstå zen av detta nyckelord. Den här artikeln kommer att dra tillbaka gardinen för att täcka hemligheterna bakom detta nyckelord för alla som ännu inte har kunnat göra det... Jag har du har Schildts Java-referens, så på sidan 171 kan du se att det här nyckelordet krävs för att en metod ska referera till objektet som anropade det. Vi skulle kunna avsluta lektionen med det. Men vi behöver detaljer. Som regel måste du använda detta i två fall:

1. När en instansvariabel och metod/konstruktorvariabel har samma namn;
2. När du behöver anropa en specifik typ av konstruktör (till exempel en standardkonstruktor eller parametriserad konstruktor) från en annan typ av konstruktor. Detta kallas också ett explicit konstruktoranrop.

Och det är ungefär det — det finns bara två fall där detta skrämmande sökord används. Låt oss nu titta på dessa två fall i exempel.

Exempel 1: En instansvariabel och metodvariabel har samma namn.

Anta att vi har en Human- klass som definierar ett namnfält: Låt oss skapa en sätter för namnvariabeln ( sättaren är fullt funktionell - det finns ingen hake här):

class Human {
    String name;


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

Observera att vi skickar String newName till setName -metoden. Vi deklarerade en ny variabel och kunde ha döpt den till vad vi vill eftersom den bara kommer att synas inom de krulliga klammerparenteserna ({}) som omsluter setName- metoden . Observera att sättaren har en enda rad:

name = newName;

Här har vi introducerat en ny variabel som heter newName och tilldelat den till objektets befintliga namnvariabel . Många programmerare kan tycka att det är konstigt att introducera en variabel med ett nytt namn när vi i slutändan pratar om samma sak. Det vill säga vi pratar om namnfältet i klassen Human . Det är därför Javas skapare kom på ett sätt att bekvämt använda samma variabelnamn. Med andra ord, varför ha två namn för en variabel som betecknar samma sak. Vi vill med andra ord göra något så här:

class Human {
    String name;


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

Men här stöter vi på ett problem . Vi har nu två variabler med samma namn. Ett strängnamn tillhör klassen Human , medan det andra strängnamnet tillhör dess setName- metod. Som ett resultat skulle JVM inte veta vilken variabel du hänvisar till när du skriver följande rad i settern:

name = name;

Java antar att du menar den närmaste namnvariabeln , dvs den från setName- metoden: Så det visar sig att du helt enkelt tilldelar metodens namnvariabel till sig själv. Vilket naturligtvis inte är meningsfullt. Därför behövde språket på något sätt för att skilja Human -klassens namnvariabel från namnvariabeln i setName -metoden. Detta problem löstes genom att introducera nyckelordet this , vilket i det här fallet indikerar att du avser att referera till variabeln som är associerad med en instans av klassen Human , inte variabeln i metoden: Med andra ord, dettahänvisar till det anropande objektet, som vi nämnde i början av artikeln. Som ett resultat anger metoden setName personens namn på det skapade objektet. Nedan finns programmets kod utan att använda detta nyckelord. Koden skapar ett mänskligt objekt och tilldelar det ett namn: Och här är koden med detta nyckelord:

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

Detta låter oss alltså undvika att introducera nya variabler för att beteckna samma sak, vilket gör koden renare och mindre belamrad med extra variabler.

Exempel 2: Använder detta för ett explicit konstruktoranrop

Att anropa en konstruktor från en annan kan vara användbart när du (märkligt nog) har flera konstruktorer och du inte vill att den nya konstruktören ska duplicera initieringskod som tidigare skrivits i en annan konstruktor. Förvirrad? Det är inte så läskigt som det verkar. Titta på koden nedan. Den har två konstruktörer för 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;
    }
}

Här har vi först försett en konstruktor med två parametrar: int age och int weight . Anta att den har två rader kod:

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

Senare bestämmer vi oss för att lägga till ytterligare en konstruktör med tre parametrar, vilket lägger till höjd till befintliga ålders- och viktparametrar. Du kan skriva den nya konstruktören så här:

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

Men istället för att upprepa befintlig kod i denna konstruktor, kan du använda nyckelordet this för att uttryckligen anropa konstruktorn med två parametrar:

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

Det är som om vi säger till konstruktören med tre parametrar:

• anropa denna andra konstruktor som har två parametrar
• och lägg sedan till en annan variabel.

Det är allt =). Slutligen noterar vi att i Java används detta nyckelord endast i metoder och konstruktörer. Men detta skickas implicit till alla icke-statiska metoder (det är därför detta ofta kallas en implicit parameter) och kan användas för att referera till objektet som anropade metoden. Var inte rädd för det här sökordet, för det är inte skrämmande.