జావాలో, ' ClassCastException ”అభివృద్ధి దశలో డెవలపర్‌లు వాటిని పట్టుకోవడానికి అనుమతించడం ద్వారా రన్‌టైమ్‌లో టైప్ అనుకూలత సమస్యలను గుర్తించడంలో సహాయపడుతుంది. ఇది రకం భద్రతను కూడా నిర్ధారిస్తుంది, ప్రోగ్రామ్‌లోని అసమానతలను నివారిస్తుంది. డీబగ్గింగ్, టెస్టింగ్, సరైన టైప్ కాస్టింగ్ మొదలైన ప్రక్రియలో ClassCastException చాలా సహాయపడుతుంది.
ఈ గైడ్ జావాలో ClassCastExceptionను పరిష్కరించే విధానాన్ని ప్రదర్శిస్తుంది.
జావాలో ClassCastException ఎలా పుడుతుంది?
ది ' ClassCastException ” సరైన టైప్ కాస్టింగ్‌ని నిర్ధారిస్తుంది మరియు అననుకూల రకం మార్పిడుల వల్ల ఏర్పడే రన్‌టైమ్ లోపాలను నివారిస్తుంది. సరళంగా చెప్పాలంటే, ఒక వస్తువు అననుకూల రకానికి ప్రసారం చేయడానికి ప్రయత్నించినప్పుడు ఈ మినహాయింపు విసిరివేయబడుతుంది.
ఉదాహరణకు, ఈ క్రింది కోడ్‌ని సందర్శించండి “ ClassCastException 'జావాలో:
దిగుమతి java.io.* ;
దిగుమతి java.lang.* ;
దిగుమతి java.util.* ;
తరగతి LinuxHint {
//డ్రైవర్ క్లాస్ సృష్టి
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ )
{
ప్రయత్నించండి {
వస్తువు తల్లిదండ్రులు = కొత్త వస్తువు ( ) ;
స్ట్రింగ్ బిడ్డ = ( స్ట్రింగ్ ) తల్లిదండ్రులు ;
వ్యవస్థ . బయటకు . println ( బిడ్డ ) ;
}
క్యాచ్ ( మినహాయింపు f ) {
వ్యవస్థ . బయటకు . println ( f ) ;
}
}
}
పై కోడ్ యొక్క వివరణ:
- లో ' ప్రయత్నించండి 'బ్లాక్, ఒక వస్తువు యొక్క ఉదాహరణ' తల్లిదండ్రులు 'ని ఉపయోగించడం ద్వారా ప్రకటించబడింది' కొత్త ” కీవర్డ్.
- ఆ తరువాత, టైప్‌కాస్టింగ్ ఉపయోగించబడుతుంది దీనిలో ' వస్తువు 'రకం టైప్‌కాస్ట్ చేయబడుతోంది మరియు పేరు కలిగి ఉంది' బిడ్డ ”.
- ఈ టైప్‌కాస్టింగ్ పేరెంట్ క్లాస్ దాని చైల్డ్ క్లాస్‌కి టైప్ కాస్ట్ చేయకూడదనే నియమాన్ని ఉల్లంఘిస్తోంది. అందుకే మినహాయింపు పుడుతుంది ఎందుకంటే ' వస్తువు ”టైప్ అనేది పేరెంట్ క్లాస్.
- చివరికి, ' క్యాచ్ 'బ్లాక్ ఉపయోగించబడుతుంది' మినహాయింపు ” పారామీటర్‌గా మరియు కన్సోల్‌లో సందేశాన్ని ప్రింట్ చేస్తుంది.
అమలు దశ ముగిసిన తర్వాత:
ఎగువ స్నాప్‌షాట్ జావాలో ClassCastException సంభవించడాన్ని చూపుతుంది.
జావాలో ClassCastExceptionను ఎలా పరిష్కరించాలి?
డెవలపర్ సులభంగా పరిష్కరించగల లేదా పెంచే అవకాశాన్ని నివారించగల మూడు పరిష్కారాలు ఉపయోగించబడతాయి. ClassCastException ” జావాలో.
ఈ పరిష్కారాలు క్రింద విడిగా వివరించబడ్డాయి:
పరిష్కారం 1: 'ఉదాహరణ' ఆపరేటర్ యొక్క ఉపయోగం
ది ' ఉదాహరణ 'ఆపరేటర్ ధృవీకరిస్తే' వస్తువు ” అనేది కోరుకున్న రకం లేదా కాదు. ఈ ధృవీకరణ '' సంభవించడాన్ని నిరోధించడంలో సహాయపడుతుంది ClassCastException ”. ఉదాహరణకు, దిగువ కోడ్ బ్లాక్‌ని సందర్శించండి:
ప్రజా తరగతి TypeCheckingLinuxHint {ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
వస్తువు తల్లిదండ్రులు = 'LinuxHint ఫ్యామిలీ' ;
ఉంటే ( తల్లిదండ్రులు ఉదాహరణ స్ట్రింగ్ ) {
స్ట్రింగ్ బిడ్డ = ( స్ట్రింగ్ ) తల్లిదండ్రులు ;
వ్యవస్థ . బయటకు . println ( 'టైప్‌కాస్టింగ్ స్ట్రింగ్ తర్వాత:' + బిడ్డ ) ;
} లేకపోతే {
వ్యవస్థ . బయటకు . println ( 'వస్తువు అనేది కావలసిన రకం స్ట్రింగ్ యొక్క ఉదాహరణ.' ) ;
}
}
}
పై కోడ్ యొక్క వివరణ:
- మొదట, ' తల్లిదండ్రులు 'ఆబ్జెక్ట్ సృష్టించబడింది, ఇది లోపల డమ్మీ విలువతో ప్రారంభించబడింది' ప్రయత్నించండి ”బ్లాక్.
- అప్పుడు, ఉపయోగించండి 'ఉంటే' ప్రకటనలో ' ఉదాహరణ '' యొక్క ఉదాహరణను తనిఖీ చేయడానికి ఆపరేటర్ ఉపయోగించబడుతుంది తల్లిదండ్రులు 'కావలసిన వస్తువు' స్ట్రింగ్ ” రకం.
- తర్వాత, పరిస్థితి తిరిగి వస్తే “ నిజం ” టైప్‌కాస్టింగ్ నిర్వహించబడుతుంది మరియు కన్సోల్‌లో ప్రదర్శించబడుతుంది.
- లేదంటే, కన్సోల్‌లో అనుకూల దోష సందేశం ప్రదర్శించబడుతుంది.
అమలు దశ ముగిసిన తర్వాత:
స్నాప్‌షాట్ టైప్‌కాస్టింగ్ విజయవంతంగా పూర్తయిందని మరియు ClassCastExceptionని ఉపయోగించి పరిష్కరించబడిందని చూపిస్తుంది ఉదాహరణ ” ఆపరేటర్.
పరిష్కారం 2: సమీక్ష మరియు సరైన టైప్‌కాస్టింగ్ ఆపరేషన్
కోడ్‌ను అనేకసార్లు తనిఖీ చేయడం మరియు టైప్‌కాస్టింగ్ కోసం అనుకూల రకాలను సమీక్షించడం మరొక పరిష్కారం. ఉదాహరణకు, దిగువ కోడ్‌ను సందర్శించండి, దీనిలో ' ClassCastException టైప్‌కాస్టింగ్‌కు అనుకూలం కాని కావలసిన రకం కారణంగా అరెస్టు చేయబడతాడు:
ప్రజా తరగతి TypeCheckLinuxHint {ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
వస్తువు తల్లిదండ్రులు = 'LinuxHint ఫ్యామిలీ' ;
పూర్ణ సంఖ్య మార్చబడిన సంఖ్య = ( పూర్ణ సంఖ్య ) తల్లిదండ్రులు ;
వ్యవస్థ . బయటకు . println ( 'టైప్‌కాస్టింగ్ తర్వాత సంఖ్య:' + మార్చబడిన సంఖ్య ) ;
}
}
పై కోడ్‌లో, ప్రోగ్రామర్ ''ని తప్పుగా ప్రసారం చేసారు స్ట్రింగ్ ' నుండి ' పూర్ణ సంఖ్య ”.
సంకలన దశ ముగిసిన తర్వాత:
ఎగువ స్నాప్‌షాట్ ClassCastException సంభవించడాన్ని చూపుతుంది.
పరిష్కారం 3: జెనరిక్స్ ఉపయోగం
ప్రోగ్రామర్లు ఉపయోగించవచ్చు ' జెనరిక్స్ ” ఊహించిన రకాలను పేర్కొనడానికి మరియు సంకలన సమయంలో రకం భద్రతను అమలు చేయడానికి.
ఉదాహరణకు, క్రింది కోడ్‌ని సందర్శించండి:
దిగుమతి java.util.ArrayList ;దిగుమతి java.util.List ;
ప్రజా తరగతి జెనరిక్స్ ఉపయోగించి {
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
జాబితా < స్ట్రింగ్ > empname = కొత్త అర్రేలిస్ట్ <> ( ) ;
empname. జోడించు ( 'హ్యారీ' ) ;
empname. జోడించు ( 'కుమ్మరి' ) ;
స్ట్రింగ్ ప్రారంభ = empname. పొందండి ( 0 ) ;
స్ట్రింగ్ చివరి = empname. పొందండి ( 1 ) ;
వ్యవస్థ . బయటకు . println ( 'మొదటి పేరు: ' + ప్రారంభ ) ;
వ్యవస్థ . బయటకు . println ( 'రెండవ పేరు: ' + చివరి ) ;
}
}
పై కోడ్ యొక్క వివరణ:
- ముందుగా, అవసరమైన యుటిలిటీలు జావా ఫైల్‌లోకి దిగుమతి చేయబడతాయి మరియు '' జెనరిక్స్ ఉపయోగించి ” అని ప్రకటించారు.
- తరువాత, ' అర్రేలిస్ట్ 'రకం' స్ట్రింగ్ ' పేరుతో ప్రకటించబడింది ' empname ” మరియు రెండు నకిలీ డేటా మూలకాలను అందించడం ద్వారా ప్రారంభించబడింది.
- అప్పుడు, '' పేరుతో రెండు స్ట్రింగ్-టైప్ వేరియబుల్స్ సృష్టించండి ప్రారంభ 'మరియు' చివరి ”. ఆ తర్వాత, ఇండెక్స్ సంఖ్యలను యాక్సెస్ చేయడం ద్వారా విలువలను కేటాయించండి.
- చివరికి, ఫలితాన్ని చూడటానికి రెండు వేరియబుల్‌లను ప్రదర్శించండి.
అమలు ముగిసిన తర్వాత, అవుట్‌పుట్ ఇలా కనిపిస్తుంది:
పై స్నాప్‌షాట్ జెనరిక్స్ ఉపయోగించి టైప్‌కాస్టింగ్ నిర్వహించబడిందని వివరిస్తుంది.
ముగింపు
పరిష్కరించడానికి ' ClassCastException 'జావాలో, ప్రోగ్రామర్ సరైన రకం అనుకూలతను నిర్ధారించాలి,' జెనరిక్స్ ' ఇంకా ' ఉదాహరణ ” ఆపరేటర్. మినహాయింపును పరిష్కరించడానికి, ప్రోగ్రామర్ తప్పనిసరిగా సరైన రకం అనుకూలతను నిర్ధారించడం ద్వారా కాస్టింగ్ ఆపరేషన్‌ను సమీక్షించి సరిచేయాలి. అంతేకాకుండా, ఈ ' ClassCastException 'ని ఉపయోగించడం ద్వారా నివారించవచ్చు' జెనరిక్స్ 'మరియు' ఉపయోగంతో ఉదాహరణ ” ఆపరేటర్. ఈ గైడ్ జావాలో ClassCastExceptionను పరిష్కరించే పద్ధతిని ప్రదర్శించింది.