జావాలో స్థిర విలువలు: చివరి, స్థిరాంకాలు మరియు మార్పులేనివి

హాయ్! "మాడిఫైయర్" అనే పదం మీకు ఇప్పటికే బాగా తెలుసు. కనీసం, మీరు యాక్సెస్ మాడిఫైయర్‌లను (పబ్లిక్, ప్రైవేట్) మరియు స్టాటిక్ మాడిఫైయర్‌లను ఎదుర్కొన్నారు. ఈ రోజు మనం ఫైనల్ అనే ప్రత్యేక మాడిఫైయర్ గురించి చర్చిస్తాము . స్థిరమైన, స్పష్టమైన, మార్పులేని ప్రవర్తనలు అవసరమయ్యే మా ప్రోగ్రామ్‌లోని చివరి మాడిఫైయర్ "సిమెంట్స్" భాగాలను మీరు చెప్పవచ్చు. మీ ప్రోగ్రామ్‌లలో మీరు ఉపయోగించగల మూడు స్థలాలు ఉన్నాయి: తరగతులు, పద్ధతులు మరియు వేరియబుల్స్. వాటిని క్రమంలో నడుపుదాం. క్లాస్ డిక్లరేషన్‌లో ఫైనల్ మాడిఫైయర్ ఉపయోగించబడితే , తరగతి వారసత్వంగా పొందబడదని అర్థం. మునుపటి పాఠాలలో, మేము ఒక సాధారణ వారసత్వ ఉదాహరణను ఉపయోగించాము: మాకు 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". మనకు స్థిరాంకాలు ఎందుకు అవసరం? ఉదాహరణకు, మీరు ప్రోగ్రామ్‌లో క్రమం తప్పకుండా ఉపయోగించే స్థిర విలువ ఉంటే అవి చాలా ఉపయోగకరంగా ఉంటాయి. ఉదాహరణకు, మీరు చరిత్ర సృష్టించాలని మరియు "The Witcher 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 ". ఏ ఇతర రకాలు మార్పులేనివి? మీరు ఖచ్చితంగా గుర్తుంచుకోవాల్సిన కొన్ని అన్ని ఆదిమ రకాల రేపర్ తరగతులు. Integer, Byte, Character, Short, Boolean, Long, Double, Float: ఈ తరగతులన్నీ ఆబ్జెక్ట్‌లను సృష్టిస్తాయి ( వాటి గురించి మేము immutableరాబోయే పాఠాలలో మాట్లాడుతాము). ఇందులో పెద్ద సంఖ్యలను సృష్టించడానికి ఉపయోగించే తరగతులు ఉన్నాయి BigIntegerమరియు , ఏమి ఊహించండి, java.lang.StackTraceElementBigDecimalవస్తువులు కూడా మార్పులేనివి. ఇది అర్ధమే: ఎవరైనా మా స్టాక్ డేటాను మార్చగలిగితే, అది మొత్తం పనికిరానిదిగా చేస్తుంది. ఎవరైనా స్టాక్ ట్రేస్ ద్వారా వెళ్లి OutOfMemoryError ని FileNotFoundException కి మార్చడాన్ని ఊహించుకోండి . ఆపై మీరు లోపం యొక్క కారణాన్ని కనుగొనడానికి ఆ స్టాక్‌ని ఉపయోగిస్తారు. కానీ ప్రోగ్రామ్ ఫైల్‌లను కూడా ఉపయోగించదు. :) కాబట్టి, వారు ఈ వస్తువులను మార్పులేని విధంగా చేసారు. సరే, కాబట్టి ఇది StackTraceElement కోసం ఎక్కువ లేదా తక్కువ అర్ధమే . కానీ, ఎవరైనా తీగలను మార్చలేనిదిగా ఎందుకు చేయాలి? వారి విలువలను మార్చడం ఎందుకు సమస్య? ఇది బహుశా మరింత సౌకర్యవంతంగా ఉంటుంది. :/ దీనికి అనేక కారణాలు ఉన్నాయి. మొదట, ఇది మెమరీని ఆదా చేస్తుంది. మార్పులేని తీగలను స్ట్రింగ్ పూల్‌లో ఉంచవచ్చు, కొత్త వాటిని సృష్టించే బదులు స్ట్రింగ్‌లను మళ్లీ ఉపయోగించడానికి అనుమతిస్తుంది. రెండవది, భద్రత కోసం. ఉదాహరణకు, వినియోగదారు పేర్లు మరియు పాస్‌వర్డ్‌లు దాదాపు ప్రతి ప్రోగ్రామ్‌లో స్ట్రింగ్‌లుగా ఉంటాయి. వాటిని మార్చడం సాధ్యం చేయడం వలన అధికార సమస్యలు ఏర్పడవచ్చు. ఇతర కారణాలు ఉన్నాయి, కానీ జావాపై మా అధ్యయనం ఇంకా వాటిని కవర్ చేయలేదు, కాబట్టి మేము వాటి గురించి తర్వాత తిరిగి వస్తాము.