மார்க்கர் இடைமுகங்கள் மற்றும் ஆழமான பிரதிகள்

"வணக்கம், அமிகோ!"

"வணக்கம், பிலாபோ!"

"இன்று நான் உங்களுக்கு மார்க்கர் இடைமுகங்களைப் பற்றி கூறுவேன் ."

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

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

" சீரியலைசபிள் இடைமுகம் வரிசைப்படுத்தலை ஆதரிக்கும் வகுப்புகளைக் குறிக்கப் பயன்படுகிறது, இந்த வகுப்புகளின் நிகழ்வுகள் தானாக வரிசைப்படுத்தப்பட்டு சீரழிக்கப்படலாம் என்பதைக் குறிக்கிறது."

" ரிமோட் இன்டர்ஃபேஸ் என்பது ரிமோட் எக்ஸிகியூஷனை ஆதரிக்கும் பொருட்களை அடையாளம் காணப் பயன்படுகிறது, அதாவது மற்றொரு ஜாவா மெய்நிகர் இயந்திரம் மற்றும்/அல்லது வேறு கணினியிலிருந்து செயல்படுத்தப்படும் முறைகள்."

" குளோனிங்கை ஆதரிக்கும் வகுப்புகளைக் குறிக்க குளோன் செய்யக்கூடிய இடைமுகம் பயன்படுத்தப்படுகிறது."

"ஓ, குளோனிங் அல்லது நகலெடுப்பது பற்றி."

"நகலெடுப்பதில் இரண்டு வகைகள் உள்ளன: ஆழமற்ற மற்றும் ஆழமான."

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

" ஆழமான நகலெடுப்பு என்பது ஒரு பொருளை நகலெடுப்பதை உள்ளடக்கியது, அது குறிப்பிடும் பொருள்கள் மற்றும் அந்த பொருள்கள் குறிப்பிடும் பொருள்கள் போன்றவை."

"நம்பகமாக ஒரு ஆழமான குளோனை உருவாக்க ஒரு நல்ல வழி உள்ளது."

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

"நீங்கள் அதை எப்படி செய்கிறீர்கள் என்பது இங்கே:"

1) நினைவகத்தில் ஒரு இடையகத்தை (பைட் வரிசை) உருவாக்கவும்.

2) பொருள் மற்றும் துணைப் பொருள்களை இடையகத்தில் வரிசைப்படுத்தவும்.

3) இடையகத்தில் சேமிக்கப்பட்ட பொருள் படிநிலையை சீரியலைஸ் செய்யவும்.

BigObject objectOriginal = new BigObject();

ByteArrayOutputStream writeBuffer = new ByteArrayOutputStream();
ObjectOutputStream outputStream = new ObjectOutputStream(writeBuffer);
outputStream.writeObject(objectOriginal);
outputStream.close();

byte[] buffer = writeBuffer.toByteArray();
ByteArrayInputStream readBuffer = new ByteArrayInputStream(buffer);
ObjectInputStream inputStream = new ObjectInputStream(readBuffer);
BigObject objectCopy = (BigObject)inputStream.readObject();

"முதல் வரியில், objectOriginal ஐ உருவாக்குகிறோம் , அதை குளோன் செய்வோம். பொருள் மற்றும் அதன் அனைத்து துணைப் பொருள்களும் வரிசையாக்கத்தை ஆதரிக்க வேண்டும்."

"மூன்றாவது வரியில், நாம் ஒரு ByteArrayOutputStream ஐ உருவாக்குகிறோம் , இது புதிய தரவு சேர்க்கப்படும்போது மாறும் வகையில் விரிவடையும் (அரேலிஸ்ட் போன்றது)."

"வரிசை 4 இல், நாம் ஒரு ObjectOutputStream ஐ உருவாக்குகிறோம் , இது வரிசைப்படுத்தலுக்குப் பயன்படுத்தப்படுகிறது."

"வரிசை 5 இல், outputStream ஐப் பயன்படுத்தி objectOriginal ஐ ஒரு பைட் வரிசையாக வரிசைப்படுத்தி அதை ரைட்பஃபரில் சேமிக்கிறோம் ."

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

"வரி 9 இல், ஒரு இன்புட்ஸ்ட்ரீம் போல படிக்கும் பொருட்டு, இடையகத்தை பைட்அரேஇன்புட்ஸ்ட்ரீமாக மாற்றுகிறோம் ."

"வரி 10 இல், பொருளைப் படிக்க (டீரியலைஸ் செய்ய) ObjectInputStream கன்ஸ்ட்ரக்டருக்கு readBuffer ஐ அனுப்புகிறோம் ."

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

"நீங்கள் என்ன நினைக்கறீர்கள்?"

"இது அழகாக இருக்கிறது."

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