రీడర్/రైటర్

"హలో, అమిగో! ఈ రోజు, ఎల్లీ మీకు అడాప్టర్ ప్యాటర్న్ గురించి చెప్పారు."

I/O స్ట్రీమ్‌లకు సంబంధించిన చాలా తరగతులు అడాప్టర్‌లుగా అమలు చేయబడతాయి. అవి సమానమైన ఇంటర్‌ఫేస్‌లను మారుస్తాయి లేదా అవి వాటిని కనెక్ట్ చేస్తాయి, సాధారణ నుండి ప్రారంభించి కాంప్లెక్స్‌కు వెళతాయి.

" InputStreamReader మరియు BufferedReader కూడా అడాప్టర్లేనా? కనీసం, అవి ఉపయోగించిన విధానంలో అడాప్టర్‌లకు చాలా పోలి ఉంటాయి: ఒక వస్తువు సృష్టించబడిన తర్వాత, అది మరొక తరగతి యొక్క కన్స్ట్రక్టర్‌కు పంపబడుతుంది."

"అవును, InputStreamReader ఇన్‌పుట్‌స్ట్రీమ్ ఇంటర్‌ఫేస్‌ను రీడర్ ఇంటర్‌ఫేస్‌గా మారుస్తుంది . బఫర్డ్ రీడర్ దాని స్వచ్ఛమైన రూపంలో అడాప్టర్ కాదు, ఎందుకంటే జావా సృష్టికర్తలు దాని పద్ధతులకు వారి స్వంత ప్రత్యేక ఇంటర్‌ఫేస్‌ను ఇవ్వకూడదని నిర్ణయించుకున్నారు. కానీ ఇది ఆత్మీయమైనది."

బజిలియన్ విభిన్న తరగతులను వ్రాయడానికి బదులుగా, జావా యొక్క సృష్టికర్తలు రెండు డజన్ల అడాప్టర్‌లను వ్రాసారు మరియు ప్రోగ్రామర్ కోరుకున్నప్పటికీ వాటిని ఒకదానికొకటి కనెక్ట్ చేయడానికి అనుమతించారు.

ఈ విధానం చాలా సౌకర్యవంతంగా ఉంటుంది. ప్రోగ్రామర్ ఎల్లప్పుడూ తన క్లాస్ మరియు/లేదా అడాప్టర్‌ని వ్రాయవచ్చు, అది ఒక ప్రామాణిక ఇంటర్‌ఫేస్‌ను అమలు చేయగలదు మరియు ఆమె నిర్మిస్తున్న అడాప్టర్ వస్తువుల గొలుసులో దానిని చేర్చవచ్చు.

"కాబట్టి ఇదంతా ఎలా పని చేస్తుంది. పెద్ద సంక్లిష్ట తరగతులకు బదులుగా, మేము సాధారణ వస్తువులు మరియు అడాప్టర్ల గొలుసులను తయారు చేస్తాము. ఆపై మీరు వాటిని సృష్టించి, వాటిని సరైన క్రమంలో కలపండి!"

"మరియు మీరు తప్పిపోయిన వాటిని అమలు చేయండి."

"అవును, నాకు అర్థమైంది."

"అయితే నిజానికి నేను ఈరోజు రీడర్ మరియు రైటర్ గురించి చెప్పాలనుకున్నాను . ఇవి ఇన్‌పుట్‌స్ట్రీమ్ మరియు అవుట్‌పుట్ స్ట్రీమ్ తరగతులకు చాలా పోలి ఉండే రెండు అబ్‌స్ట్రాక్ట్ తరగతులు. కానీ ఆ తరగతులలా కాకుండా, ఈ రెండు తరగతులు అక్షరాలతో పనిచేస్తాయి. అవి అక్షరాలు చదవడం మరియు వ్రాయడం. అవి వచన సమాచారంతో పని చేస్తున్నప్పుడు చాలా సౌకర్యవంతంగా ఉంటుంది. వారు కలిగి ఉన్న పద్ధతులను పరిశీలిద్దాం:"

int read(char[] cbuf);

int read();

boolean ready();

void close();

"రీడర్ యొక్క రీడ్(చార్ [] cbuf) పద్ధతి ఒక్కోసారి ఒక అక్షరం కాకుండా మొత్తం అక్షరాల బ్లాక్‌లను చదవడానికి అనుమతిస్తుంది. కనుక ఇది వేగంగా మరియు మరింత సౌకర్యవంతంగా ఉంటుంది."

"సరిగ్గా. మరియు ఇప్పుడు రైటర్‌కు ఎలాంటి పద్ధతులు ఉన్నాయో చూద్దాం:"

void write(int c);

void write(char[] cbuff);

void write(String s);

void flush();

void close();

రీడర్ మరియు రైటర్ నైరూప్య తరగతులు అని అర్థం చేసుకోవడం ముఖ్యం . వారు ఏమీ చేయరు మరియు వాస్తవంగా కోడ్‌ను కలిగి ఉండరు. వారి పద్ధతులన్నీ వారసత్వంగా వచ్చే తరగతులలో అమలు చేయవలసి ఉంటుంది. తరగతులు ఎలా పరస్పరం వ్యవహరిస్తాయో ప్రమాణీకరించడం వారి పని . డెవలపర్‌లు ఒకరితో ఒకరు పరస్పరం సంభాషించడానికి వారి స్వంత ప్రమాణాలను కనిపెట్టాల్సిన అవసరం లేదు. ప్రతి ఒక్కరూ కొన్ని ప్రాథమిక ప్రమాణాలను నిర్వహించడం చాలా సౌకర్యవంతంగా ఉంటుంది. ఇది వివిధ ప్రోగ్రామర్లు వ్రాసిన తరగతులను జావా సృష్టికర్తలు వ్రాసిన తరగతులతో మాత్రమే కాకుండా ఇతర ప్రోగ్రామర్లు వ్రాసిన తరగతులతో కూడా సులభంగా సంభాషించడానికి అనుమతిస్తుంది.

ప్రమాణాలు శక్తివంతమైనవి.

"నేను అంగీకరిస్తున్నాను. సాధారణ ప్రమాణాలకు మద్దతు ఇవ్వడం అందరికీ ప్రయోజనకరం."