இறுதி மற்றும் பிற ஜாவா முக்கிய வார்த்தைகள்

"ஹாய், அமிகோ!"

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

"இன்று நான் ஜாவாவில் உள்ள பல முக்கிய வார்த்தைகளைப் பற்றி உங்களுக்குச் சொல்லப் போகிறேன். ஆனால் நான் மிகவும் சுவாரசியமான வார்த்தைகளுடன் தொடங்குவேன்: இறுதிச் சொல். "

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

"நமக்கு ஏன் இறுதி தேவை?"

"இது மிகவும் எளிமையானது. ஒரு மாறியை இறுதியாகக் குறித்தால், அது மாற்ற முடியாததாகிவிடும்:"

final int i = 5;
i++; //Compilation error: the value of i cannot be changed.

"நான் பார்க்கிறேன்."

"நாம் ஒரு முறையை இறுதியாகக் குறித்தால், பெறப்பட்ட வகுப்புகளில் முறையை மீறுவது தடைசெய்யப்பட்டுள்ளது:"

class Cat
{
 public final String getName()
 {
  return "cat";
 }
}

class Tiger extends Cat
{
 public String getName() //Compilation error: overriding the getName()
 {
  return "tiger";
 }
}

"நான் பார்க்கிறேன். ஆனால் ஒரு முறையை மீறுவதை நீங்கள் ஏன் தடை செய்ய வேண்டும்?"

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

"இறுதியாக, மூன்றாவது பயன்பாடு."

"ஒரு வகுப்பை இறுதிச் சொல்லைக் கொண்டு குறியிட்டால், அதை மரபுரிமையாகப் பெற முடியாது."

public final class Cat
{
 public String getName()
 {
  return "cat";
 }
}

class Tiger extends Cat //Compilation error: the Cat class cannot be
{
 public String getName()
 {
  return "tiger";
 }
}

"ஒரு வர்க்கம் மரபுரிமையாக வருவதை நாம் ஏன் தடுக்க வேண்டும்?"

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

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

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

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

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

"இறுதியை வேறு எங்கு பயன்படுத்தலாம்?"

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

public void setName(final String name)
{
 final String displayName = "Mr."+ name;
  …
 this.name = displayName;
}

"அதனால் என்ன பயன்?"

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

எடுத்துக்காட்டாக, விலையின் அடிப்படையில் விற்பனை வரியைக் கணக்கிட விரும்புகிறோம்:

public int getPriceNDS()
{
 final int NDS = 20;
 return this.price * NDS / 200;
}

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

"சரி, இதுவரை சிக்கலான எதுவும் இல்லை."

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

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

"இல்லை, நீங்கள் ஒரு மாறாத வகுப்பை எழுதாவிட்டால்."

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

class Home
{
 private final int width = 200;
 private final int height = 100;

 public Home()
 {
 }
}

class Home
{
 private final int width;
 private final int height;

 public Home()
 {
 }
}

"ஆனால், ஜாவா ஒரு வகுப்பின் இறுதி மாறிகளின் துவக்கத்தை கன்ஸ்ட்ரக்டர் வரை தாமதப்படுத்த உங்களை அனுமதிக்கிறது."

class Home
{
 private final int width = 200;
 private final int height;

 public Home()
 {
  height = 100;
 }
}

class Home
{
 private final int width;
 private final int height;

 public Home()
 {
  height = 100;
 }
}

"கூடுதலாக, வெவ்வேறு கட்டமைப்பாளர்கள் வெவ்வேறு மதிப்புகளுடன் இறுதி மாறிகளை துவக்கலாம். இது மிகவும் வசதியானது:"

class Home
{
 private final int width;
 private final int height;

 public Home()
 {
  height = 100;
  width = 200;
 }

 public Home(int width)
 {
  this.height = 300;
  this.width = width;
 }

 public Home(int width, int height)
 {
  this.height = height;
  this.width = width;
 }
}

"இது மிகவும் சுவாரசியமான தலைப்பு, முற்றிலும் எல்லாமே அர்த்தமுள்ளதாக இருந்தது. நன்றி, பிலாபோ!"