CodeGym /జావా కోర్సు /మాడ్యూల్ 2: జావా కోర్ /కాస్టింగ్ టైప్ చేయండి. మార్పిడులను విస్తరించడం మరియు తగ్గ...

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

మాడ్యూల్ 2: జావా కోర్
స్థాయి , పాఠం
అందుబాటులో ఉంది

"హాయ్, అమిగో! నేటి పాఠం యొక్క అంశం టైప్ మార్పిడులను విస్తృతం చేయడం మరియు సంకుచితం చేయడం. మీరు చాలా కాలం క్రితం ఆదిమ రకాలను వెడల్పు చేయడం మరియు కుదించడం గురించి తెలుసుకున్నారు. లెవల్ 10లో. ఈ రోజు మనం రిఫరెన్స్ రకాల కోసం ఇది ఎలా పని చేస్తుందనే దాని గురించి మాట్లాడబోతున్నాం, అనగా తరగతుల ఉదాహరణలు."

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

ఇక్కడ ఒక ఉదాహరణ:

కోడ్ వివరణ
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;
}
ఇక్కడ మాకు మూడు అసైన్‌మెంట్ ఆపరేషన్‌లు ఉన్నాయి. అవన్నీ విస్తృతమైన మార్పిడులకు ఉదాహరణలు.

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

"ఓహ్, రెండవ నుండి చివరి ఉదాహరణ ప్రతిదీ స్పష్టం చేసింది: చెక్ ఎందుకు అవసరం మరియు టైప్ కాస్టింగ్ ఎందుకు అవసరం."

"నేను ఆశిస్తున్నాను. ఈ వాస్తవాన్ని నేను మీ దృష్టిని ఆకర్షించాలనుకుంటున్నాను:"

ఇవేవీ వస్తువును ఏ విధంగానూ మార్చవు! నిర్దిష్ట రిఫరెన్స్ వేరియబుల్‌లో కాల్ చేయడానికి అందుబాటులో ఉన్న పద్ధతుల సంఖ్య మాత్రమే మారుతుంది .

ఉదాహరణకు, క్యాట్ వేరియబుల్ మిమ్మల్ని doAnimalActions మరియు doCatActions పద్ధతులను కాల్ చేయడానికి అనుమతిస్తుంది. టైగర్ ఆబ్జెక్ట్‌ని సూచించినప్పటికీ, దానికి doTigerActions పద్ధతి గురించి ఏమీ తెలియదు.

"అవును, నాకు అర్థమైంది. నేను అనుకున్నదానికంటే తేలికగా ఉంది."

వ్యాఖ్యలు
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION