குளோன் முறை மற்றும் குளோன் செய்யக்கூடிய இடைமுகம்

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

"வணக்கம், கிம்."

"குளோன்() முறையைப் பற்றி நான் உங்களுக்குச் சொல்லப் போகிறேன்."

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

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

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

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

"ஹ்ம்ம். அதெல்லாம் ஒன்னும் போகல."

"விஷயம் என்னவென்றால், ஜாவா மெய்நிகர் இயந்திரத்திற்கு எந்தப் பொருட்களை குளோன் செய்ய முடியும் அல்லது குளோன் செய்ய முடியாது என்று தெரியாது. உதாரணமாக, கோப்புகளை குளோன் செய்ய முடியாது. System.in ஸ்ட்ரீமிற்கும் இது பொருந்தும்."

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

" குளோனபிள் இடைமுகம் என்பது 'மார்க்கர் இடைமுகம்' என்று அழைக்கப்படுகிறது: இது எந்த முறைகளையும் கொண்டிருக்கவில்லை மற்றும் சில வகுப்புகளைக் குறிக்கப் பயன்படுகிறது.

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

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

"நீங்கள் குளோன் () முறையை அழைக்கும் போது , ​​பொருள் குளோன் செய்யக்கூடிய இடைமுகத்தை ஆதரிக்கிறதா என்பதை ஜாவா சரிபார்க்கிறது. அவ்வாறு செய்தால், அது குளோன் ( ) முறையைப் பயன்படுத்தி பொருளை குளோன் செய்கிறது; இல்லையெனில், அது ஒரு CloneNotSupportedException ஐ வீசுகிறது."

"வேறு வார்த்தைகளில் கூறுவதானால், நாம் குளோன் முறையை மேலெழுத வேண்டுமா அல்லது வகுப்பை குளோன் செய்யக்கூடியதாக மாற்ற வேண்டுமா?"

"ஆம், ஆனால் நீங்கள் இன்னும் முறையை மீற வேண்டும். குளோன்() முறை பாதுகாக்கப்பட்டதாக அறிவிக்கப்பட்டுள்ளது, எனவே அதன் தொகுப்பில் உள்ள வகுப்புகள் (java.lang.*) அல்லது அவற்றின் துணைப்பிரிவுகளால் மட்டுமே இதை அழைக்க முடியும்."

"எனக்குக் கொஞ்சம் குழப்பமாக இருக்கிறது - அதனால் ஒரு பொருளை குளோன் செய்ய நான் என்ன செய்ய வேண்டும்?"

"Object class இன் «default» குளோனிங் முறையை நீங்கள் பயன்படுத்த விரும்பினால், நீங்கள் செய்ய வேண்டியது:

" அ) உங்கள் வகுப்பில் குளோன் செய்யக்கூடிய இடைமுகத்தைச் சேர்க்கவும்"

" ஆ) குளோன் முறையை மேலெழுதவும் மற்றும் உங்கள் செயலாக்கத்திற்குள் சூப்பர் கிளாஸின் செயலாக்கத்தை அழைக்கவும்:"

class Point implements Cloneable
{
 int x;
 int y;

 public Object clone()
 {
  return super.clone();
 }
    }

"அல்லது குளோன் முறையின் செயலாக்கத்தை முழுவதுமாக நீங்களே எழுதலாம்:"

class Point
{
 int x;
 int y;

 public Object clone()
 {
  Point point = new Point();
  point.x = this.x;
  point.y = this.y;
  return point;
 }
}

"இது ஒரு சுவாரஸ்யமான முறை. நான் நிச்சயமாக அதைப் பயன்படுத்துவேன். எப்போதாவது..."