జావాలోని స్టాటిక్ మాడిఫైయర్ గురించి మీరు తెలుసుకోవలసిన 10 విషయాలు

జావాలో, స్టాటిక్ మాడిఫైయర్ అంటే ఏదో ఒక తరగతికి నేరుగా సంబంధించినది: ఫీల్డ్ స్థిరంగా ఉంటే, అది తరగతికి చెందినది; ఒక పద్ధతి స్థిరంగా ఉంటే, అది తరగతికి చెందినది. ఫలితంగా, మీరు స్టాటిక్ పద్ధతికి కాల్ చేయడానికి లేదా స్టాటిక్ ఫీల్డ్‌ని సూచించడానికి తరగతి పేరును ఉపయోగించవచ్చు. ఉదాహరణకు, countఫీల్డ్ క్లాస్‌లో స్థిరంగా ఉంటే Counter, మీరు ఈ క్రింది వ్యక్తీకరణతో వేరియబుల్‌ను సూచించవచ్చని అర్థం: Counter.count. వాస్తవానికి, యాక్సెస్ మాడిఫైయర్లను తప్పనిసరిగా పరిగణించాలి. ఉదాహరణకు, privateఫీల్డ్‌లు అవి ప్రకటించబడిన తరగతిలో మాత్రమే అందుబాటులో ఉంటాయి. మరియు protectedఫీల్డ్‌లు ప్యాకేజీలోని అన్ని తరగతులకు అలాగే ప్యాకేజీ వెలుపల ఉన్న అన్ని సబ్‌క్లాస్‌లకు అందుబాటులో ఉంటాయి. తరగతిని పెంచడం అనేది Counterఒక స్థిరమైన పద్ధతిని కలిగి ఉందని అనుకుందాంincrement()countఫీల్డ్. ఈ పద్ధతిని కాల్ చేయడానికి, మీరు ఉపయోగించవచ్చు Counter.increment(). Counterస్టాటిక్ ఫీల్డ్ లేదా పద్ధతిని యాక్సెస్ చేయడానికి క్లాస్ యొక్క ఉదాహరణను సృష్టించాల్సిన అవసరం లేదు . ఇది స్టాటిక్ (క్లాస్) వేరియబుల్స్ మరియు మెథడ్స్ మరియు నాన్-స్టాటిక్ (ఉదాహరణ) వేరియబుల్స్ మరియు మెథడ్స్ మధ్య ఉన్న ప్రాథమిక వ్యత్యాసం. ఒక ముఖ్యమైన గమనిక. క్లాస్‌లోని స్టాటిక్ మెంబర్‌లు నేరుగా క్లాస్‌కు చెందినవారని మర్చిపోవద్దు, తరగతికి సంబంధించిన ఏదైనా ఉదాహరణ కాదు. అంటే, స్టాటిక్ countవేరియబుల్ విలువ అన్ని వస్తువులకు ఒకే విధంగా ఉంటుంది Counter. ఈ కథనంలో, మేము జావాలో స్టాటిక్ మాడిఫైయర్‌ను ఉపయోగించడం యొక్క ప్రాథమిక అంశాలను అలాగే కీలక ప్రోగ్రామింగ్ భావనలను అర్థం చేసుకోవడంలో మీకు సహాయపడే కొన్ని లక్షణాలను పరిశీలిస్తాము.

జావాలోని స్టాటిక్ మాడిఫైయర్ గురించి ప్రతి ప్రోగ్రామర్ తెలుసుకోవలసినది.

ఈ విభాగంలో, మేము స్టాటిక్ పద్ధతులు, ఫీల్డ్‌లు మరియు తరగతులను ఉపయోగించడం యొక్క ప్రధాన అంశాలను పరిశీలిస్తాము. వేరియబుల్స్‌తో ప్రారంభిద్దాం.

1. మీరు స్టాటిక్ మెథడ్ లేదా బ్లాక్ వంటి స్టాటిక్ సందర్భంలో క్లాస్‌లోని నాన్-స్టాటిక్ మెంబర్‌లను యాక్సెస్ చేయలేరు. దిగువ కోడ్‌ను కంపైల్ చేయడం వలన లోపం ఏర్పడుతుంది:

   
   public class Counter {
   private int count;
   public static void main(String args []) {
      System.out.println(count); //  Compile time error
   }
   }
   

   జావా ప్రోగ్రామర్లు, ముఖ్యంగా కొత్తవారు చేసే అత్యంత సాధారణ తప్పులలో ఇది ఒకటి. mainపద్ధతి స్థిరమైనది మరియు countవేరియబుల్ కాదు కాబట్టి , పద్ధతి printlnలోపల ఉన్న పద్ధతిని ఉపయోగించడం వలన main"కంపైల్ టైమ్ ఎర్రర్" ఏర్పడుతుంది.

2. thread safeస్థానిక వేరియబుల్స్ కాకుండా, స్టాటిక్ ఫీల్డ్‌లు మరియు పద్ధతులు జావాలో లేవు . ఆచరణలో, బహుళ-థ్రెడ్ ప్రోగ్రామింగ్‌లో భద్రతా సమస్యలకు ఇది చాలా తరచుగా కారణాలలో ఒకటి. క్లాస్ యొక్క ప్రతి ఉదాహరణ స్టాటిక్ వేరియబుల్ యొక్క అదే కాపీని సూచిస్తుందని పరిగణనలోకి తీసుకుంటే, అటువంటి వేరియబుల్ క్లాస్ ద్వారా రక్షించబడాలి లేదా "లాక్" చేయబడాలి. కాబట్టి, స్టాటిక్ వేరియబుల్స్ ఉపయోగిస్తున్నప్పుడు, synchronizedవంటి సమస్యలను నివారించడానికి అవి సరిగ్గా ఉన్నాయని నిర్ధారించుకోండి race conditions.

3. స్టాటిక్ పద్ధతులు ఆచరణాత్మక ప్రయోజనాన్ని కలిగి ఉంటాయి, మీరు వాటిని కాల్ చేయాలనుకున్న ప్రతిసారీ కొత్త వస్తువును సృష్టించాల్సిన అవసరం లేదు. దానిని ప్రకటించే తరగతి పేరును ఉపయోగించి స్టాటిక్ పద్ధతిని పిలుస్తారు. అందుకే ఈ పద్ధతులు factoryపద్ధతులు మరియు utilityపద్ధతులకు సరైనవి. తరగతి java.lang.Mathఒక అద్భుతమైన ఉదాహరణ: దాదాపు అన్ని దాని పద్ధతులు స్థిరంగా ఉంటాయి. finalజావా యొక్క యుటిలిటీ తరగతులు అదే కారణంతో గుర్తించబడ్డాయి .

4. @Overrideమరొక ముఖ్యమైన విషయం ఏమిటంటే, మీరు స్టాటిక్ పద్ధతులను ( ) భర్తీ చేయలేరు . మీరు అటువంటి పద్ధతిని a లో ప్రకటిస్తే subclass, అంటే అదే పేరు మరియు సంతకంతో ఉన్న పద్ధతి, మీరు దానిని superclassభర్తీ చేయడానికి బదులుగా "దాచండి". ఈ దృగ్విషయాన్ని అంటారు method hiding. దీని అర్థం పేరెంట్ మరియు చైల్డ్ క్లాస్‌లలో స్టాటిక్ మెథడ్ డిక్లేర్ చేయబడితే, కంపైల్ సమయంలో పిలవబడే పద్ధతి ఎల్లప్పుడూ వేరియబుల్ రకంపై ఆధారపడి ఉంటుంది. మెథడ్ ఓవర్‌రైడింగ్ కాకుండా, ప్రోగ్రామ్ రన్ అయినప్పుడు ఇటువంటి పద్ధతులు అమలు చేయబడవు. ఒక ఉదాహరణను పరిశీలిద్దాం:

   
   class Vehicle {
        public static void kmToMiles(int km) {
             System.out.println("Inside the parent class / static method");
        } 
   }
   
   class Car extends Vehicle {
        public static void kmToMiles(int km) {
             System.out.println("Inside the child class / static method");
        } 
   }
   
   public class Demo {   
      public static void main(String args []) {
         Vehicle v = new Car();
          v.kmToMiles(10);
     }
   }
   

   కన్సోల్ అవుట్‌పుట్:

   పేరెంట్ క్లాస్ / స్టాటిక్ మెథడ్ లోపల

   ఆబ్జెక్ట్ a అయినప్పటికీ Car, క్లాస్‌లోని స్టాటిక్ మెథడ్‌ని Vehicleకంపైల్ సమయంలో పిలుస్తారని కోడ్ స్పష్టంగా చూపిస్తుంది. మరియు సంకలన లోపాలు లేవని గమనించండి!

5. ఇంకా ఏమిటంటే, అత్యున్నత స్థాయి తరగతులు కాకుండా, మీరు తరగతులను స్థిరంగా ప్రకటించవచ్చు. ఇటువంటి తరగతులు అంటారు nested static classes. అవి మంచి సమన్వయాన్ని అందించడానికి ఉపయోగపడతాయి. సమూహ స్టాటిక్ క్లాస్ యొక్క అద్భుతమైన ఉదాహరణ HashMap.Entry, ఇది లోపల ఉన్న డేటా నిర్మాణం HashMap. ఇది గమనించదగ్గ విషయం ఏమిటంటే, అంతర్గత తరగతుల వలె, స్టాటిక్ నెస్టెడ్ తరగతులు ప్రత్యేక .class ఫైల్‌లో ప్రకటించబడతాయి. అందువల్ల, మీరు మీ ప్రధాన తరగతిలో ఐదు సమూహ తరగతులను ప్రకటిస్తే, మీరు .class పొడిగింపుతో 6 ఫైల్‌లను కలిగి ఉంటారు. మరొక ఉదాహరణ తరగతిలో Comparatorవయస్సు పోలిక ( ) వంటి మా స్వంత ప్రకటన .AgeComparatorEmployee

6. స్టాటిక్ మాడిఫైయర్‌ను స్టాటిక్ బ్లాక్‌లో కూడా పేర్కొనవచ్చు, దీనిని "స్టాటిక్ ఇనిషియలైజేషన్ బ్లాక్" అని పిలుస్తారు, ఇది క్లాస్ లోడ్ అయినప్పుడు అమలు చేయబడుతుంది. మీరు అటువంటి బ్లాక్‌ని ప్రకటించకుంటే, జావా అన్ని స్టాటిక్ ఫీల్డ్‌లను ఒకే జాబితాలో సేకరిస్తుంది మరియు క్లాస్ లోడ్ అయినప్పుడు వాటిని ప్రారంభిస్తుంది. స్టాటిక్ బ్లాక్ తనిఖీ చేయబడిన మినహాయింపులను విసిరివేయదు, కానీ అది ఎంపిక చేయని వాటిని విసిరివేయగలదు. ఈ సందర్భంలో, ఒక ExceptionInInitializerErrorజరుగుతుంది. ఆచరణలో, స్టాటిక్ ఫీల్డ్‌ల ప్రారంభ సమయంలో సంభవించే ఏదైనా మినహాయింపు జావా ద్వారా ఈ ఎర్రర్‌లో చుట్టబడుతుంది. ఇది కూడా అత్యంత సాధారణ కారణం NoClassDefFoundError, ఎందుకంటే తరగతి సూచించబడినప్పుడు అది మెమరీలో ఉండదు.

7. వర్చువల్ లేదా నాన్-స్టాటిక్ మెథడ్‌ల లింక్‌లా కాకుండా, కంపైల్ సమయంలో స్టాటిక్ పద్ధతులు లింక్ చేయబడతాయని తెలుసుకోవడం ఉపయోగకరంగా ఉంటుంది, ఇవి నిజమైన వస్తువుపై కాల్ చేసినప్పుడు రన్ టైమ్‌లో లింక్ చేయబడతాయి. దీని ప్రకారం, జావాలో స్టాటిక్ పద్ధతులను భర్తీ చేయడం సాధ్యం కాదు, ఎందుకంటే రన్ టైమ్‌లో పాలిమార్ఫిజం వాటికి వర్తించదు. స్థిరమైన పద్ధతిని ప్రకటించేటప్పుడు ఇది పరిగణించవలసిన ముఖ్యమైన పరిమితి. సబ్‌క్లాస్‌లో పద్ధతిని భర్తీ చేసే సామర్థ్యం లేదా అవసరం లేనప్పుడు మాత్రమే అలా చేయడం అర్థవంతంగా ఉంటుంది. ఫ్యాక్టరీ పద్ధతులు మరియు యుటిలిటీ పద్ధతులు స్టాటిక్ మాడిఫైయర్ యొక్క సరైన ఉపయోగానికి మంచి ఉదాహరణలు. జాషువా బ్లాచ్ తన పుస్తకం ఎఫెక్టివ్ జావాలో స్టాటిక్ ఫ్యాక్టరీ పద్ధతులు కన్‌స్టక్టర్‌ల కంటే కలిగి ఉన్న అనేక ప్రయోజనాలను సూచించాడు, ఇది ప్రతి జావా ప్రోగ్రామర్‌కు తప్పనిసరిగా చదవాలి.

8. ఇనిషియలైజేషన్ అనేది స్టాటిక్ బ్లాక్ యొక్క ముఖ్యమైన అంశం. క్లాస్ మెమరీలోకి లోడ్ అయిన తర్వాత స్టాటిక్ ఫీల్డ్‌లు లేదా వేరియబుల్స్ ప్రారంభించబడతాయి. ప్రారంభించడం యొక్క క్రమం పై నుండి క్రిందికి, అదే క్రమంలో అవి జావా క్లాస్ యొక్క సోర్స్ ఫైల్‌లో ప్రకటించబడతాయి. స్టాటిక్ ఫీల్డ్‌లు థ్రెడ్-సురక్షిత పద్ధతిలో ప్రారంభించబడినందున, ఈ ప్రక్రియ Singletonనమూనాను అమలు చేయడానికి కూడా ఉపయోగించబడుతుంది. Enumమీరు కొన్ని కారణాల వల్ల a గా ఉపయోగించకపోతే Singleton, మీకు మంచి ప్రత్యామ్నాయం ఉంది. కానీ ఈ సందర్భంలో, ఇది "సోమరితనం" ప్రారంభించడం కాదని మీరు పరిగణనలోకి తీసుకోవాలి. ఎవరైనా "అడిగే" ముందు కూడా స్టాటిక్ ఫీల్డ్ ప్రారంభించబడుతుందని దీని అర్థం. ఆబ్జెక్ట్ రిసోర్స్-హెవీ లేదా అరుదుగా ఉపయోగించినట్లయితే, దాన్ని స్టాటిక్ బ్లాక్‌లో ప్రారంభించడం మీకు అనుకూలంగా పని చేయదు.

9. సీరియలైజేషన్ సమయంలో, transientవేరియబుల్స్ వంటి స్టాటిక్ ఫీల్డ్‌లు సీరియలైజ్ చేయబడవు. నిజానికి, మీరు ఏదైనా డేటాను స్టాటిక్ ఫీల్డ్‌లో సేవ్ చేస్తే, అది డీరియలైజేషన్ తర్వాత దాని ప్రారంభ (డిఫాల్ట్) విలువను కలిగి ఉంటుంది. ఉదాహరణకు, స్టాటిక్ ఫీల్డ్ ఒక అయితే int, డీరియలైజేషన్ తర్వాత దాని విలువ సున్నా అవుతుంది. దాని రకం అయితే float, విలువ 0.0 అవుతుంది. ఫీల్డ్ ఒక అయితే Object, విలువ ఉంటుంది null. నిజం చెప్పాలంటే, జావా స్థానాలకు సంబంధించిన ఇంటర్వ్యూలలో సీరియలైజేషన్ గురించి తరచుగా అడిగే ప్రశ్నలలో ఇది ఒకటి. స్టాటిక్ ఫీల్డ్‌లో అవసరమైన వస్తువు డేటాను నిల్వ చేయవద్దు!

10. చివరగా, స్టాటిక్ దిగుమతి గురించి మాట్లాడుకుందాం. ఈ మాడిఫైయర్ స్టాండర్డ్ స్టేట్‌మెంట్‌తో చాలా సారూప్యతను కలిగి ఉంది import, అయితే ఇది భిన్నంగా ఉంటుంది, ఇది ఒకటి లేదా మొత్తం స్టాటిక్ క్లాస్ మెంబర్‌లను దిగుమతి చేసుకోవడానికి మిమ్మల్ని అనుమతిస్తుంది. స్టాటిక్ మెథడ్స్‌ని దిగుమతి చేసుకున్న తర్వాత, అదే క్లాస్‌లో డిక్లేర్ చేయబడినట్లుగా వాటిని యాక్సెస్ చేయవచ్చు. అదేవిధంగా, స్టాటిక్ ఫీల్డ్‌లను దిగుమతి చేయడం ద్వారా, మేము తరగతి పేరును పేర్కొనకుండానే వాటిని యాక్సెస్ చేయవచ్చు. ఈ ఫీచర్ జావా 1.5లో కనిపించింది మరియు సరిగ్గా ఉపయోగించినప్పుడు కోడ్ రీడబిలిటీని మెరుగుపరుస్తుంది. ఈ నిర్మాణం చాలా తరచుగా JUnit పరీక్షలలో కనుగొనబడింది, ఎందుకంటే దాదాపు అన్ని టెస్ట్ డెవలపర్‌లు స్థిరీకరణ పద్ధతుల కోసం స్టాటిక్ దిగుమతిని ఉపయోగిస్తారు, ఉదా assertEquals()మరియు వాటి ఓవర్‌లోడ్ వేరియంట్‌లు.

11. ఇప్పటికి ఇంతే. ప్రతి జావా ప్రోగ్రామర్ పైన పేర్కొన్న స్టాటిక్ మాడిఫైయర్ యొక్క అన్ని అంశాలను తెలుసుకోవాలి. ఈ కథనం స్టాటిక్ వేరియబుల్స్, ఫీల్డ్‌లు, పద్ధతులు, ఇనిషియలైజేషన్ బ్లాక్‌లు మరియు దిగుమతుల గురించి ప్రాథమిక సమాచారాన్ని సమీక్షించింది. ఇది జావా ప్రోగ్రామ్‌లను వ్రాయడానికి మరియు అర్థం చేసుకోవడానికి అవసరమైన కొన్ని ముఖ్యమైన లక్షణాలను కూడా తాకింది. ప్రతి డెవలపర్ వారి స్టాటిక్ మెంబర్‌లను నైపుణ్యంగా ఉపయోగించుకుంటారని నేను ఆశిస్తున్నాను, ఎందుకంటే ఇది తీవ్రమైన సాఫ్ట్‌వేర్ అభివృద్ధికి చాలా ముఖ్యమైనది."