உள்ளடக்கம்

• ஒப்பீட்டு விளக்கப்படம்
• நூல் வகுப்பின் வரையறை
• இயங்கக்கூடிய இடைமுகத்தின் வரையறை
• ஜாவாவில் நூல் மற்றும் இயக்கக்கூடிய முக்கிய வேறுபாடுகள்
• முடிவுரை:

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

கீழே காட்டப்பட்டுள்ள ஒப்பீட்டு விளக்கப்படத்தின் உதவியுடன் நூல் மற்றும் இயங்கக்கூடியவற்றுக்கு இடையிலான வேறு சில வேறுபாடுகளைக் கவனிப்போம்:

1. ஒப்பீட்டு விளக்கப்படம்
2. வரையறை
3. முக்கிய வேறுபாடுகள்
4. முடிவுரை

ஒப்பீட்டு விளக்கப்படம்

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

நூல் வகுப்பின் வரையறை

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

/ * ஒரு நூலை வரையறுத்தல் * / வகுப்பு புராணக்கதை நூல் {/ * நூலின் வேலை * / பொது வெற்றிட ரன் () {(int i = 0; i <10; i ++) {System.Out.ln ("குழந்தை நூல்" ); Main} வகுப்பு மெயின் த்ரெட் main / * பிரதான நூலின் வேலை * / பொது நிலையான வெற்றிட மெயின் (சரம் ஆர்க்ஸ்) {மைத்ரெட் எம்.டி = புதிய மித்ரெட் (); / * பிரதான நூல் குழந்தை நூலை உருவாக்கியது * / mt.start (); for (int i = 0; i <10; i ++) {System.Out. ("முதன்மை நூல்"); Th}} / * வெளியீடு * / பிரதான நூல் பிரதான நூல் முதன்மை நூல் குழந்தை நூல் குழந்தை நூல் குழந்தை நூல் குழந்தை நூல் குழந்தை நூல் முதன்மை நூல் குழந்தை நூல் முதன்மை நூல் முதன்மை நூல் குழந்தை நூல் குழந்தை நூல் பிரதான நூல் முதன்மை நூல் குழந்தை நூல் குழந்தை நூல் முதன்மை நூல்

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

இயங்கக்கூடிய இடைமுகத்தின் வரையறை

runnable இல் ஒரு இடைமுகம் java.lang தொகுப்பதற்கு. இயங்கக்கூடிய இடைமுகத்தை செயல்படுத்துதல் நாம் ஒரு நூலை வரையறுக்க முடியும். இயங்கக்கூடிய இடைமுகம் ஒரு முறையைக் கொண்டுள்ளது ஓடு(), இது இயங்கக்கூடிய இடைமுகத்தை செயல்படுத்தும் வகுப்பால் செயல்படுத்தப்படுகிறது. இயங்கக்கூடிய இடைமுகத்தை செயல்படுத்தும் நூலை வரையறுக்க நீங்கள் தேர்வுசெய்யும்போது, ​​வேறு எந்த வகுப்பையும் நீட்டிக்க உங்களுக்கு இன்னும் விருப்பம் உள்ளது. இயங்கக்கூடிய இடைமுகத்தை செயல்படுத்துவதன் மூலம் நீங்கள் பல நூல்களை உருவாக்கும்போது, ​​ஒவ்வொரு நூலும் ஒரே இயங்கக்கூடிய நிகழ்வைப் பகிர்ந்து கொள்கின்றன. இயங்கக்கூடிய இடைமுகத்தைப் பயன்படுத்தி ஒரு நூலை எவ்வாறு வரையறுப்பது என்பதைக் கற்றுக்கொள்வோம்.

/ * ஒரு நூலை வரையறுத்தல் * / வகுப்பு இயக்கக்கூடிய நூல் இயங்கக்கூடிய {/ * நூலின் வேலை * / பொது வெற்றிட ரன் () {(int i = 0; i <10; i ++) {System.Out.ln ("குழந்தை நூல்" ); Main} வகுப்பு மெயின் த்ரெட் main / * பிரதான நூலின் வேலை * / பொது நிலையான வெற்றிட மெயின் (சரம் ஆர்க்ஸ்) {மைத்ரெட் rt = புதிய மித்ரெட் (); / * பிரதான நூல் இயங்கக்கூடிய பொருளை உருவாக்கியது * / நூல் t = புதிய நூல் (rt); / * பிரதான நூல் குழந்தை நூலை உருவாக்கி இயங்கக்கூடிய பொருளைக் கடந்து சென்றது * / t.start (); for (int i = 0; i <10; i ++) {System.Out. ("முதன்மை நூல்"); Th}} / * வெளியீடு * / பிரதான நூல் பிரதான நூல் முதன்மை நூல் குழந்தை நூல் குழந்தை நூல் குழந்தை நூல் குழந்தை நூல் குழந்தை நூல் முதன்மை நூல் குழந்தை நூல் முதன்மை நூல் முதன்மை நூல் குழந்தை நூல் குழந்தை நூல் பிரதான நூல் முதன்மை நூல் குழந்தை நூல் குழந்தை நூல் முதன்மை நூல்

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

ஜாவாவில் நூல் மற்றும் இயக்கக்கூடிய முக்கிய வேறுபாடுகள்

1. நூல் வகுப்பை விரிவாக்குவதன் மூலம் உருவாக்கப்பட்ட ஒவ்வொரு நூலும் அதற்கான தனித்துவமான பொருளை உருவாக்கி அந்த பொருளுடன் தொடர்புடையதாக இருக்கும். மறுபுறம், இயங்கக்கூடிய இடைமுகத்தை செயல்படுத்துவதன் மூலம் உருவாக்கப்பட்ட ஒவ்வொரு நூலும் ஒரே இயங்கக்கூடிய நிகழ்வைப் பகிர்ந்து கொள்கின்றன.
2. நூல் வகுப்பை விரிவாக்குவதன் மூலம் உருவாக்கப்படும் போது ஒவ்வொரு நூலும் தனித்துவமான பொருளுடன் தொடர்புடையதாக இருப்பதால், அதிக நினைவகம் தேவைப்படுகிறது. மறுபுறம், இயங்கக்கூடிய இடைமுகத்தை செயல்படுத்துவதன் மூலம் உருவாக்கப்பட்ட ஒவ்வொரு நூலும் ஒரே பொருள் இடத்தைப் பகிர்ந்து கொள்கின்றன, எனவே இதற்கு குறைந்த நினைவகம் தேவைப்படுகிறது.
3. நீங்கள் நூல் வகுப்பை நீட்டித்தால், ஜாவா பல பரம்பரை அனுமதிக்காததால் நீங்கள் வேறு எந்த வகுப்பையும் பெறலாம், அதேசமயம் ரன்னேபிள் செயல்படுத்துவது ஒரு வகுப்பிற்கு வேறு எந்த வகுப்பையும் பெற வாய்ப்பளிக்கிறது.
4. நூல் வகுப்பின் வேறு சில முறைகளை மேலெழுத அல்லது நிபுணத்துவம் பெற வேண்டுமானால் மட்டுமே ஒரு நூல் வகுப்பை நீட்டிக்க வேண்டும். ரன் முறையை மட்டும் நிபுணத்துவம் செய்ய விரும்பினால் நீங்கள் இயக்கக்கூடிய இடைமுகத்தை செயல்படுத்த வேண்டும்.
5. நூல் வகுப்பை விரிவாக்குவது குறியீட்டில் இறுக்கமான இணைப்பை அறிமுகப்படுத்துகிறது, ஏனெனில் நூல் குறியீடு மற்றும் நூலின் வேலை ஒரே வகுப்பினரால் உள்ளது. மறுபுறம், இயங்கக்கூடிய இடைமுகத்தை செயல்படுத்துவது குறியீட்டில் தளர்வான இணைப்பை அறிமுகப்படுத்துகிறது, ஏனெனில் நூலின் குறியீடு நூலுக்கு ஒதுக்கப்பட்ட வேலையிலிருந்து பிரிக்கப்படுகிறது.

முடிவுரை:

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