సమూహ తరగతులను వారసత్వంగా పొందడం

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

"హాయ్, కిమ్."

"స్టాటిక్ మరియు నాన్-స్టాటిక్ నెస్టెడ్ క్లాస్‌లను వారసత్వంగా పొందడం గురించి నేను మీకు చెప్పాలనుకుంటున్నాను."

"నేను సిద్ధం."

"స్టాటిక్ నెస్టెడ్ క్లాస్‌లను వారసత్వంగా పొందడంలో నిజంగా ఎలాంటి సమస్యలు లేవు. అవి సాధారణ తరగతుల మాదిరిగానే వారసత్వంగా పొందబడతాయి:"

public class Car
{
 public static class Door
 {

 }
}

public class LamborghiniDoor extends Car.Door
{
}

"అయితే మనం స్టాటిక్ నెస్టెడ్ క్లాస్‌లు ఇతర క్లాస్‌లలో స్టాటిక్ నెస్టెడ్ క్లాస్‌లను వారసత్వంగా పొందేలా చేయగలమా?"

"ఎందుకు కాదు?"

public class Car
{
 public static class Door
 {

 }
}

public class Lamborghini extends Car
{
 public static class LamborghiniDoor extends Car.Door
 {
 }
}

"సరే, అర్థమైంది. అవి కూడా రెగ్యులర్ క్లాసుల మాదిరిగానే వారసత్వంగా వచ్చినవే, అవునా?"

"అవును. కానీ నాన్-స్టాటిక్ నెస్టెడ్ క్లాస్‌లు (అంతర్గత తరగతులు అంటారు) అంత సులభంగా వారసత్వంగా పొందవు."

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

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

"ఇది ఇలా కనిపిస్తుంది:"

public class Car
{
 public class Door
 {

 }
}

public class LamborghiniDoor extends Car.Door
{
 LamborghiniDoor(Car car)
 {
  car.super();
 }
}

"మీరు తప్పనిసరిగా డోర్ కన్‌స్ట్రక్టర్‌కు కార్ ఆబ్జెక్ట్‌ను పరోక్షంగా పంపించాలి. ఇది ప్రత్యేక నిర్మాణాన్ని ఉపయోగించి చేయబడుతుంది: «car.super()»."

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

"అవును, కొన్ని సూక్ష్మ నైపుణ్యాలు ఉన్నాయి, కానీ ఇది రాకెట్ సైన్స్ కాదు."