BufferedInputStream

"ஹலோ, அமிகோ! இன்று நான் உங்களுக்கு BufferedInputStream வகுப்பைப் பற்றிய சில சுவாரஸ்யமான விஷயங்களைச் சொல்கிறேன், ஆனால் « ரேப்பர்கள் » மற்றும் « சர்க்கரை பையில் » தொடங்குவோம் ."

"ரேப்பர்" மற்றும் "சர்க்கரை பை" என்பதன் அர்த்தம் என்ன?"

"இவை உருவகங்கள். கேள். அதனால்..."

"ரேப்பர்" (அல்லது "அலங்கரிப்பான்") வடிவமைப்பு முறை என்பது பரம்பரையைப் பயன்படுத்தாமல் பொருளின் செயல்பாட்டை நீட்டிப்பதற்கான மிகவும் எளிமையான மற்றும் வசதியான பொறிமுறையாகும்.

எங்களிடம் இரண்டு முறைகள் கொண்ட கேட் கிளாஸ் உள்ளது என்று வைத்துக்கொள்வோம்: 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());
}

வேறு வார்த்தைகளில் கூறுவதானால், ஒவ்வொரு அசல் பொருளையும் ஒரு ரேப்பர் பொருளுடன் அமைதியாக மாற்றுவோம், இது அசல் பொருளுக்கான இணைப்பைப் பெறுகிறது. ரேப்பரில் உள்ள அனைத்து முறை அழைப்புகளும் அசல் பொருளுக்கு அனுப்பப்படும், மேலும் அனைத்தும் கடிகார வேலைகளைப் போலவே இயங்கும்.

"எனக்கு இது பிடிக்கும். தீர்வு எளிமையானது மற்றும் செயல்பாட்டுடன் உள்ளது."

"சர்க்கரை பை" பற்றி நான் உங்களுக்குச் சொல்கிறேன். இது டிசைன் பேட்டர்னை விட உருவகம். பஃபர் மற்றும் பஃபரிங் என்ற வார்த்தைக்கான உருவகம். பஃபரிங் என்றால் என்ன, அது ஏன் நமக்குத் தேவை?"

இன்னைக்கு ரிஷிக்கு சமையல் செய்யணும்னு சொன்னாங்க, நீங்க அவருக்கு உதவி பண்றீங்க. ரிஷி இன்னும் வரவில்லை, ஆனால் எனக்கு டீ குடிக்க வேண்டும். எனக்கு ஒரு ஸ்பூன் சர்க்கரை கொண்டு வரச் சொல்கிறேன். நீங்கள் அடித்தளத்திற்குச் சென்று சர்க்கரைப் பையைக் கண்டுபிடி. நீங்கள் முழு பையையும் என்னிடம் கொண்டு வரலாம், ஆனால் எனக்கு பை தேவையில்லை. எனக்கு ஒரு ஸ்பூன் மட்டுமே தேவை. பிறகு, ஒரு நல்ல ரோபோ போல, ஒரு ஸ்பூன் எடுத்து என்னிடம் கொண்டு வாருங்கள். நான் அதை தேநீரில் சேர்க்கிறேன், ஆனால் அது இன்னும் போதுமான இனிப்பு இல்லை. மேலும் ஒன்றை என்னிடம் கொண்டு வரும்படி கேட்டுக்கொள்கிறேன். நீங்கள் மீண்டும் அடித்தளத்திற்குச் சென்று மற்றொரு ஸ்பூன் கொண்டு வாருங்கள். பிறகு எல்லி வந்து, அவளுக்கு சர்க்கரை கொண்டு வரச் சொல்கிறேன்... இதெல்லாம் அதிக நேரம் எடுக்கும் மற்றும் திறமையற்றது.

ரிஷி வந்து, இதையெல்லாம் பார்த்துவிட்டு, ஒரு சர்க்கரைக் கிண்ணம் நிறைய சர்க்கரை கொண்டு வரச் சொன்னார். பிறகு எல்லியும் நானும் ரிஷியிடம் சர்க்கரை கேட்க ஆரம்பிக்கிறோம். அவர் சர்க்கரை கிண்ணத்தில் இருந்து எங்களுக்கு பரிமாறுகிறார், அவ்வளவுதான்.

ரிஷி தோன்றிய பிறகு என்ன நடந்தது என்பது பஃபரிங் என்று அழைக்கப்படுகிறது : சர்க்கரை கிண்ணம் ஒரு இடையகமாகும். இடையகத்திற்கு நன்றி, "வாடிக்கையாளர்கள்" ஒரு இடையகத்திலிருந்து தரவை சிறிய பகுதிகளாகப் படிக்க முடியும் , அதே நேரத்தில் இடையகமானது நேரத்தையும் முயற்சியையும் மிச்சப்படுத்துவதற்காக, அவற்றை மூலத்திலிருந்து பெரிய பகுதிகளாகப் படிக்கிறது .

"இது ஒரு அருமையான உதாரணம், கிம். எனக்கு நன்றாகப் புரிகிறது. ஒரு ஸ்பூன் சர்க்கரைக்கான வேண்டுகோள் ஒரு ஸ்ட்ரீமில் இருந்து ஒரு பைட்டைப் படிப்பது போன்றது."

"சரியாக. BufferedInputStream கிளாஸ் என்பது பஃபர் செய்யப்பட்ட ரேப்பருக்கு ஒரு சிறந்த உதாரணம். இது InputStream வகுப்பை மூடுகிறது. இது அசல் இன்புட்ஸ்ட்ரீமில் இருந்து தரவை பெரிய பிளாக்குகளில் உள்ள தரவை ஒரு இடையகமாகப் படிக்கிறது, பின்னர் அதை இடையகத்திலிருந்து துண்டு-துண்டாக இழுக்கிறது. அதிலிருந்து படிக்கவும்."

"வெரி குட். எல்லாம் தெளிவாக இருக்கிறது. எழுதுவதற்கு பஃபர்கள் உள்ளதா?"

"ஓ, நிச்சயமாக."

"ஒரு உதாரணம் இருக்கலாம்?"

"ஒரு குப்பைத் தொட்டியை கற்பனை செய்து பாருங்கள். ஒவ்வொரு முறையும் குப்பைகளை எரியூட்டியில் போடுவதற்குப் பதிலாக, குப்பைத் தொட்டியில் அதை எறிந்தால் போதும். பிறகு பப்பா இரண்டு வாரங்களுக்கு ஒருமுறை கேனை வெளியில் எடுத்துச் செல்கிறார். ஒரு உன்னதமான தாங்கல்."

"எவ்வளவு சுவாரஸ்யமானது! மேலும் ஒரு பை சர்க்கரையை விட மிகவும் தெளிவாக உள்ளது."

"மேலும் ஃப்ளஷ்() முறையானது குப்பையை உடனே வெளியே எடுப்பது போன்றது. விருந்தினர்கள் வருவதற்கு முன்பு நீங்கள் அதைப் பயன்படுத்தலாம்."