ஜாவாவில் நிலையான மதிப்புகள்: இறுதி, மாறிலிகள் மற்றும் மாறாதவை

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

public class Animal {
}



public class Cat extends Animal {
   // Fields and methods of the Cat class
}


public class Dog extends Animal {

   // Fields and methods of the Dog class
}

இருப்பினும், வகுப்பில் இறுதி மாற்றியைப் பயன்படுத்தினால் Animal, தி Catமற்றும் Dogவகுப்புகள் அதை மரபுரிமையாகப் பெற முடியாது.

public final class Animal {

}

public class Cat extends Animal {

   // Error! Cannot inherit from final Animal
}

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

public class Animal {
  
   public void speak() {
       System.out.println("Hello!");
   }
}

public class Cat extends Animal {

   @Override
   public void speak() {
       System.out.println("Meow!");
   }
}

public class Dog extends Animal {

   @Override
   public void speak() {
       System.out.println("Woof!");
   }
}

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

public class Main {

   public static void main(String[] args) {

       Cat cat = new Cat();
       Dog dog = new Dog();
      
       cat.speak();
       dog.speak();
   }
}

வெளியீடு: மியாவ்! வூஃப்! Animalஇருப்பினும், வகுப்பின் முறையை இறுதியானது என அறிவித்தால் speak(), பிற வகுப்புகளில் அதை மீற முடியாது:

public class Animal {

   public final void speak() {
       System.out.println("Hello!");
   }
}


public class Cat extends Animal {

   @Override
   public void speak() {// Error! A final method can't be overridden!
       System.out.println("Meow!");
   }
}

speak()பெற்றோர் வகுப்பில் வரையறுக்கப்பட்டுள்ள முறையைப் பயன்படுத்த எங்கள் பொருள்கள் கட்டாயப்படுத்தப்படும் :

public static void main(String[] args) {

   Cat cat = new Cat();
   Dog dog = new Dog();

   cat.speak();
   dog.speak();
}

வெளியீடு: வணக்கம்! வணக்கம்! இப்போது, ​​இறுதி மாறிகள் பற்றி. அவை மாறிலிகள் என்றும் அழைக்கப்படுகின்றன . முதலில் (மற்றும் மிக முக்கியமாக), நிலையான மதிப்புக்கு ஒதுக்கப்பட்ட ஆரம்ப மதிப்பை மாற்ற முடியாது. இது ஒரு முறை மற்றும் அனைவருக்கும் ஒதுக்கப்பட்டுள்ளது.

public class Main {
  
   private static final int CONSTANT_EXAMPLE = 333;

   public static void main(String[] args) {

       CONSTANT_EXAMPLE = 999;// Error! You can't assign a new value to a final variable!
   }
}

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

public static void main(String[] args) {

   final int CONSTANT_EXAMPLE;

   CONSTANT_EXAMPLE = 999;// This is allowed
}

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

public class TheWitcher4 {

   private static final String GERALT_NAME = "Geralt of Rivia";
   private static final String YENNEFER_NAME = "Yennefer of Wengerberg";
   private static final String TRISS_NAME = "Triss Merigold";

   public static void main(String[] args) {

       System.out.println("The Witcher 4");
       System.out.println("It's already the fourth Witcher game, but " + GERALT_NAME + " still can't decide who" +
               " he likes more: " + YENNEFER_NAME + " or " + TRISS_NAME);

       System.out.println("But, if you've never played The Witcher before, we'll start from the beginning.");
       System.out.println("The protagonist's name is " + GERALT_NAME);
       System.out.println(GERALT_NAME + " is a witcher, a monster hunter");
   }
}

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

மாறாத வகைகள்

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

public static void main(String[] args) {

   String str1 = "I love Java";

   String str2 = str1;// Both reference variables point to the same string.
   System.out.println(str2);

   str1 = "I love Python";// but changing str1 has no impact on str2
   System.out.println(str2);// str2 continues to point to the "I love Java" string, but str1 now points to a different object
}

வெளியீடு: நாங்கள் எழுதிய பிறகு நான் ஜாவாவை விரும்புகிறேன்

str1 = "I love Python";

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

str1 = "I love Python";

str1 இப்போது சுட்டிக்காட்டும் மற்றொரு பொருளை உருவாக்கியது . ஆனால், "ஐ லவ் ஜாவா" சரம் பொருளில் எந்த விளைவையும் ஏற்படுத்த முடியாது. சரி, வேறு ஏதாவது முயற்சி செய்யலாம்! வகுப்பு Stringமுறைகள் நிறைந்தது, மேலும் சிலவற்றில் பொருளின் நிலையை மாற்றுவது போல் தோன்றும்! உதாரணமாக, ஒரு replace()முறை உள்ளது. நம் சரத்தில் ஜாவா என்ற வார்த்தையை "பைதான்" என்று மாற்றுவோம்!

public static void main(String[] args) {

   String str1 = "I love Java";

   String str2 = str1;// Both reference variables point to the same string.
   System.out.println(str2);

   str1.replace("Java", "Python");// We try to change the state of str1 by swapping the word "Java" with "Python"
   System.out.println(str2);
}

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

public static void main(String[] args) {

   String str1 = "I love Java";

   String str2 = str1;// Both reference variables point to the same string.
   System.out.println(str2);

   str1.substring(10);// Truncate the original String 
   System.out.println(str2);
}

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

str1.replace("Java", "Python");

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

public static void main(String[] args) {

   String str1 = "I love Java";

   String str2 = str1;// Both reference variables point to the same string.
   System.out.println(str2);

   String str1AfterReplacement =  str1.replace("Java", "Python");
   System.out.println(str2);

   System.out.println(str1AfterReplacement);
}

எல்லா Stringமுறைகளும் இந்த வழியில் செயல்படுகின்றன. பொருளை ஒன்றும் செய்ய முடியாது "I love Java". நீங்கள் ஒரு புதிய பொருளை உருவாக்கி எழுதலாம்: "<புதிய பொருள்> = கையாளுதலின் "I love Java" object "விளைவு , , , , , , : இந்த வகுப்புகள் அனைத்தும் பொருட்களை உருவாக்குகின்றன ( அவற்றைப் பற்றி வரவிருக்கும் பாடங்களில் பேசுவோம்) இதில் பெரிய எண்களை உருவாக்கப் பயன்படுத்தப்படும் வகுப்புகளும் அடங்கும், எடுத்துக்காட்டாக மற்றும் . , யூகிக்க என்ன, java.lang.StackTraceElementIntegerByteCharacterShortBooleanLongDoubleFloatimmutableBigIntegerBigDecimalபொருள்களும் மாறாதவை. இது அர்த்தமுள்ளதாக இருக்கிறது: நமது ஸ்டேக்கின் தரவை யாராவது மாற்றினால், அது முழு விஷயத்தையும் அர்த்தமற்றதாக மாற்றிவிடும். யாரோ ஒருவர் ஸ்டேக் ட்ரேஸ் வழியாக சென்று OutOfMemoryError ஐ FileNotFoundException ஆக மாற்றுவதை கற்பனை செய்து பாருங்கள் . பிழையின் காரணத்தைக் கண்டறிய அந்த அடுக்கைப் பயன்படுத்துகிறீர்கள். ஆனால் நிரல் கோப்புகளைப் பயன்படுத்துவதில்லை. :) எனவே, அவர்கள் இந்த பொருள்களை மாறாதவர்களாக ஆக்கினார்கள். சரி, அது StackTraceElement க்கு அதிகமாகவோ அல்லது குறைவாகவோ அர்த்தமுள்ளதாக இருக்கிறது . ஆனால், யாரேனும் ஏன் சரங்களை மாறாததாக மாற்ற வேண்டும்? அவர்களின் மதிப்புகளை மாற்றுவது ஏன் ஒரு பிரச்சனையாக இருக்கும்? இது ஒருவேளை இன்னும் வசதியாக இருக்கும். :/ இதற்கு பல காரணங்கள் உள்ளன. முதலில், இது நினைவகத்தை சேமிக்கிறது. மாறாத சரங்களை சரம் குளத்தில் வைக்கலாம், புதியவற்றை உருவாக்குவதற்குப் பதிலாக சரங்களை மீண்டும் பயன்படுத்த அனுமதிக்கிறது. இரண்டாவது, பாதுகாப்புக்காக. எடுத்துக்காட்டாக, ஒவ்வொரு நிரலிலும் பயனர்பெயர்கள் மற்றும் கடவுச்சொற்கள் சரங்களாகும். அவற்றை மாற்றுவது அங்கீகாரச் சிக்கல்களை ஏற்படுத்தலாம். மற்ற காரணங்களும் உள்ளன, ஆனால் ஜாவா பற்றிய எங்கள் ஆய்வு இன்னும் அவற்றைப் பற்றி விவாதிக்கவில்லை, எனவே நாங்கள் அவற்றைப் பற்றி பின்னர் வருவோம்.