చివరి మరియు ఇతర జావా కీలకపదాలు

"హాయ్, అమిగో!"

"హాయ్, బిలాబో!"

"ఈ రోజు నేను మీకు జావాలోని అనేక కీలకపదాల గురించి చెప్పబోతున్నాను. అయితే నేను చాలా ఆసక్తికరమైన దానితో ప్రారంభిస్తాను: కీవర్డ్ ఫైనల్. "

" వేరియబుల్, మెథడ్ లేదా క్లాస్‌ని డిక్లేర్ చేసేటప్పుడు మీరు ఫైనల్ కీవర్డ్‌ని ఉపయోగించవచ్చు ."

"మరి మనకు ఫైనల్ ఎందుకు కావాలి?"

"ఇది చాలా సులభం. మనం వేరియబుల్‌ని ఫైనల్‌గా గుర్తు పెట్టినట్లయితే, అది మార్చలేనిదిగా మారుతుంది:"

final int i = 5;
i++; //Compilation error: the value of i cannot be changed.

"అలాగా."

"మేము ఒక పద్ధతిని ఫైనల్‌గా గుర్తించినట్లయితే, ఉత్పన్నమైన తరగతులలో పద్ధతిని భర్తీ చేయడం నిషేధించబడింది:"

class Cat
{
 public final String getName()
 {
  return "cat";
 }
}

class Tiger extends Cat
{
 public String getName() //Compilation error: overriding the getName()
 {
  return "tiger";
 }
}

"నేను చూస్తున్నాను. అయితే మీరు ఒక పద్ధతిని అధిగమించడాన్ని ఎందుకు నిషేధించాలి?"

"సరే, ఒక ఉదాహరణగా, ఒక ప్రోగ్రామర్ ఒక పద్ధతిలో చాలా ముఖ్యమైన కోడ్‌ను వ్రాసాడని మరియు అతని తరగతిని వారసత్వంగా పొందిన అన్ని తరగతులు పేర్కొన్న ప్రవర్తనను కలిగి ఉంటాయని హామీ ఇవ్వాలనుకుంటున్నారని అనుకుందాం."

"మరియు చివరకు, మూడవ ఉపయోగం."

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

public final class Cat
{
 public String getName()
 {
  return "cat";
 }
}

class Tiger extends Cat //Compilation error: the Cat class cannot be
{
 public String getName()
 {
  return "tiger";
 }
}

"మరియు మేము ఒక తరగతిని వారసత్వంగా పొందకుండా ఎందుకు నిరోధిస్తాము?"

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

"కానీ డెవలపర్ తన తరగతికి చిన్న మార్పులు కూడా ఊహించిన విధంగా పని చేయడం ఆపివేయడానికి కారణమవుతుందని గుర్తిస్తే, వారసత్వాన్ని నిషేధించడం మంచిది."

"ఉదాహరణకు, స్ట్రింగ్ క్లాస్ అంతిమంగా ప్రకటించబడింది, అన్ని ఆదిమ రకాలు: పూర్ణాంకం, బూలియన్, డబుల్, అక్షరం..."

"ఆహ్, అర్థమైంది. స్ట్రింగ్ క్లాస్ ఒక మార్పులేని తరగతిగా సృష్టించబడింది మరియు అవి అకస్మాత్తుగా మార్చబడినట్లయితే, చాలా విషయాలు పని చేయడం ఆగిపోతాయి."

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

"మీరు ఫైనల్‌ని ఎక్కడ ఉపయోగించగలరు?"

"ఫంక్షన్ పారామీటర్‌ల ముందు మరియు వేరియబుల్స్‌కు ముందు మీరు ఫైనల్‌ని ఉపయోగించవచ్చు. ఇక్కడ ఒక ఉదాహరణ ఉంది:"

public void setName(final String name)
{
 final String displayName = "Mr."+ name;
  …
 this.name = displayName;
}

"మరి దాని ప్రయోజనం ఏమిటి?"

"సరే, రెండు ఉన్నాయి. ముందుగా, మేము ఇతర డెవలపర్‌లకు ఈ విలువ ఒక నిర్దిష్ట స్థిరాంకం అని మరియు కేవలం వేరియబుల్ మాత్రమే కాదని చెప్పాలనుకుంటే, మేము వేరియబుల్‌ను ఫైనల్‌గా ప్రకటిస్తాము."

ఉదాహరణకు, మేము ధర ఆధారంగా అమ్మకపు పన్నును లెక్కించాలనుకుంటున్నాము:

public int getPriceNDS()
{
 final int NDS = 20;
 return this.price * NDS / 200;
}

"మరియు రెండవది, లోకల్ లేదా అనామక అంతర్గత తరగతులను వ్రాసేటప్పుడు మనకు ఈ రకమైన వేరియబుల్ అవసరం. ఈ రకమైన తరగతుల గురించి నేను మీకు త్వరలో చెబుతాను. కానీ ఈరోజు కాదు."

"సరే, ఇంతవరకు సంక్లిష్టంగా ఏమీ లేదు."

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

"వాస్తవానికి నేను దాని గురించి అడగబోతున్నాను. మరియు వస్తువును మార్చలేని విధంగా చేయడానికి మార్గం లేదా?"

"లేదు, మీరు మార్పులేని తరగతి వ్రాస్తే తప్ప."

"దయచేసి తుది వేరియబుల్ యొక్క విలువను మార్చలేనందున, మీరు దాని ప్రారంభ విలువను వెంటనే కేటాయించాలి."

class Home
{
 private final int width = 200;
 private final int height = 100;

 public Home()
 {
 }
}

class Home
{
 private final int width;
 private final int height;

 public Home()
 {
 }
}

"కానీ, జావా కన్స్ట్రక్టర్ వరకు క్లాస్ యొక్క చివరి వేరియబుల్స్ ప్రారంభించడాన్ని ఆలస్యం చేస్తుంది."

class Home
{
 private final int width = 200;
 private final int height;

 public Home()
 {
  height = 100;
 }
}

class Home
{
 private final int width;
 private final int height;

 public Home()
 {
  height = 100;
 }
}

"అదనంగా, వేర్వేరు కన్స్ట్రక్టర్‌లు వేర్వేరు విలువలతో తుది వేరియబుల్‌లను ప్రారంభించవచ్చు. ఇది చాలా సౌకర్యవంతంగా ఉంటుంది:"

class Home
{
 private final int width;
 private final int height;

 public Home()
 {
  height = 100;
  width = 200;
 }

 public Home(int width)
 {
  this.height = 300;
  this.width = width;
 }

 public Home(int width, int height)
 {
  this.height = height;
  this.width = width;
 }
}

"ఇది నిజంగా ఆసక్తికరమైన అంశం, మరియు ఖచ్చితంగా ప్రతిదీ అర్ధమే. ధన్యవాదాలు, బిలాబో!"