జావా ఈ కీవర్డ్

కోడ్‌జిమ్‌లో, విద్యార్థులు జావాకు ఈ కీవర్డ్‌ని అక్షరాలా మొదటి పాఠాల నుండి పరిచయం చేస్తారు. కాలక్రమేణా, దాని అర్థం స్పష్టమవుతుంది. కానీ వెనక్కి తిరిగి చూస్తే, చాలా కాలం వరకు తాము ఈ కీవర్డ్‌లోని జెన్‌ని అర్థం చేసుకోలేకపోయామని చాలా మంది తమను తాము ఒప్పుకుంటారు. ఈ కథనం ఈ కీవర్డ్ యొక్క రహస్యాలను కవర్ చేసే తెరను వెనక్కి లాగుతుంది, ఇంకా అలా చేయలేని ఎవరికైనా... నేను మీకు షిల్డ్ట్ యొక్క జావా సూచనను పొందాను, ఆపై 171వ పేజీలో మీరు ఈ కీవర్డ్‌ని చూడవచ్చు దానిని పిలిచిన వస్తువును సూచించడానికి ఒక పద్ధతి అవసరం. మేము దానితో పాఠాన్ని ముగించవచ్చు. కానీ మాకు ప్రత్యేకతలు అవసరం. నియమం ప్రకారం, మీరు దీన్ని రెండు సందర్భాలలో ఉపయోగించాలి :

1. ఒక ఉదాహరణ వేరియబుల్ మరియు పద్ధతి/కన్స్ట్రక్టర్ వేరియబుల్ ఒకే పేరును కలిగి ఉన్నప్పుడు;
2. మీరు మరొక రకమైన కన్స్ట్రక్టర్ నుండి నిర్దిష్ట రకం కన్స్ట్రక్టర్‌ను (ఉదాహరణకు, డిఫాల్ట్ కన్‌స్ట్రక్టర్ లేదా పారామీటర్ చేయబడిన కన్స్ట్రక్టర్) కాల్ చేయాల్సి వచ్చినప్పుడు. దీనిని స్పష్టమైన కన్స్ట్రక్టర్ కాల్ అని కూడా అంటారు.

మరియు దాని గురించి - ఈ భయంకరమైన కీవర్డ్ ఉపయోగించిన రెండు సందర్భాలు మాత్రమే ఉన్నాయి. ఇప్పుడు ఈ రెండు సందర్భాలను ఉదాహరణలలో చూద్దాం.

ఉదాహరణ 1: ఒక ఉదాహరణ వేరియబుల్ మరియు మెథడ్ వేరియబుల్ ఒకే పేరును కలిగి ఉంటాయి.

నేమ్ ఫీల్డ్‌ని నిర్వచించే హ్యూమన్ క్లాస్ మన వద్ద ఉందని అనుకుందాం : నేమ్ వేరియబుల్ కోసం సెట్టర్‌ని క్రియేట్ చేద్దాం (సెట్టర్ పూర్తిగా ఫంక్షనల్‌గా ఉంది — ఇక్కడ క్యాచ్ లేదు):

class Human {
    String name;


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

మేము String newNameని setName సెట్టర్ పద్ధతికి పంపుతామని గుర్తుంచుకోండి, మేము ఒక కొత్త వేరియబుల్‌ని ప్రకటించాము మరియు setName పద్ధతిని జతపరిచే కర్లీ బ్రేస్‌లలో ({}) మాత్రమే కనిపిస్తుంది కాబట్టి దానికి మనకు కావలసిన పేరు పెట్టవచ్చు . సెట్టర్‌లో ఒకే లైన్ ఉందని గమనించండి:

name = newName;

ఇక్కడ మేము newName అనే కొత్త వేరియబుల్‌ని పరిచయం చేసాము మరియు దానిని ఆబ్జెక్ట్ యొక్క ప్రస్తుత నేమ్ వేరియబుల్‌కి కేటాయించాము. చాలా మంది ప్రోగ్రామర్లు మనం అదే విషయం గురించి మాట్లాడుతున్నప్పుడు కొత్త పేరుతో వేరియబుల్‌ని పరిచయం చేయడం బేసిగా అనిపించవచ్చు. అంటే, మేము మానవ తరగతిలో పేరు ఫీల్డ్ గురించి మాట్లాడుతున్నాము. అందుకే జావా సృష్టికర్తలు అదే వేరియబుల్ పేరును సౌకర్యవంతంగా ఉపయోగించడానికి ఒక మార్గాన్ని ఆలోచించారు. మరో మాటలో చెప్పాలంటే, ఒకే విషయాన్ని సూచించే వేరియబుల్‌కు రెండు పేర్లు ఎందుకు ఉన్నాయి. మరో మాటలో చెప్పాలంటే, మేము ఇలాంటివి చేయాలనుకుంటున్నాము:

class Human {
    String name;


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

కానీ ఇక్కడ మనకు ఒక సమస్య ఎదురవుతుంది . మనకు ఇప్పుడు ఒకే పేరుతో రెండు వేరియబుల్స్ ఉన్నాయి. ఒక స్ట్రింగ్ పేరు మానవ తరగతికి చెందినది , మరొక స్ట్రింగ్ పేరు దాని సెట్‌నేమ్ పద్ధతికి చెందినది . ఫలితంగా, మీరు సెట్టర్‌లో కింది పంక్తిని వ్రాసేటప్పుడు మీరు ఏ వేరియబుల్‌ని సూచిస్తున్నారో JVMకి తెలియదు:

name = name;

జావా మీకు దగ్గరి నేమ్ వేరియబుల్ అని ఊహిస్తుంది, అనగా setName పద్ధతి నుండి ఒకటి : కాబట్టి మీరు కేవలం పద్ధతి యొక్క పేరు వేరియబుల్‌ని దానికే కేటాయిస్తున్నారని తేలింది . ఏది అర్థం కాదు. కాబట్టి, setName పద్ధతిలోని నేమ్ వేరియబుల్ నుండి హ్యూమన్ క్లాస్ నేమ్ వేరియబుల్‌ను వేరు చేయడానికి భాషకు కొంత మార్గం అవసరం . ఈ కీవర్డ్‌ని పరిచయం చేయడం ద్వారా ఈ సమస్య పరిష్కరించబడింది , ఈ సందర్భంలో మీరు హ్యూమన్ క్లాస్ యొక్క ఇన్‌స్టాసెన్‌తో అనుబంధించబడిన వేరియబుల్‌ను సూచించాలనుకుంటున్నారని సూచిస్తుంది , పద్ధతిలోని వేరియబుల్ కాదు: ఇతర మాటలలో, ఇదిమేము వ్యాసం ప్రారంభంలో పేర్కొన్నట్లుగా, కాల్ చేసే వస్తువును సూచిస్తుంది. ఫలితంగా, setName పద్ధతి సృష్టించబడిన వస్తువుపై వ్యక్తి పేరును సెట్ చేస్తుంది. ఈ కీవర్డ్‌ని ఉపయోగించకుండా ప్రోగ్రామ్ యొక్క కోడ్ క్రింద ఉంది . కోడ్ మానవ వస్తువును సృష్టిస్తుంది మరియు దానికి ఒక పేరును కేటాయించింది: మరియు ఈ కీవర్డ్‌తో కూడిన కోడ్ ఇక్కడ ఉంది :

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

అందువల్ల, అదే విషయాన్ని సూచించడానికి కొత్త వేరియబుల్‌లను పరిచయం చేయడాన్ని నివారించేందుకు ఇది అనుమతిస్తుంది, ఇది కోడ్‌ను క్లీనర్‌గా మరియు అదనపు వేరియబుల్స్‌తో తక్కువ చిందరవందరగా చేస్తుంది.

ఉదాహరణ 2: స్పష్టమైన కన్స్ట్రక్టర్ కాల్ కోసం దీన్ని ఉపయోగించడం

మీరు బహుళ కన్‌స్ట్రక్టర్‌లను కలిగి ఉన్నప్పుడు (విచిత్రంగా తగినంత) ఒక కన్‌స్ట్రక్టర్‌ను మరొకరి నుండి కాల్ చేయడం ఉపయోగకరంగా ఉంటుంది మరియు మీరు కొత్త కన్‌స్ట్రక్టర్‌ని గతంలో వేరే కన్స్ట్రక్టర్‌లో వ్రాసిన ఇనిషియలైజేషన్ కోడ్‌ను నకిలీ చేయకూడదనుకుంటున్నారు. గందరగోళం? ఇది కనిపించేంత భయానకంగా లేదు. దిగువ కోడ్‌ను చూడండి. ఇది మానవ తరగతికి రెండు కన్స్ట్రక్టర్లను కలిగి ఉంది :

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

ఇక్కడ మేము మొదట రెండు పారామితులతో కన్స్ట్రక్టర్‌ను అందించాము: పూర్ణాంక వయస్సు మరియు పూర్ణాంక బరువు . దీనికి రెండు లైన్ల కోడ్ ఉందని అనుకుందాం:

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

తరువాత మేము మూడు పారామితులతో మరొక కన్స్ట్రక్టర్‌ను జోడించాలని నిర్ణయించుకున్నాము, ఇప్పటికే ఉన్న వయస్సు మరియు బరువు పారామితులకు ఎత్తును జోడిస్తాము. మీరు కొత్త కన్స్ట్రక్టర్‌ని ఇలా వ్రాయవచ్చు:

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

కానీ ఈ కన్స్ట్రక్టర్‌లో ఇప్పటికే ఉన్న కోడ్‌ను పునరావృతం చేయడానికి బదులుగా, మీరు రెండు పారామితులతో కన్స్ట్రక్టర్‌ను స్పష్టంగా కాల్ చేయడానికి ఈ కీవర్డ్‌ని ఉపయోగించవచ్చు :

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

మేము మూడు-పారామీటర్ కన్స్ట్రక్టర్‌కి చెబుతున్నట్లుగా ఉంది:

• రెండు పారామితులను కలిగి ఉన్న ఈ ఇతర కన్స్ట్రక్టర్‌ని కాల్ చేయండి
• ఆపై మరొక వేరియబుల్ జోడించండి.

అంతే =). చివరగా, జావాలో ఈ కీవర్డ్ పద్ధతులు మరియు కన్స్ట్రక్టర్లలో మాత్రమే ఉపయోగించబడుతుందని మేము గమనించాము. కానీ ఇది అన్ని నాన్-స్టాటిక్ పద్ధతులకు పరోక్షంగా పంపబడుతుంది (అందుకే దీనిని తరచుగా అవ్యక్త పరామితి అని పిలుస్తారు) మరియు పద్ధతి అని పిలిచే వస్తువును సూచించడానికి ఉపయోగించవచ్చు. ఈ కీవర్డ్ గురించి భయపడవద్దు, ఎందుకంటే ఇది భయానకంగా లేదు.