జావాను ఉపయోగించి అప్లికేషన్‌ను డిజైన్ చేస్తున్నప్పుడు, డెవలపర్ అమలు చేసిన కోడ్ ఫంక్షనాలిటీలను ఎప్పటికప్పుడు విశ్లేషించాల్సిన నిర్దిష్ట పరీక్ష దృశ్యాలు ఉన్నాయి. అటువంటి సందర్భాలలో, ' కాంక్రీట్ తరగతులు ”అన్ని అమలు చేయబడిన కోడ్ ఫీచర్‌లను ఉపయోగించడంలో జావా కీలక పాత్ర పోషిస్తుంది, తద్వారా ప్రస్తుత వనరులను 100% ఉపయోగించుకుంటుంది మరియు అభివృద్ధి సమయంలో ఎటువంటి లాగ్ లేదా లొసుగును నివారించవచ్చు.
ఈ వ్యాసం జావా గురించి వివరిస్తుంది. కాంక్రీట్ క్లాస్ ”.
జావాలో కాంక్రీట్ క్లాస్ అంటే ఏమిటి?
ఎ' కాంక్రీట్ క్లాస్ ” జావాలో దాని అన్ని పద్ధతులను అమలు చేసే తరగతికి అనుగుణంగా ఉంటుంది. ఈ తరగతులు అమలు చేయని ఏ పద్ధతులను కలిగి ఉండకూడదు. అలాగే, ఇది పొడిగించవచ్చు ' నైరూప్య తరగతి 'లేదా అమలు చేయండి' ఇంటర్ఫేస్ ”అది దాని అన్ని పద్ధతులను అమలు చేస్తుంది.
గమనిక : కాంక్రీట్ క్లాస్ అనేది ఒక నైరూప్య పద్ధతిని కలిగి ఉన్నట్లయితే అది ఒక వియుక్త తరగతి.
ఉదాహరణ 1: జావాలో కాంక్రీట్ క్లాస్‌ని సృష్టించడం
జావా వినియోగాన్ని వివరించే క్రింది ఉదాహరణ యొక్క అవలోకనం ' కాంక్రీట్ క్లాస్ ”:
ప్రజా తరగతి కాంక్రీట్ క్లాస్ {
స్థిరమైన int గుణించాలి ( int x, int మరియు ) {
తిరిగి x * మరియు ;
}
స్థిరమైన int జోడించు ( int x, int మరియు ) {
తిరిగి x + మరియు ;
}
స్థిరమైన int చతురస్రం ( int x ) {
తిరిగి x * x ;
}
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
వ్యవస్థ . బయటకు . println ( 'గుణకారం అవుతుంది -> ' + గుణించాలి ( 2 , 3 ) ) ;
వ్యవస్థ . బయటకు . println ( 'అదనపు అవుతుంది ->' + జోడించు ( 2 , 3 ) ) ;
వ్యవస్థ . బయటకు . println ( 'విలువ యొక్క స్క్వేర్ అవుతుంది -> ' + చతురస్రం ( 2 ) ) ;
} }
పై కోడ్ లైన్లలో:
- ' అనే కాంక్రీట్ తరగతిని ప్రకటించండి కాంక్రీట్ క్లాస్ ”.
- దాని నిర్వచనంలో, పాస్ చేసిన సంఖ్యల గుణకారం, సంకలనం మరియు వర్గాన్ని వరుసగా తిరిగి ఇచ్చే పేర్కొన్న మూడు పారామిటరైజ్డ్ ఫంక్షన్‌లను చేర్చండి.
- లో ' ప్రధాన ”, పేర్కొన్న పూర్ణాంకాలను ఫంక్షన్ ఆర్గ్యుమెంట్‌లుగా పాస్ చేయడం ద్వారా మూడు ఫంక్షన్‌లను ప్రారంభించండి, తద్వారా అన్ని తరగతి పద్ధతులను అమలు చేయండి.
అవుట్‌పుట్
అవుట్‌పుట్‌లో, క్లాస్‌లోని అన్ని ఫంక్షనాలిటీలు అమలు చేయబడినట్లు చూడవచ్చు, తద్వారా ఇది “ కాంక్రీట్ క్లాస్ ”.
ఉదాహరణ 2: వియుక్త తరగతిని విస్తరించడం ద్వారా కాంక్రీట్ తరగతిని వర్తింపజేయడం
ఈ నిర్దిష్ట ఉదాహరణ ఒక వియుక్త తరగతిని విస్తరించే కాంక్రీట్ తరగతిని నిర్వచిస్తుంది (ఇంటర్‌ఫేస్‌ను అమలు చేయడం):
ఇంటర్ఫేస్ కాంక్రీటు {int గుణించాలి ( int x, int మరియు ) ;
int జోడించు ( int x, int మరియు ) ;
}
నైరూప్య తరగతి ఉత్పత్తి అమలు చేస్తుంది కాంక్రీటు {
ప్రజా int గుణించాలి ( int x, int మరియు ) {
తిరిగి x * మరియు ;
} }
ప్రజా తరగతి కాంక్రీట్ క్లాస్ 2 విస్తరించింది ఉత్పత్తి {
ప్రజా int జోడించు ( int x, int మరియు ) {
తిరిగి x + మరియు ;
}
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ ఆర్గ్స్ [ ] ) {
కాంక్రీట్ క్లాస్ 2 వస్తువు = కొత్త కాంక్రీట్ క్లాస్ 2 ( ) ;
వ్యవస్థ . బయటకు . println ( 'గుణకారం అవుతుంది -> ' + వస్తువు. గుణించాలి ( 2 , 3 ) ) ;
వ్యవస్థ . బయటకు . println ( 'అదనపు అవుతుంది ->' + వస్తువు. జోడించు ( 2 , 3 ) ) ;
} }
ఈ కోడ్ బ్లాక్ ప్రకారం:
- ఇంటర్‌ఫేస్‌ను నిర్వచించండి' కాంక్రీటు ” పేర్కొన్న వియుక్త (అమలు చేయడం లేదు) పద్ధతులను కలిగి ఉంది.
- ఇప్పుడు, ఒక వియుక్త తరగతిని నిర్వచించండి ' ఉత్పత్తి ” నిర్వచించిన ఇంటర్‌ఫేస్‌ని అమలు చేస్తోంది.
- క్లాస్ డెఫినిషన్‌లో, ఇంటర్ఫేస్ పద్ధతుల్లో ఒకదాన్ని నిర్వచించండి అంటే, “ గుణించడం () ” పాస్ చేసిన సంఖ్యల గుణకారాన్ని తిరిగి ఇస్తుంది.
- అలాగే, కాంక్రీట్ తరగతిని ప్రకటించండి ' కాంక్రీట్ క్లాస్ 2 'విస్తరిస్తోంది' నైరూప్య ” తరగతి. ఈ తరగతి ఇంటర్ఫేస్ నుండి ఇతర వియుక్త పద్ధతిని నిర్వచిస్తుంది అంటే, ' జోడించు() ” సంఖ్యల జోడింపును ప్రదర్శిస్తోంది.
- లో ' ప్రధాన ',' యొక్క వస్తువును సృష్టించండి కాంక్రీటు 'ఉపయోగించే తరగతి' కొత్త 'కీవర్డ్ మరియు' కాంక్రీట్ క్లాస్ 2() ”నిర్మాణకర్త.
- చివరగా, నైరూప్య మరియు కాంక్రీట్ తరగతులు రెండింటిలో కూడబెట్టిన తరగతి ఫంక్షన్‌లను సృష్టించడం ద్వారా యాక్సెస్ చేయండి ' కాంక్రీట్ క్లాస్ ” వస్తువు.
అవుట్‌పుట్
ఇక్కడ, రెండు విధులు సముచితంగా అమలు చేయబడతాయని విశ్లేషించవచ్చు.
ముగింపు
జావా' కాంక్రీట్ క్లాస్ ” దాని అన్ని పద్ధతులను అమలు చేసే తరగతికి అనుగుణంగా ఉంటుంది. ఈ తరగతి దాని అన్ని పద్ధతులను నేరుగా, ఇంటర్ఫేస్ ద్వారా లేదా వియుక్త తరగతిని విస్తరించడం ద్వారా వర్తిస్తుంది. ఈ ట్యుటోరియల్ జావా పని గురించి చర్చించింది ' కాంక్రీట్ క్లాస్ ”.