அடாப்டர் வடிவமைப்பு முறை

வணக்கம்! இன்று நாம் ஒரு முக்கியமான புதிய தலைப்பைத் தொடுவோம்: வடிவமைப்பு வடிவங்கள் . இந்த வடிவங்கள் என்ன? " சக்கரத்தை மீண்டும் கண்டுபிடிக்காதே " என்ற வெளிப்பாடு உங்களுக்குத் தெரிந்திருக்க வேண்டும் என்று நினைக்கிறேன் . நிரலாக்கத்தில், பல பகுதிகளைப் போலவே, ஏராளமான பொதுவான சூழ்நிலைகள் உள்ளன. மென்பொருள் மேம்பாடு உருவாகியுள்ளதால், அவை ஒவ்வொன்றிற்கும் வேலை செய்யும் ஆயத்த தீர்வுகள் உருவாக்கப்பட்டுள்ளன. இந்த தீர்வுகள் வடிவமைப்பு வடிவங்கள் என்று அழைக்கப்படுகின்றன. மரபுப்படி, ஒரு மாதிரியானது இது போன்ற சில தீர்வுகளை உருவாக்குகிறது: "உங்கள் திட்டத்தில் நீங்கள் X செய்ய வேண்டும் என்றால், அதைச் செய்வதற்கான சிறந்த வழி இதுதான்". நிறைய வடிவங்கள் உள்ளன. நீங்கள் நிச்சயமாக அறிந்திருக்க வேண்டிய "ஹெட் ஃபர்ஸ்ட் டிசைன் பேட்டர்ன்ஸ்" என்ற சிறந்த புத்தகம் அவர்களுக்காக அர்ப்பணிக்கப்பட்டுள்ளது. சுருக்கமாகச் சொன்னால், ஒரு மாதிரியானது ஒரு பொதுவான சிக்கலையும் அதனுடன் தொடர்புடைய தீர்வையும் கொண்டுள்ளது, இது ஒரு வகையான தரநிலையாகக் கருதப்படுகிறது. இன்றைய பாடத்தில், இந்த வடிவங்களில் ஒன்றை நாம் சந்திப்போம்: அடாப்டர். அதன் பெயர் அனைத்தையும் கூறுகிறது, மேலும் நிஜ வாழ்க்கையில் நீங்கள் பல முறை அடாப்டர்களை சந்தித்திருக்கிறீர்கள். மிகவும் பொதுவான சில அடாப்டர்கள் பல கணினிகள் மற்றும் மடிக்கணினிகள் கொண்டிருக்கும் கார்டு ரீடர்கள் ஆகும். எங்களிடம் ஒருவித மெமரி கார்டு இருப்பதாக வைத்துக்கொள்வோம். அதனால் என்ன பிரச்சனை? கணினியுடன் தொடர்பு கொள்ளத் தெரியாது. அவர்கள் பொதுவான இடைமுகத்தைப் பகிர்ந்து கொள்ளவில்லை. கணினியில் USB போர்ட் உள்ளது, ஆனால் அதில் மெமரி கார்டைச் செருக முடியாது. கார்டை கம்ப்யூட்டரில் செருக முடியாது, அதனால் எங்களின் புகைப்படங்கள், வீடியோக்கள் மற்றும் பிற தரவைச் சேமிக்க முடியாது. கார்டு ரீடர் என்பது இந்த சிக்கலை தீர்க்கும் ஒரு அடாப்டர் ஆகும். எல்லாவற்றிற்கும் மேலாக, இது ஒரு USB கேபிள் உள்ளது! கார்டு போலல்லாமல், கார்டு ரீடரை கணினியில் செருகலாம். அவர்கள் கணினியுடன் பொதுவான இடைமுகத்தைப் பகிர்ந்து கொள்கிறார்கள்: USB. இது நடைமுறையில் எப்படி இருக்கிறது என்று பார்ப்போம்:

public interface USB { 

   void connectWithUsbCable(); 
}

யூ.எஸ்.பி வழியாக இணைப்பதற்கான ஒரே ஒரு முறை கொண்ட எங்களின் யூ.எஸ்.பி இடைமுகம் இது.

public class MemoryCard { 

   public void insert() { 
       System.out.println("Memory card successfully inserted!"); 
   } 

   public void copyData() { 
       System.out.println("The data has been copied to the computer!"); 
   } 
}

இது மெமரி கார்டைக் குறிக்கும் எங்கள் வகுப்பு. இது ஏற்கனவே நமக்குத் தேவையான 2 முறைகளைக் கொண்டுள்ளது, ஆனால் இங்கே சிக்கல் உள்ளது: இது USB இடைமுகத்தை செயல்படுத்தவில்லை. கார்டை USB போர்ட்டில் செருக முடியாது.

public class CardReader implements USB { 

   private MemoryCard memoryCard; 

   public CardReader(MemoryCard memoryCard) { 
       this.memoryCard = memoryCard; 
   } 

   @Override 
   public void connectWithUsbCable() { 
       this.memoryCard.insert(); 
       this.memoryCard.copyData(); 
   } 
}

இதோ எங்கள் அடாப்டர்! என்ன செய்கிறதுCardReaderகிளாஸ் டூ மற்றும் அதை சரியாக அடாப்டராக மாற்றுவது எது? இது எல்லாம் எளிது. மாற்றியமைக்கப்படும் வகுப்பு (MemoryCard) அடாப்டரின் புலங்களில் ஒன்றாக மாறும். இது அர்த்தமுள்ளதாக இருக்கிறது. நிஜ வாழ்க்கையில் கார்டு ரீடருக்குள் மெமரி கார்டை வைக்கும்போது, ​​அதுவும் அதன் ஒரு பகுதியாக மாறும். மெமரி கார்டு போலல்லாமல், அடாப்டர் கணினியுடன் ஒரு இடைமுகத்தைப் பகிர்ந்து கொள்கிறது. இதில் USB கேபிள் உள்ளது, அதாவது USB வழியாக மற்ற சாதனங்களுடன் இணைக்க முடியும். அதனால்தான் எங்கள் CardReader வகுப்பு USB இடைமுகத்தை செயல்படுத்துகிறது. ஆனால் இந்த முறையின் உள்ளே சரியாக என்ன நடக்கிறது? நாம் என்ன நடக்க வேண்டும்! அடாப்டர் நமது மெமரி கார்டுக்கு வேலையை ஒப்படைக்கிறது. உண்மையில், அடாப்டர் தானாகவே எதையும் செய்யாது. கார்டு ரீடருக்கு சுயாதீனமான செயல்பாடு எதுவும் இல்லை. அதன் வேலை கணினி மற்றும் மெமரி கார்டை இணைப்பது மட்டுமே, கார்டு அதன் வேலையைச் செய்ய அனுமதிக்கிறது - கோப்புகளை நகலெடுப்பது!connectWithUsbCable()முறை) மெமரி கார்டின் "தேவைகளை" பூர்த்தி செய்ய. மெமரி கார்டில் இருந்து தரவை நகலெடுக்க விரும்பும் நபரை உருவகப்படுத்தும் சில கிளையன்ட் நிரலை உருவாக்குவோம்:

public class Main { 

   public static void main(String[] args) { 

       USB cardReader = new CardReader(new MemoryCard()); 
       cardReader.connectWithUsbCable(); 
   } 
}

அதனால் என்ன கிடைத்தது? கன்சோல் வெளியீடு:

Memory card successfully inserted! 
The data has been copied to the computer!

சிறப்பானது. நாங்கள் எங்கள் இலக்கை அடைந்தோம்! அடாப்டர் பேட்டர்ன் பற்றிய தகவலுடன் வீடியோவிற்கான இணைப்பு இதோ:

• அடாப்டர் பேட்டர்ன் - டிசைன் பேட்டர்ன்கள்

வாசகர் மற்றும் எழுத்தாளர் சுருக்க வகுப்புகள்

இப்போது நாம் நமக்குப் பிடித்த செயல்பாட்டிற்குத் திரும்புவோம்: உள்ளீடு மற்றும் வெளியீட்டில் வேலை செய்வதற்கான இரண்டு புதிய வகுப்புகளைப் பற்றி அறிந்துகொள்வது :) நாம் ஏற்கனவே எத்தனை விஷயங்களைக் கற்றுக்கொண்டோம் என்று எனக்கு ஆச்சரியமாக இருக்கிறது. Reader இன்று நாம் மற்றும் வகுப்புகள் பற்றி பேசுவோம் Writer. ஏன் குறிப்பாக அந்த வகுப்புகள்? ஏனெனில் அவை அடாப்டர்கள் பற்றிய நமது முந்தைய பகுதியுடன் தொடர்புடையவை. அவற்றை இன்னும் விரிவாக ஆராய்வோம். நாம் தொடங்குவோம்  Reader. Readerஒரு சுருக்க வகுப்பாகும், எனவே எங்களால் பொருட்களை வெளிப்படையாக உருவாக்க முடியாது.   ஆனால் நீங்கள் ஏற்கனவே அதை நன்கு அறிந்திருக்கிறீர்கள்! எல்லாவற்றிற்கும் மேலாக, அதன் வழித்தோன்றல்கள் BufferedReaderமற்றும் வகுப்புகளுடன் நீங்கள் நன்கு அறிந்திருக்கிறீர்கள் :)InputStreamReader

public class BufferedReader extends Reader { 
… 
} 

public class InputStreamReader extends Reader { 
… 
}

வகுப்பு InputStreamReaderஒரு உன்னதமான அடாப்டர். InputStreamஒருவேளை நீங்கள் நினைவில் வைத்திருப்பது போல், ஒரு பொருளை அதன் கட்டமைப்பாளருக்கு அனுப்பலாம் . இதைச் செய்ய, நாங்கள் வழக்கமாக System.inமாறியைப் பயன்படுத்துகிறோம்:

public static void main(String[] args) { 

   InputStreamReader inputStreamReader = new InputStreamReader(System.in); 
}

ஆனால் என்ன InputStreamReaderசெய்வது? ஒவ்வொரு அடாப்டரைப் போலவே, இது ஒரு இடைமுகத்தை மற்றொன்றுக்கு மாற்றுகிறது.  இந்த வழக்கில், InputStreamஇடைமுகத்திற்கான இடைமுகம் Reader. ஆரம்பத்தில், எங்களிடம் InputStreamவகுப்பு உள்ளது. இது நன்றாக வேலை செய்கிறது, ஆனால் நீங்கள் தனிப்பட்ட பைட்டுகளைப் படிக்க மட்டுமே இதைப் பயன்படுத்த முடியும். கூடுதலாக, எங்களிடம் ஒரு Readerசுருக்க வகுப்பு உள்ளது. இது சில மிகவும் பயனுள்ள செயல்பாடுகளைக் கொண்டுள்ளது - இது எழுத்துக்களை எவ்வாறு படிப்பது என்று தெரியும்! இந்த திறன் நமக்கு நிச்சயமாக தேவை. ஆனால் இங்கே நாம் பொதுவாக அடாப்டர்களால் தீர்க்கப்படும் உன்னதமான சிக்கலை எதிர்கொள்கிறோம் - பொருந்தாத இடைமுகங்கள். அதற்கு என்ன பொருள்? ஆரக்கிள் ஆவணத்தைப் பார்ப்போம். வகுப்பின் முறைகள் இங்கே InputStream. முறைகளின் தொகுப்பு துல்லியமாக ஒரு இடைமுகம். நீங்கள் பார்க்க முடியும் என, இந்த வகுப்பில் ஒரு உள்ளதுread()முறை (ஒரு சில மாறுபாடுகள், உண்மையில்), ஆனால் இது பைட்டுகளை மட்டுமே படிக்க முடியும்: தனிப்பட்ட பைட்டுகள் அல்லது ஒரு இடையகத்தைப் பயன்படுத்தி பல பைட்டுகள். ஆனால் இந்த விருப்பம் எங்களுக்கு பொருந்தாது - நாங்கள் எழுத்துக்களைப் படிக்க விரும்புகிறோம். சுருக்க வகுப்பில் ஏற்கனவே செயல்படுத்தப்பட்டReader செயல்பாடு நமக்குத் தேவை . இதை ஆவணங்களிலும் பார்க்கலாம். இருப்பினும், InputStreamமற்றும்  Readerஇடைமுகங்கள் இணக்கமற்றவை! நீங்கள் பார்க்க முடியும் என, முறையின் ஒவ்வொரு செயலாக்கமும் read()வெவ்வேறு அளவுருக்கள் மற்றும் வருவாய் மதிப்புகளைக் கொண்டுள்ளது. இங்குதான் நமக்குத் தேவை InputStreamReader! இது எங்கள் வகுப்புகளுக்கு இடையே ஒரு அடாப்டராக செயல்படும் . நாம் மேலே கருதிய கார்டு ரீடரில் உள்ள எடுத்துக்காட்டில், அடாப்டர் வகுப்பிற்கு "உள்ளே" வகுப்பை மாற்றியமைப்பதற்கான ஒரு உதாரணத்தை வைக்கிறோம், அதாவது ஒன்றை அதன் கட்டமைப்பாளருக்கு அனுப்புகிறோம். முந்தைய எடுத்துக்காட்டில், ஒரு MemoryCardபொருளை உள்ளே வைக்கிறோம் CardReader. InputStream இப்போது நாம் ஒரு பொருளை கட்டமைப்பாளருக்கு அனுப்புகிறோம் InputStreamReader! System.inநமக்குத் தெரிந்த மாறியைப் பின்வருமாறு பயன்படுத்துகிறோம் InputStream:

public static void main(String[] args) { 

   InputStreamReader inputStreamReader = new InputStreamReader(System.in); 
}

உண்மையில், க்கான ஆவணங்களைப் பார்க்கும்போது InputStreamReader, ​​​​தழுவல் வெற்றி பெற்றதைக் காணலாம் :) இப்போது நம் வசம் உள்ள எழுத்துக்களைப் படிக்கும் முறைகள் உள்ளன. எங்கள் பொருள் (விசைப்பலகையுடன் இணைக்கப்பட்ட ஸ்ட்ரீம்) ஆரம்பத்தில் இதை அனுமதிக்கவில்லை என்றாலும் System.in, மொழியின் படைப்பாளிகள் அடாப்டர் வடிவத்தை செயல்படுத்துவதன் மூலம் இந்த சிக்கலைத் தீர்த்தனர். Readerபெரும்பாலான I/O வகுப்புகளைப் போலவே, சுருக்க வகுப்பிற்கும் ஒரு இரட்டை சகோதரர் இருக்கிறார்  - Writer. இது அதே பெரிய நன்மையைக் கொண்டுள்ளது  Reader - இது எழுத்துக்களுடன் பணிபுரிய வசதியான இடைமுகத்தை வழங்குகிறது. வெளியீட்டு ஸ்ட்ரீம்களில், சிக்கல் மற்றும் அதன் தீர்வு உள்ளீடு ஸ்ட்ரீம்களைப் போலவே இருக்கும். OutputStreamபைட்டுகளை மட்டுமே எழுதக்கூடிய ஒரு வகுப்பு உள்ளது , ஒரு உள்ளதுWriterஎழுத்துகளுடன் எவ்வாறு வேலை செய்வது என்பதை அறியும் சுருக்க வர்க்கம் மற்றும் இரண்டு பொருந்தாத இடைமுகங்கள் உள்ளன. இந்த சிக்கல் மீண்டும் அடாப்டர் வடிவத்தால் தீர்க்கப்படுகிறது.  மற்றும்   வகுப்புகளின் இரண்டு இடைமுகங்களையும் ஒருவருக்கொருவர் OutputStreamWriterஎளிதாக மாற்றியமைக்க வகுப்பைப் பயன்படுத்துகிறோம் . ஒரு பைட் ஸ்ட்ரீமை கன்ஸ்ட்ரக்டருக்கு அனுப்பிய பிறகு , பைட்டுகளுக்குப் பதிலாக எழுத்துகளை எழுத ஒரு பயன்படுத்தலாம்! WriterOutputStreamOutputStreamOutputStreamWriter

import java.io.*; 

public class Main { 

   public static void main(String[] args) throws IOException { 

       OutputStreamWriter streamWriter = new OutputStreamWriter(new FileOutputStream("C:\\Users\\Username\\Desktop\\test.txt")); 
       streamWriter.write(32144); 
       streamWriter.close();
   } 
}

32144 (綐) குறியீட்டைக் கொண்ட எழுத்தை எங்கள் கோப்பில் எழுதினோம், பைட்டுகளுடன் வேலை செய்ய வேண்டிய அவசியத்தை நீக்கிவிட்டோம் :) இன்றைக்கு அவ்வளவுதான். அடுத்த பாடங்களில் சந்திப்போம்! :)