బఫర్డ్‌ఇన్‌పుట్ స్ట్రీమ్

"హలో, అమిగో! ఈ రోజు నేను మీకు బఫర్డ్‌ఇన్‌పుట్‌స్ట్రీమ్ క్లాస్ గురించి కొన్ని ఆసక్తికరమైన విషయాలను చెబుతాను, అయితే « రేపర్లు » మరియు « చక్కెర బ్యాగ్ » తో ప్రారంభిద్దాం ."

"రేపర్" మరియు "బ్యాగ్ ఆఫ్ షుగర్" అంటే ఏమిటి?"

"ఇవి రూపకాలు. వినండి. కాబట్టి..."

"రేపర్" (లేదా "డెకరేటర్") డిజైన్ నమూనా అనేది వారసత్వాన్ని ఉపయోగించకుండా ఆబ్జెక్ట్ కార్యాచరణను విస్తరించడానికి చాలా సులభమైన మరియు అనుకూలమైన విధానం.

మనకు రెండు పద్ధతులతో క్యాట్ క్లాస్ ఉందని అనుకుందాం: getName మరియు setName:

class Cat
{
 private String name;
 public Cat(String name)
 {
  this.name = name;
 }
 public String getName()
 {
  return this.name;
 }
 public void setName(String name)
 {
  this.name = name;
 }
}

public static void main(String[] args)
{
 Cat cat = new Cat("Oscar");

 printName(cat);
}

public static void printName(Cat cat)
{
 System.out.println(cat.getName());
}

మనం పిల్లి వస్తువుపై పద్దతి కాల్‌ని అడ్డగించి , బహుశా కొన్ని చిన్న మార్పులు చేయవలసి ఉందని అనుకుందాం. దీని కోసం, మేము దానిని దాని స్వంత రేపర్ క్లాస్‌లో చుట్టాలి .

మనం ఏదైనా వస్తువుకు కాల్ చేసే పద్ధతి చుట్టూ మన స్వంత కోడ్‌ను "రాప్" చేయాలనుకుంటే , మనం వీటిని చేయాలి:

1) మా స్వంత రేపర్ క్లాస్‌ని సృష్టించండి మరియు చుట్టబడిన వస్తువు వలె అదే తరగతి/ఇంటర్‌ఫేస్ నుండి వారసత్వంగా పొందండి.

2) చుట్టాల్సిన వస్తువును మా తరగతి కన్స్ట్రక్టర్‌కి పంపండి.

3) మా కొత్త తరగతిలోని అన్ని పద్ధతులను భర్తీ చేయండి. ప్రతి ఓవర్‌రైడ్ పద్ధతుల లోపల చుట్టబడిన వస్తువు యొక్క పద్ధతులను ప్రారంభించండి.

4) మీకు కావలసిన మార్పులు చేయండి: కాల్‌లు చేసే పద్ధతిని మార్చండి, వాటి పారామితులను మార్చండి మరియు/లేదా మరేదైనా చేయండి.

దిగువ ఉదాహరణలో, మేము Cat వస్తువు యొక్క getName పద్ధతికి కాల్‌లను అడ్డగిస్తాము మరియు దాని రిటర్న్ విలువను కొద్దిగా మారుస్తాము.

class Cat
{
 private String name;
 public Cat(String name)
 {
  this.name = name;
 }
 public String getName()
 {
  return this.name;
 }
 public void setName(String name)
 {
  this.name = name;
 }
}

class CatWrapper extends Cat
{
 private Cat original;
 public CatWrapper (Cat cat)
 {
  super(cat.getName());
  this.original = cat;
 }

 public String getName()
 {
  return "A cat named " + original.getName();
 }

 public void setName(String name)
 {
  original.setName(name);
 }
}

public static void main(String[] args)
{
 Cat cat = new Cat("Oscar");
 Cat catWrap = new CatWrapper (cat);
 printName(catWrap);
}

public static void printName(Cat named)
{
 System.out.println(named.getName());
}

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

"నాకు ఇది ఇష్టం. పరిష్కారం సరళమైనది మరియు క్రియాత్మకమైనది."

"నేను మీకు «పంచదార బ్యాగ్» గురించి కూడా చెబుతాను. ఇది డిజైన్ నమూనా కంటే రూపకం. బఫర్ మరియు బఫరింగ్ అనే పదానికి రూపకం. బఫరింగ్ అంటే ఏమిటి మరియు మనకు ఎందుకు అవసరం?"

ఈ రోజు వంట చేయడం రిషి వంతు వచ్చిందని, మీరు అతనికి సహాయం చేస్తున్నారని చెప్పండి. రిషి ఇంకా రాలేదు, కానీ నాకు టీ తాగాలని ఉంది. నాకు ఒక చెంచా చక్కెర తీసుకురావాలని నేను మిమ్మల్ని అడుగుతున్నాను. మీరు నేలమాళిగకు వెళ్లి చక్కెర సంచిని కనుగొనండి. మీరు నాకు మొత్తం బ్యాగ్ తీసుకురావచ్చు, కానీ నాకు బ్యాగ్ అవసరం లేదు. నాకు ఒక్క చెంచా చాలు. అప్పుడు, ఒక మంచి రోబోట్ లాగా, మీరు ఒక చెంచా తీసుకొని నా దగ్గరకు తీసుకురండి. నేను దానిని టీలో కలుపుతాను, కానీ అది ఇప్పటికీ తగినంత తీపిగా లేదు. మరియు నాకు మరొకటి తీసుకురావాలని నేను మిమ్మల్ని అడుగుతున్నాను. మీరు మళ్ళీ నేలమాళిగకు వెళ్లి మరొక చెంచా తీసుకురండి. అప్పుడు ఎల్లీ వస్తాడు, మరియు ఆమె కోసం చక్కెర తీసుకురావాలని నేను మిమ్మల్ని అడుగుతున్నాను... ఇదంతా చాలా సమయం పడుతుంది మరియు అసమర్థమైనది.

రిషి వచ్చి, ఇదంతా చూసి, అతనికి పంచదార గిన్నె నిండా పంచదార తీసుకురా అని అడిగాడు. అప్పుడు ఎల్లీ మరియు నేను రిషిని షుగర్ అడగడం ప్రారంభిస్తాము. అతను చక్కెర గిన్నె నుండి మాకు వడ్డిస్తాడు మరియు అంతే.

రిషి కనిపించిన తర్వాత ఏమి జరిగిందో బఫరింగ్ అంటారు : చక్కెర గిన్నె బఫర్. బఫరింగ్‌కు ధన్యవాదాలు, "క్లయింట్‌లు" బఫర్ నుండి డేటాను చిన్న భాగాలలో చదవగలరు , అయితే బఫర్, సమయం మరియు శ్రమను ఆదా చేయడానికి, వాటిని మూలం నుండి పెద్ద భాగాలలో చదువుతుంది .

"ఇది ఒక చక్కని ఉదాహరణ, కిమ్. నేను సరిగ్గా అర్థం చేసుకున్నాను. ఒక చెంచా చక్కెర కోసం అభ్యర్థన ఒక స్ట్రీమ్ నుండి ఒక బైట్ చదివినట్లుగా ఉంది."

"సరిగ్గా. బఫర్డ్‌ఇన్‌పుట్‌స్ట్రీమ్ క్లాస్ అనేది బఫర్డ్ రేపర్‌కి ఒక క్లాసికల్ ఉదాహరణ. ఇది ఇన్‌పుట్‌స్ట్రీమ్ క్లాస్‌ను వ్రాప్ చేస్తుంది. ఇది అసలు ఇన్‌పుట్‌స్ట్రీమ్ నుండి డేటాను పెద్ద బ్లాక్‌లలో బఫర్‌లోకి రీడ్ చేసి, ఆపై దాన్ని బఫర్ నుండి పీస్‌బై పీస్‌గా లాగుతుంది. దాని నుండి చదవండి."

"చాలా బాగుంది. అంతా క్లియర్‌గా ఉంది. రాయడానికి బఫర్‌లు ఉన్నాయా?"

"అలాగే తప్పకుండా."

"బహుశా ఒక ఉదాహరణ?"

"ఒక చెత్త డబ్బాను ఊహించుకోండి. ప్రతిసారీ చెత్తను దహనం చేయడానికి బయటికి వెళ్లే బదులు, మీరు దానిని చెత్త డబ్బాలో వేస్తారు. తర్వాత బుబ్బా ప్రతి రెండు వారాలకు ఒకసారి డబ్బాను బయటికి తీసుకువెళతారు. ఒక క్లాసిక్ బఫర్."

"ఎంత ఆసక్తికరంగా ఉంది! మరియు చక్కెర బ్యాగ్ కంటే చాలా స్పష్టంగా ఉంది."

"మరియు ఫ్లష్() పద్ధతి వెంటనే చెత్తను తీయడం లాంటిది. అతిథులు రాకముందే మీరు దానిని ఉపయోగించవచ్చు."