శూన్యం మరియు ఇతరులు.

"హాయ్, అమిగో! నేను మీ కోసం మరొక చిన్న మరియు ఆసక్తికరమైన అంశాన్ని పొందాను. శూన్య రకం."

"మరియు మీకు అలాంటి రకం ఎందుకు అవసరం? నా ఉద్దేశ్యం, నేను శూన్యాన్ని అర్థం చేసుకున్నాను: ఇది ఫంక్షన్‌లు మరియు విధానాలను సమలేఖనంలోకి తీసుకురావడం. మాకు విధానాలు లేవు, కానీ శూన్యతను తిరిగి ఇచ్చే ఫంక్షన్‌లు (ఏమీ లేవు)."

"అవును, కానీ ఎల్లీ ఈ మధ్యనే మీకు కాల్ చేయగల ఇంటర్‌ఫేస్ గురించి చెప్పినట్లు గుర్తుందా?"

"అవును."

"మరి మీరు టైప్ ఆర్గ్యుమెంట్‌గా పాస్ చేయాల్సినవి కూడా గుర్తున్నాయా?"

"అవును, రిటర్న్ విలువ రకం:"

class EmptyJob implements Callable
{
 public String call() throws Exception
 {
  return null;
 }
}

"రైట్. మరియు మీరు కాల్ పద్ధతిని ఒక పూర్ణాంకానికి తిరిగి ఇవ్వాలనుకుంటే ఏమి చేయాలి? అప్పుడు ఏమిటి?"

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

class EmptyJob implements Callable
{
 public Integer call() throws Exception
 {
  return null;
 }
}

"అద్భుతమైనది. మరియు పద్ధతి ఏమీ తిరిగి ఇవ్వకపోతే?"

"నేను మీ అభిప్రాయాన్ని అర్థం చేసుకున్నాను. అప్పుడు మేము శూన్యానికి ప్రతిరూపంగా Voidని ఉపయోగిస్తాము?"

"అవును."

"రిటర్న్ విలువను ఆబ్జెక్ట్‌గా చేసి, ఆపై శూన్యతను తిరిగి ఇవ్వడం సులభం కాదా?"

"కొన్నిసార్లు, కానీ ఎల్లప్పుడూ కాదు."

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

"లేదా పద్ధతికి కాల్ చేసే కోడ్ రిటర్న్ విలువను ఆశిస్తుంది."

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

class EmptyJob implements Callable
{
 public Void call() throws Exception
 {
  return null;
 }
}

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

"కోడ్ రీడబిలిటీ మొదట వస్తుంది. నాకు జావా ఇష్టం!"

"అద్భుతం. మీకు నచ్చినందుకు సంతోషిస్తున్నాను. ఈరోజుకి పూర్తి చేసాము."