ఈ బ్లాగ్ జావాలో 'తాత్కాలిక' కీవర్డ్ వినియోగం మరియు అమలు గురించి వివరిస్తుంది.
జావాలో 'తాత్కాలిక' కీవర్డ్ ఏమిటి?
జావా' క్షణికమైన 'కీవర్డ్ నివారించేందుకు ఉపయోగించబడుతుంది' సీరియలైజేషన్ ”. డేటా స్ట్రక్చర్‌లోని ఏదైనా వస్తువు తాత్కాలికంగా కేటాయించబడితే, అది సీరియలైజ్ చేయబడదని అర్థం. ఇది ఒక నిర్దిష్ట వేరియబుల్ తాత్కాలికంగా కేటాయించబడితే, అది ఫైల్‌లో వ్రాయబడదు మరియు “ 0 ” బదులుగా నిల్వ చేయబడుతుంది.
వాక్యనిర్మాణం
ప్రైవేట్ క్షణికమైన < మేమ్ var >;
ఈ వాక్యనిర్మాణంలో, ' మేమ్ var ”గా కేటాయించబడిన వేరియబుల్‌కు పాయింట్లు” క్షణికమైన ”.
ఉదాహరణకి వెళ్లే ముందు, ''తో పని చేయడానికి క్రింది లైబ్రరీలను చేర్చారని నిర్ధారించుకోండి. సీరియలైజ్ చేయదగినది ”ఇంటర్ఫేస్ మరియు అన్ని తరగతులు మరియు పద్ధతులను వరుసగా యాక్సెస్ చేయండి:
దిగుమతి java.io.Serialisable ;
దిగుమతి java.io.* ;
జావాలో 'తాత్కాలిక' కీవర్డ్ యొక్క ప్రదర్శన
కింది ఉదాహరణలో, ' క్షణికమైన ” కీవర్డ్‌ని వేరియబుల్‌తో అనుబంధించవచ్చు అంటే ఆబ్జెక్ట్‌లో దాని పాస్ చేసిన విలువ ఫైల్‌లో వ్రాయబడదు:
ప్రజా తరగతి తాత్కాలిక కీ అమలు చేస్తుంది సీరియలైజ్ చేయదగినది {స్ట్రింగ్ పేరు ;
స్ట్రింగ్ నగరం ;
క్షణికమైన int వయస్సు ;
తాత్కాలిక కీ ( స్ట్రింగ్ పేరు, స్ట్రింగ్ నగరం, int వయస్సు ) {
ఇది . పేరు = పేరు ;
ఇది . నగరం = నగరం ;
ఇది . వయస్సు = వయస్సు ;
}
పైన పేర్కొన్న కోడ్ లైన్ల ప్రకారం, దిగువ అందించిన దశలను వర్తింపజేయండి:
- అన్నింటిలో మొదటిది, '' అనే తరగతిని నిర్వచించండి తాత్కాలిక కీ 'అది అమలు చేస్తుంది' సీరియలైజ్ చేయదగినది ” క్లాస్ ఆబ్జెక్ట్‌ని సీరియలైజ్ చేయగలిగేలా చేయడానికి మరియు ఆబ్జెక్ట్ యొక్క మార్పిడిని ఫైల్ రూపంలో సేవ్ చేయడానికి అనుమతిస్తుంది.
- క్లాస్ డెఫినిషన్‌లో, 'తో పేర్కొన్న వేరియబుల్స్‌ను పేర్కొనండి వయస్సు ''గా కేటాయించబడింది క్షణికమైన ”.
- ఇప్పుడు, పేర్కొన్న వేరియబుల్స్‌కు సమానంగా పేర్కొన్న పారామితులను కలిగి ఉన్న క్లాస్ కన్స్ట్రక్టర్‌ను సృష్టించండి.
- కన్స్ట్రక్టర్ డెఫినిషన్‌లో, పేర్కొన్న వేరియబుల్స్‌ని చూడండి మరియు వాటికి పరామితి విలువలను '' ద్వారా కేటాయించండి ఇది ”.
ఇప్పుడు, అవలోకనం ' ప్రధాన ” కోడ్ స్నిప్పెట్:
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ ఆర్గ్స్ [ ] ) విసురుతాడు మినహాయింపు {తాత్కాలిక వస్తువు = కొత్త తాత్కాలిక కీ ( 'హ్యారీ' , 'లండన్' , 22 ) ;
FileOutputStream ఫైల్ అవుట్ = కొత్త FileOutputStream ( 'defaultfile.txt' ) ;
ObjectOutputStream objOut = కొత్త ObjectOutputStream ( ఫైల్ అవుట్ ) ;
objOut. ఆబ్జెక్ట్ వ్రాయండి ( వస్తువు ) ;
objOut. ఫ్లష్ ( ) ;
objOut. దగ్గరగా ( ) ;
ఫైల్ అవుట్. దగ్గరగా ( ) ;
వ్యవస్థ . బయటకు . println ( 'డేటా విజయవంతంగా నిల్వ చేయబడింది!' ) ;
ObjectInputStream ఫైల్ = కొత్త ObjectInputStream ( కొత్త FileInputStream ( 'defaultfile.txt' ) ) ;
తాత్కాలిక కీ రీడ్‌డేటా = ( తాత్కాలిక కీ ) ఫైల్. చదివే వస్తువు ( ) ;
వ్యవస్థ . బయటకు . println ( డేటా చదవండి. పేరు + '' + డేటా చదవండి. నగరం + '' + డేటా చదవండి. వయస్సు + '' ) ;
ఫైల్. దగ్గరగా ( ) ;
} }
లో ' ప్రధాన ”, దిగువ అందించిన దశలను పరిగణించండి:
- '' ద్వారా తరగతి వస్తువును సృష్టించండి కొత్త 'కీవర్డ్ మరియు' తాత్కాలిక కీ() ” కన్స్ట్రక్టర్, వరుసగా, మరియు పేర్కొన్న విలువలను కన్స్ట్రక్టర్ ఆర్గ్యుమెంట్‌లుగా పాస్ చేయండి.
- తదుపరి దశలో, 'ని సృష్టించండి FileOutputStream ”ఆబ్జెక్ట్ పాస్ చేసిన డేటాను పేర్కొన్న వాటికి వ్రాయడానికి ఫైల్ .
- ఆ తర్వాత, అదే విధంగా, 'ని సృష్టించండి ObjectOutputStream 'ఆబ్జెక్ట్‌ను వ్రాయడానికి ఆబ్జెక్ట్‌లు చదవగలవు' ObjectInputStream ”.
- ఇప్పుడు, వర్తించు ' రైట్ ఆబ్జెక్ట్() 'నిర్దిష్ట తరగతి వస్తువును వ్రాయడానికి పద్ధతి' ObjectOutputStream ”.
- స్ట్రీమ్‌ను ఫ్లష్ చేయడానికి మరియు మూసివేయడానికి, “ని వర్తింపజేయండి ఫ్లష్ () 'మరియు' దగ్గరగా() ” పద్ధతులు, వరుసగా.
- ఫైల్‌ను చదవడానికి, ''ని సృష్టించండి ObjectInputStream ”ఆబ్జెక్ట్ మరియు వ్రాసిన ఫైల్‌ను ఒక “గా సేకరించండి FileInputStream ” నుండి ఇన్‌పుట్ బైట్‌లను పొందేందుకు పరామితి ఫైల్ .
- చివరగా, సృష్టించిన క్లాస్ ఆబ్జెక్ట్‌ను సూచించడం ద్వారా ఫైల్ యొక్క కంటెంట్‌లను చదవండి “ తాత్కాలిక కీ ”.
- అల్గోరిథం: ఆబ్జెక్ట్‌లో ఆమోదించబడిన విలువలు ఫైల్‌కి ''గా కేటాయించబడిన విలువ మినహా వ్రాయబడతాయి. క్షణికమైన ”. ఫైల్‌ని చదివిన తర్వాత, అన్ని విలువలు తిరిగి పొందబడతాయి కానీ తాత్కాలిక విలువ ''గా ప్రదర్శించబడుతుంది. 0 ”.
మొత్తం కోడ్
ప్రజా తరగతి తాత్కాలిక కీ అమలు చేస్తుంది సీరియలైజ్ చేయదగినది {స్ట్రింగ్ పేరు ;
స్ట్రింగ్ నగరం ;
క్షణికమైన int వయస్సు ;
తాత్కాలిక కీ ( స్ట్రింగ్ పేరు, స్ట్రింగ్ నగరం, int వయస్సు ) {
ఇది . పేరు = పేరు ;
ఇది . నగరం = నగరం ;
ఇది . వయస్సు = వయస్సు ;
}
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ ఆర్గ్స్ [ ] ) విసురుతాడు మినహాయింపు {
తాత్కాలిక వస్తువు = కొత్త తాత్కాలిక కీ ( 'హ్యారీ' , 'లండన్' , 22 ) ;
FileOutputStream ఫైల్ అవుట్ = కొత్త FileOutputStream ( 'defaultfile.txt' ) ;
ObjectOutputStream objOut = కొత్త ObjectOutputStream ( ఫైల్ అవుట్ ) ;
objOut. ఆబ్జెక్ట్ వ్రాయండి ( వస్తువు ) ;
objOut. ఫ్లష్ ( ) ;
objOut. దగ్గరగా ( ) ;
ఫైల్ అవుట్. దగ్గరగా ( ) ;
వ్యవస్థ . బయటకు . println ( 'డేటా విజయవంతంగా నిల్వ చేయబడింది!' ) ;
ObjectInputStream ఫైల్ = కొత్త ObjectInputStream ( కొత్త FileInputStream ( 'defaultfile.txt' ) ) ;
తాత్కాలిక కీ రీడ్‌డేటా = ( తాత్కాలిక కీ ) ఫైల్. చదివే వస్తువు ( ) ;
వ్యవస్థ . బయటకు . println ( డేటా చదవండి. పేరు + '' + డేటా చదవండి. నగరం + '' + డేటా చదవండి. వయస్సు + '' ) ;
ఫైల్. దగ్గరగా ( ) ;
} }
అవుట్‌పుట్
పై ఫలితంలో, '' వయస్సు ''గా కేటాయించబడింది క్షణికమైన ”, కాబట్టి దాని విలువ ఫైల్‌లో వ్రాయబడలేదు మరియు తదనుగుణంగా తిరిగి పొందబడింది అంటే, “ 0 ”.
ఫైల్ సృష్టించబడింది
సృష్టించబడిన ఫైల్ క్రింద ప్రదర్శించబడుతుంది:
ఇది జావాలో తాత్కాలిక కీవర్డ్ వాడకం గురించి.
ముగింపు
సీరియలైజేషన్ నుండి దూరంగా ఉండటానికి జావా తాత్కాలిక కీవర్డ్ ఉపయోగించబడుతుంది అంటే ఒక నిర్దిష్ట వేరియబుల్ ఇలా కేటాయించబడితే “ క్షణికమైన ”, ఇది ఫైల్‌లో వ్రాయబడదు మరియు “ 0 ” బదులుగా నిల్వ చేయబడుతుంది. ఈ వ్యాసం ఉపయోగం మరియు అమలు గురించి చర్చించింది ' క్షణికమైన ”జావాలో కీవర్డ్.