జావాలోని వస్తువుల సూక్ష్మ నైపుణ్యాలు

1. లక్షణాలు: గెట్టర్స్ మరియు సెట్టర్స్

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

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

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

ఇతర తరగతులు మీ తరగతిలోని ఆబ్జెక్ట్‌లలోని డేటాను పొందగలగాలి లేదా మార్చగలగాలని మీరు కోరుకుంటే, మీరు మీ తరగతికి రెండు పద్ధతులను జోడించాలి - పొందే పద్ధతి మరియు సెట్ పద్ధతి. ఉదాహరణ:

class Person
{
   private String name;

   public Person(String name)
   {
      this.name = name;
   }

   public String getName()
   {
      return name;
   }

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

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

ఈ getName()పద్ధతిని " పేరు ఫీల్డ్ కోసం గెటర్ " అని కూడా పిలుస్తారు మరియు ఈ పద్ధతిని " పేరు ఫీల్డ్ కోసం సెట్టర్setName() " అని కూడా పిలుస్తారు .

ఇది చాలా సాధారణమైన విధానం. మొత్తం జావా కోడ్‌లో 80-90%లో, మీరు తరగతిలో పబ్లిక్ వేరియబుల్‌లను ఎప్పటికీ చూడలేరు. బదులుగా, అవి ప్రకటించబడతాయి private(లేదా protected), మరియు ప్రతి వేరియబుల్‌కు పబ్లిక్ గెట్టర్‌లు మరియు సెట్టర్‌లు ఉంటాయి.

ఈ విధానం కోడ్‌ను ఎక్కువ కాలం చేస్తుంది, కానీ మరింత నమ్మదగినదిగా చేస్తుంది.

క్లాస్ వేరియబుల్‌ని నేరుగా యాక్సెస్ చేయడం అంటే మీ కారుని డబుల్ ఎల్లో లైన్‌ల ద్వారా మార్చడం లాంటిది : ఇది సులభం మరియు వేగవంతమైనది, కానీ ప్రతి ఒక్కరూ దీన్ని చేస్తే, ప్రతి ఒక్కరికీ పరిస్థితులు మరింత దిగజారిపోతాయి.

xమీరు పాయింట్ ( , ) ను వివరించే తరగతిని సృష్టించాలనుకుంటున్నారని అనుకుందాం y. అనుభవం లేని ప్రోగ్రామర్ దీన్ని ఎలా చేయాలో ఇక్కడ ఉంది:

class Point
{
   public int x;
   public int y;
}

అనుభవజ్ఞుడైన జావా ప్రోగ్రామర్ దీన్ని ఎలా చేయాలో ఇక్కడ ఉంది:

class Point {
   private int x;
   private int y;

   public Point(int x, int y) {
      this.x = x;
      this.y = y;
   }

   public int getX() {
      return x;
   }

   public void setX(int x) {
      this.x = x;
   }

   public int getY() {
      return y;
   }

   public void setY(int y) {
      this.y = y;
   }
}

కోడ్ పొడవుగా ఉందా? నిస్సందేహంగా.

కానీ మీరు గెట్టర్స్ మరియు సెట్టర్‌లకు పారామీటర్ ధ్రువీకరణను జోడించవచ్చు. xఉదాహరణకు, మీరు ఎల్లప్పుడూ సున్నా కంటే ఎక్కువగా ఉండేలా చూసుకోవచ్చు y(లేదా సున్నా కంటే తక్కువ కాదు). ఉదాహరణ:

class Point {
   private int x;
   private int y;

   public Point(int x, int y) {
      this.x = x < 0 ? 0 : x;
      this.y = y < 0 ? 0 : y;
   }

   public int getX() {
      return x;
   }

   public void setX(int x) {
      this.x = x < 0 ?  0 : x;
   }

   public int getY() {
      return y;
   }

   public void setY(int y) {
      this.y = y < 0 ? 0 : y;
   }
}

2. వస్తువు జీవితకాలం

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

C++ వంటి అనేక ప్రోగ్రామింగ్ భాషలలో, deleteవస్తువులను తొలగించడానికి ప్రత్యేక ఆపరేటర్ ఉంది. అయితే ఇది జావాలో ఎలా పని చేస్తుంది?

జావాలో, ప్రతిదీ కొద్దిగా భిన్నంగా అమర్చబడింది. జావాకు డిలీట్ ఆపరేటర్ లేదు. జావాలో వస్తువులు తొలగించబడలేదని దీని అర్థం? లేదు, అవి తొలగించబడ్డాయి. లేకపోతే, జావా అప్లికేషన్‌లు త్వరగా మెమరీ అయిపోతాయి మరియు నెలల తరబడి అంతరాయం లేకుండా నడుస్తున్న ప్రోగ్రామ్‌ల గురించి ఎటువంటి చర్చ ఉండదు.

జావాలో, వస్తువుల తొలగింపు పూర్తిగా స్వయంచాలకంగా ఉంటుంది. జావా మెషీన్ స్వయంగా వస్తువుల తొలగింపును నిర్వహిస్తుంది. ఈ ప్రక్రియను చెత్త సేకరణ అని పిలుస్తారు మరియు చెత్తను సేకరించే యంత్రాంగాన్ని చెత్త కలెక్టర్ ( GC ) అంటారు.

కాబట్టి ఆబ్జెక్ట్‌ను ఎప్పుడు డిలీట్ చేయాలో జావా మెషీన్‌కి ఎలా తెలుస్తుంది?

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

జావాలో, మీరు ఇప్పటికే ఉన్న వస్తువుకు సూచనను సృష్టించలేరు — మీరు ఇప్పటికే కలిగి ఉన్న సూచనలను మాత్రమే కేటాయించగలరు. మేము ఒక వస్తువుకు సంబంధించిన అన్ని సూచనలను తొలగిస్తే, అది శాశ్వతంగా పోతుంది.

వృత్తాకార సూచనలు

మేము ఒక సాధారణ ప్రతిరూపం పొందే వరకు ఆ తర్కం గొప్పగా అనిపిస్తుంది: మన దగ్గర ఒకదానికొకటి సూచించే రెండు వస్తువులు ఉన్నాయని అనుకుందాం (ఒకదానికొకటి రిఫరెన్స్‌లను నిల్వ చేయండి). ఏ ఇతర వస్తువులు ఈ వస్తువులకు సూచనలను నిల్వ చేయవు.

ఈ ఆబ్జెక్ట్‌లు కోడ్ నుండి యాక్సెస్ చేయబడవు, కానీ అవి ఇప్పటికీ సూచించబడుతున్నాయి.

అందుకే చెత్త సేకరించేవాడు వస్తువులను "రిఫరెన్స్" మరియు "రిఫరెన్స్డ్" కాకుండా రీచబుల్ మరియు అన్ రీచబుల్ అని విభజిస్తాడు.

చేరుకోగల వస్తువులు

ముందుగా, 100% సజీవంగా ఉన్న వస్తువులు చేరుకోగల జాబితాకు జోడించబడతాయి. ఉదాహరణకు, ప్రస్తుత థ్రెడ్ ( Thread.current()) లేదా కన్సోల్ ఇన్‌పుట్‌స్ట్రీమ్ ( System.in).

ఆపై చేరుకోగల వస్తువుల జాబితా ప్రారంభ చేరుకోగల వస్తువుల ద్వారా సూచించబడిన వస్తువులను చేర్చడానికి విస్తరిస్తుంది. ఈ విస్తారిత సెట్ ద్వారా సూచించబడిన వస్తువులను చేర్చడానికి ఇది మళ్లీ విస్తరించబడుతుంది.

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

3. చెత్త సేకరణ

మెమరీ ఫ్రాగ్మెంటేషన్

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

ఫలితంగా, మనం పెద్ద వస్తువును (ఉదాహరణకు, మిలియన్ మూలకాలతో కూడిన శ్రేణి) సృష్టించలేని పరిస్థితికి సులభంగా చేరుకోవచ్చు, ఎందుకంటే ఉచిత మెమరీలో పెద్ద భాగం లేదు. మరో మాటలో చెప్పాలంటే, ఉచిత మెమరీ ఉండవచ్చు, చాలా వరకు కూడా ఉండవచ్చు, కానీ ఉచిత మెమరీ యొక్క పెద్ద వరుస బ్లాక్ ఉండకపోవచ్చు.

మెమరీ ఆప్టిమైజేషన్ (డిఫ్రాగ్మెంటేషన్)

జావా యంత్రం ఈ సమస్యను నిర్దిష్ట మార్గంలో పరిష్కరిస్తుంది. ఇది ఇలా కనిపిస్తుంది:

జ్ఞాపకశక్తిని రెండు భాగాలుగా విభజించారు. అన్ని వస్తువులు కేవలం సగం మెమరీలో సృష్టించబడతాయి (మరియు తొలగించబడతాయి). మెమరీలోని రంధ్రాలను శుభ్రం చేయడానికి సమయం వచ్చినప్పుడు, మొదటి సగంలోని అన్ని వస్తువులు రెండవ సగంకి కాపీ చేయబడతాయి. కానీ అవి ఒకదానికొకటి సరిగ్గా కాపీ చేయబడతాయి, తద్వారా రంధ్రాలు లేవు.

ప్రక్రియ సుమారుగా ఇలా కనిపిస్తుంది:

దశ 1: వస్తువులను సృష్టించిన తర్వాత

దశ 2: "రంధ్రాల" స్వరూపం

దశ 3: "రంధ్రాల" తొలగింపు

అందుకే మీరు వస్తువులను తొలగించాల్సిన అవసరం లేదు. జావా మెషీన్ కేవలం అన్ని చేరుకోగల వస్తువులను కొత్త స్థానానికి కాపీ చేస్తుంది మరియు ఆబ్జెక్ట్‌లు నిల్వ చేయబడిన మొత్తం మెమరీ ప్రాంతాన్ని ఖాళీ చేస్తుంది.