జావాలో రిఫరెన్స్ వేరియబుల్స్

1. రిఫరెన్స్ వేరియబుల్స్

జావా భాషలో, రెండు రకాల వేరియబుల్స్ ఉన్నాయి: ఆదిమ వేరియబుల్స్ మరియు మిగతావన్నీ. ఇది జరిగినప్పుడు, మేము ఇప్పుడు "మిగతా ప్రతిదీ" గురించి మాట్లాడబోతున్నాము.

నిజానికి, ప్రిమిటివ్ వేరియబుల్స్ మరియు రిఫరెన్స్ వేరియబుల్స్ ఉన్నాయని చెప్పడం మరింత సరైనది . కాబట్టి ఈ రిఫరెన్స్ వేరియబుల్స్ ఏమిటి?

ఆదిమ రకాలు కాకుండా, వేరియబుల్స్ నేరుగా విలువలను నిల్వ చేస్తాయి, రిఫరెన్స్ వేరియబుల్స్ వస్తువులకు సూచనలను నిల్వ చేస్తాయి. అంటే, మెమరీలో ఎక్కడో ఒక వస్తువు ఉంది మరియు రిఫరెన్స్ వేరియబుల్ ఈ వస్తువు యొక్క చిరునామాను మెమరీలో నిల్వ చేస్తుంది (వస్తువుకు సూచన).

ఆదిమ రకాలు మాత్రమే నేరుగా వేరియబుల్స్ లోపల విలువలను నిల్వ చేస్తాయి. అన్ని ఇతర రకాలు ఒక వస్తువు సూచనను మాత్రమే నిల్వ చేస్తాయి . మార్గం ద్వారా, మీరు ఇప్పటికే అటువంటి రెండు రకాల వేరియబుల్స్‌ను ఎదుర్కొన్నారు - Stringవేరియబుల్స్ మరియు అర్రే వేరియబుల్స్.

శ్రేణి మరియు స్ట్రింగ్ రెండూ మెమరీలో ఎక్కడో నిల్వ చేయబడిన వస్తువులు. Stringవేరియబుల్స్ మరియు అర్రే వేరియబుల్స్ వస్తువులకు సంబంధించిన సూచనలను మాత్రమే నిల్వ చేస్తాయి.

int a, int b and double dతమ విలువలను తమలో తాము నిల్వ చేసుకునే ఆదిమ వేరియబుల్స్.

వేరియబుల్ అనేది రిఫరెన్స్ మరియు మెమరీలో String strఒక వస్తువుకు చిరునామా (రిఫరెన్స్) నిల్వ చేస్తుంది .String

ఆదిమ రకం యొక్క వేరియబుల్‌కు ఆదిమ విలువను కేటాయించినప్పుడు, దాని విలువ కాపీ చేయబడుతుంది (నకిలీ చేయబడింది). రిఫరెన్స్ వేరియబుల్‌ను కేటాయించేటప్పుడు, ఆబ్జెక్ట్ యొక్క చిరునామా మాత్రమే కాపీ చేయబడుతుంది - ఆబ్జెక్ట్ కూడా కాపీ చేయబడదు .

2. రెఫరెన్సులు దేనికి సంబంధించినవి?

రిఫరెన్స్ వేరియబుల్స్ మరియు ప్రిమిటివ్ వేరియబుల్స్ మధ్య ప్రాథమిక వ్యత్యాసం ఏమిటి?

ఆదిమ వేరియబుల్ ఒక పెట్టె లాంటిది: మీరు దానిలో కొంత విలువను నిల్వ చేయవచ్చు. రిఫరెన్స్ వేరియబుల్ అనేది ఫోన్ నంబర్‌తో కూడిన కాగితం లాంటిది.

కారు vs కారు కీలు

మీ స్నేహితుడికి అతని పుట్టినరోజు కోసం కారు ఇవ్వాలని మీరు నిర్ణయించుకున్నారని ఊహించుకోండి. మీరు దానిని పెట్టెలో చుట్టి మీతో తీసుకెళ్లరు: కారు చాలా పెద్దది.

కారు కీలను కలిగి ఉండేంత పెద్ద బాక్స్‌లో వాటిని ప్రదర్శించడం చాలా సౌకర్యవంతంగా ఉంటుంది. మీ స్నేహితుడు పెట్టె నుండి కీలను పొందినప్పుడు ప్రతిదీ అర్థం చేసుకుంటాడు. మీరు కీలను అప్పగించగలిగినప్పుడు మొత్తం కారును మీతో తీసుకెళ్లాల్సిన అవసరం లేదు.

ఒక వ్యక్తి vs ఆమె ఫోన్ నంబర్

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

అదేవిధంగా, ఒక వస్తువుతో పరస్పర చర్య చేయడానికి సూచన ఉపయోగించబడుతుంది. అన్ని వస్తువులు సూచనలను ఉపయోగించి ఒకదానితో ఒకటి సంకర్షణ చెందుతాయి. "వ్యక్తుల మార్పిడికి" బదులుగా, మేము కేవలం ఫోన్ నంబర్లను మార్పిడి చేస్తాము.

ఆదిమ వేరియబుల్‌కు విలువను కేటాయించినప్పుడు, దాని విలువ కాపీ చేయబడుతుంది (నకిలీ చేయబడింది). రిఫరెన్స్ వేరియబుల్‌కు విలువను కేటాయించినప్పుడు, ఆబ్జెక్ట్ యొక్క చిరునామా (ఫోన్ నంబర్) మాత్రమే కాపీ చేయబడుతుంది - ఆ వస్తువు కూడా కాపీ చేయబడదు.

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

3. సూచనలు కేటాయించడం

రిఫరెన్స్ వేరియబుల్స్‌ను కేటాయించేటప్పుడు, మెమరీలో ఆబ్జెక్ట్ యొక్క చిరునామా మాత్రమే కేటాయించబడుతుంది. వస్తువులు స్వయంగా కనిపించవు లేదా అదృశ్యం కావు.

ఈ విధానం పెద్ద మొత్తంలో మెమరీని కాపీ చేయడాన్ని నివారిస్తుంది. మీరు ఒక పద్ధతికి చాలా పెద్ద వస్తువును పాస్ చేయవలసి వస్తే, మేము ఆబ్జెక్ట్ రిఫరెన్స్‌ను పాస్ చేస్తాము మరియు అంతే. సూచన చాలా తక్కువ స్థలాన్ని తీసుకుంటుంది.

అన్ని రిఫరెన్స్ వేరియబుల్స్ పరిమాణం (వాటి రకంతో సంబంధం లేకుండా) ఒకే విధంగా ఉంటుంది — 4 బైట్‌లు (పూర్ణాంకం లాగా). కానీ! మీ అప్లికేషన్ 64-బిట్ జావా మెషీన్‌లో రన్ అవుతున్నట్లయితే, అన్ని సూచనలు 8 బైట్‌లు (64 బిట్‌లు) పరిమాణంలో ఉంటాయి.

అంతేకాదు, రెఫరెన్స్‌లు ఒకదానికొకటి మాత్రమే కేటాయించబడతాయి. మీరు రిఫరెన్స్‌లను మార్చలేరు లేదా రిఫరెన్స్ వేరియబుల్స్‌కు ఏకపక్ష విలువలను కేటాయించలేరు:

String hello = "Hello";
String s = hello;

String hello = "Hello";
hello++;

String hello = 0x1234;

4. ఒక nullసూచన

మరియు రిఫరెన్స్ వేరియబుల్‌కు ఇంకా ఏమీ కేటాయించబడకపోతే అది ఏమి నిల్వ చేస్తుంది?

ఇది శూన్య సూచనను నిల్వ చేస్తుంది. nullప్రత్యేక జావా కీవర్డ్ అంటే సూచన లేకపోవడం (ఖాళీ సూచన). విలువ nullఏదైనా రిఫరెన్స్ వేరియబుల్‌కు కేటాయించబడుతుంది.

అన్ని రిఫరెన్స్ వేరియబుల్స్‌కు nullకొన్ని రకాల రిఫరెన్స్ కేటాయించబడితే తప్ప.

ఉదాహరణలు:

class Person
{
   public static String name;
   public static int age;
}

విలువ కేటాయించబడని స్థానిక వేరియబుల్‌లు ఆదిమ మరియు సూచన రకాలు రెండింటికీ ప్రారంభించబడనివిగా పరిగణించబడతాయి.

ఒక వేరియబుల్ ఏదైనా వస్తువుకు సూచనను నిల్వ చేసి, మీరు వేరియబుల్ విలువను క్లియర్ చేయాలనుకుంటే, దానిని శూన్య సూచనగా కేటాయించండి.

String s = null;
s = "Hello";
s = null;

5. పద్ధతులకు సూచనలు పాస్ చేయడం

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

ఉదాహరణ:

class Solution
{
   public static void fill(String[] array, String value)
   {
      for (int i = 0; i < array.length; i++)
        array[i] = value;
   }

   public static void main(String[] args)
   {
     String[] data = new String[10];
     fill(data, "Hello");
   }
}

పద్ధతిని fillపిలిచినప్పుడు, arrayపరామితి శ్రేణికి సూచనగా కేటాయించబడుతుంది data. వేరియబుల్ valueస్ట్రింగ్ ఆబ్జెక్ట్ ("హలో")కు సూచనగా కేటాయించబడింది.

పద్ధతిని కాల్ చేయడానికి ముందు మెమరీ ఇలా కనిపిస్తుంది fill:

మెథడ్ రన్ అవుతున్నప్పుడు మెమరీ ఇలా కనిపిస్తుంది fill :

dataమరియు వేరియబుల్స్ arrayమెమరీలో ఒకే కంటైనర్‌ను సూచిస్తాయి (నివేదనలను నిల్వ చేయండి).

వేరియబుల్ valueస్ట్రింగ్ ఆబ్జెక్ట్ ( )కు సూచనను నిల్వ చేస్తుంది "Hello".

శ్రేణి యొక్క సెల్‌లు వస్తువుకు సూచనలను కూడా నిల్వ చేస్తాయి "Hello".

వాస్తవానికి, ఏ వస్తువులు నకిలీ చేయబడవు - కేవలం సూచనలు మాత్రమే కాపీ చేయబడతాయి.

6. C/C ++ భాషతో పోలిక

ఇంటర్వ్యూలలో, కొన్నిసార్లు జావా ప్రోగ్రామర్‌లు జావాలోని పద్ధతులకు డేటా ఎలా పంపబడుతుందని అడుగుతారు? మరియు కొన్నిసార్లు ప్రశ్న ఏమిటంటే డేటా సూచన ద్వారా లేదా విలువ ద్వారా పంపబడుతుందా?

ఈ ప్రశ్న C++ నుండి వచ్చింది, కానీ జావాలో చాలా అర్ధవంతమైనది కాదు . జావాలో, పారామితులు ఎల్లప్పుడూ ఆర్గ్యుమెంట్‌ల విలువలను మాత్రమే కేటాయించబడతాయి. కాబట్టి సరైన సమాధానం " విలువ ఆధారంగా " ఉంటుంది .

కానీ మీ స్థితిని వివరించడానికి సిద్ధంగా ఉండండి , మీరు వెంటనే రిటార్ట్‌ను వినవచ్చు: "ఆదిమ రకాలు విలువ ద్వారా ఆమోదించబడతాయి మరియు సూచన రకాలు సూచన ద్వారా ఆమోదించబడతాయి."

ఈ సమస్య యొక్క మూలం చాలా మంది జావా ప్రోగ్రామర్లు గతంలో C++ ప్రోగ్రామర్లుగా ఉన్నారు. ఆ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో, పద్ధతులకు పారామితులు ఎలా పంపబడతాయి అనే ప్రశ్న చాలా ముఖ్యమైనది.

జావాలో, ప్రతిదీ నిస్సందేహంగా ఉంటుంది: ఆదిమ రకాలు నిల్వ విలువలను మరియు సూచన రకాలు కూడా విలువను నిల్వ చేస్తాయి — ఒక సూచన. ఇది వేరియబుల్ విలువగా పరిగణించబడుతుందా అనే ప్రశ్న .

C++లో, ఒక వేరియబుల్ ఆబ్జెక్ట్ మరియు ఆబ్జెక్ట్‌కి సంబంధించిన రెఫరెన్స్‌ను నిల్వ చేయగలదు. ఆదిమ రకాలకు సంబంధించి కూడా ఇది వర్తిస్తుంది: ఒక ఆదిమ వేరియబుల్ విలువను నిల్వ చేయగలదు లేదా వేరియబుల్‌ను ఒక సూచనగా ప్రకటించగలదు int. కాబట్టి, గందరగోళాన్ని నివారించడానికి, C++ ప్రోగ్రామర్లు ఎల్లప్పుడూ ఆబ్జెక్ట్‌ని సూచనగా సూచిస్తారు మరియు ఆబ్జెక్ట్‌నే - ఒక విలువగా సూచిస్తారు .

C++లో, మీరు ఒక వేరియబుల్‌లో ఒక వస్తువును కలిగి ఉన్న పరిస్థితిని సులభంగా కలిగి ఉండవచ్చు, కానీ మరొకటి ఆ వస్తువుకు సూచనను కలిగి ఉంటుంది. దీని ప్రకారం, వేరియబుల్ ఏమి నిల్వ చేస్తుంది అనే ప్రశ్న - వస్తువు లేదా దానికి సూచన - చాలా ముఖ్యమైనది. ఒక వస్తువును ఒక పద్ధతికి పంపినప్పుడు, అది కాపీ చేయబడింది (విలువ ద్వారా పాస్ అయితే), మరియు కాపీ చేయబడదు (రిఫరెన్స్ ద్వారా పాస్ అయితే).

జావాలో, ఈ ద్వంద్వత్వం ఉనికిలో లేదు, కాబట్టి సరైన సమాధానం: ఆర్గ్యుమెంట్‌లు విలువ ద్వారా జావా పద్ధతులకు పంపబడతాయి . ఇది మేము రిఫరెన్స్ వేరియబుల్స్ గురించి మాట్లాడుతున్నప్పుడు, ఈ విలువ ఒక సూచన.