కాస్టింగ్ టైప్ చేయండి. మార్పిడులను విస్తరించడం మరియు తగ్గించడం

class Animal
{
public void doAnimalActions();
}class Cat extends Animal
{
public void doCatActions();
}class Tiger extends Cat
{
public void doTigerActions();
}

public static void main(String[] args)
{
Tiger tiger = new Tiger();
Cat cat = new Tiger();
Animal animal = new Tiger();
Object obj = new Tiger();
}

public static void main(String[] args)
{
Object obj = new Tiger();
Animal animal = (Animal) obj;
Cat cat = (Cat) obj;
Tiger tiger = (Tiger) animal;
Tiger tiger2 = (Tiger) cat;
}

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

ఈ చిన్న ఆవిష్కరణ టైప్ కాస్టింగ్ లోపాల సంఖ్యలో అనేక రెట్లు తగ్గింపును ఉత్పత్తి చేసింది మరియు జావా ప్రోగ్రామ్‌ల స్థిరత్వాన్ని గణనీయంగా పెంచింది.

public static void main(String[] args)
{
Object obj = new Tiger();
if (obj instanceof Cat)
{
Cat cat = (Cat) obj;
cat.doCatActions();
}}

public static void main(String[] args)
{
Animal animal = new Tiger();
doAllAction(animal);

Animal animal2 = new Cat();
doAllAction(animal2);

Animal animal3 = new Animal();
doAllAction(animal3);
}

public static void doAllAction(Animal animal)
{
if (animal instanceof Tiger)
{
Tiger tiger = (Tiger) animal;
tiger.doTigerActions();
}

if (animal instanceof Cat)
{
Cat cat = (Cat) animal;
cat.doCatActions();
}

animal.doAnimalActions();
}

మేము ఏ రకమైన వస్తువుతో పని చేస్తున్నామో మాకు (మా కోడ్) ఎల్లప్పుడూ తెలియదు. ఇది వేరియబుల్ (జంతువు), లేదా ఏదైనా సంతతి రకం (పిల్లి, పులి) వలె ఒకే రకమైన వస్తువు కావచ్చు.

doAllAction పద్ధతిని పరిగణించండి. పంపబడిన వస్తువు రకంతో సంబంధం లేకుండా ఇది సరిగ్గా పని చేస్తుంది.

మరో మాటలో చెప్పాలంటే, ఇది మూడు రకాలైన జంతువులు, పిల్లి మరియు పులికి సరిగ్గా పని చేస్తుంది.

public static void main(String[] args)
{
Cat cat = new Tiger();
Animal animal = cat;
Object obj = cat;
}

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