स्थिर पद्धती

1. स्थिर पद्धती

स्टॅटिक व्हेरिएबल्स व्यतिरिक्त, क्लासेसमध्ये स्टॅटिक पद्धती देखील असू शकतात.

नियमित पद्धती वर्गाच्या वस्तूंशी (उदाहरणे) बांधील असतात आणि त्या वर्गाच्या सामान्य (नॉन-स्टॅटिक) व्हेरिएबल्सचा संदर्भ घेऊ शकतात (तसेच स्टॅटिक व्हेरिएबल्स आणि पद्धती ). स्टॅटिक पद्धती क्लासच्या स्टॅटिक ऑब्जेक्टशी बांधील आहेत आणि केवळ स्टॅटिक व्हेरिएबल्स आणि/किंवा क्लासच्या इतर स्टॅटिक पद्धतींमध्ये प्रवेश करू शकतात.

वर्गावर सामान्य (नॉन-स्टॅटिक) पद्धत कॉल करण्यासाठी, आपण प्रथम वर्गाचा ऑब्जेक्ट तयार केला पाहिजे आणि नंतर ऑब्जेक्टवर पद्धत कॉल केली पाहिजे. तुम्ही क्लासवर ऑब्जेक्ट ऐवजी सामान्य पद्धत कॉल करू शकत नाही.

उदाहरण:

public class DataInfo
{
   public int getValue()
   {
      return 100;
   }
}

public class Solution
{
   public static void main(String[] args)
   {
      System.out.println(DataInfo.getValue()); // This will generate an error!
   }
}

परंतु स्टॅटिक मेथड कॉल करण्यासाठी, क्लासचे स्टॅटिक ऑब्जेक्ट फक्त अस्तित्वात असणे पुरेसे आहे (आणि क्लास मेमरीमध्ये लोड केल्यानंतर ते नेहमी अस्तित्वात असते). म्हणूनच main() पद्धत स्थिर आहे. हे क्लासच्या स्थिर ऑब्जेक्टशी बांधील आहे, त्यामुळे तुम्हाला कॉल करण्यासाठी कोणतेही ऑब्जेक्ट तयार करण्याची आवश्यकता नाही.

मेथड स्टॅटिक घोषित करण्यासाठी, तुम्हाला मेथड हेडरच्या आधी स्टॅटिक कीवर्ड लिहावा लागेल. या बांधकामाचे सर्वसाधारण स्वरूप खालीलप्रमाणे आहे:

static Type name(parameters)
{
   method code
}

उदाहरणे:

public class Solution
{
   public static void main(String args[])
   {
      test();
   }

   public static void test()
   {
      int d = 2/0;
   }
}

दुसर्‍या क्लासमधून स्टॅटिक मेथड कॉल करण्यासाठी, तुम्हाला स्टॅटिक पद्धतीच्या नावापूर्वी क्लासचे नाव नमूद करावे लागेल. या बांधकामाचे सर्वसाधारण स्वरूप खालीलप्रमाणे आहे:

Type name = ClassName.methodName(arguments)

उदाहरणे:

int x = Math.min(a, b);

int min(int a, int b)

Thread.sleep(200);

void sleep(long ms)

Path path = Path.of("c:\\readme.txt");

Path of(String str)

2. स्थिर वि सामान्य (नॉन-स्टॅटिक) पद्धती

स्थिर पद्धती आणि सामान्य पद्धतींमध्ये काय फरक आहे?

एक सामान्य पद्धत एका सामान्य वस्तूला (वर्गाचा एक उदाहरण) बांधील आहे, तर स्थिर पद्धत नाही. एक सामान्य पद्धत व्हेरिएबल्समध्ये प्रवेश करू शकते, परंतु स्थिर पद्धत करू शकत नाही: त्यात फक्त संबंधित उदाहरण नाही.

दोन प्रकारच्या पद्धतींमधील फरक खालील सारणीमध्ये व्यक्त केला आहे:

जर त्या इतक्या कठोरपणे मर्यादित असतील तर अशा पद्धतींची गरज का आहे? उत्तर असे आहे की या पद्धतीचे त्याचे फायदे देखील आहेत.

प्रथम, स्टॅटिक पद्धती आणि व्हेरिएबल्समध्ये प्रवेश करण्यासाठी तुम्हाला कोणताही ऑब्जेक्ट संदर्भ पास करण्याची आवश्यकता नाही.

दुसरे, काहीवेळा तुम्हाला व्हेरिएबलचे फक्त एकच उदाहरण असणे आवश्यक आहे. उदाहरणार्थ, System.out( सिस्टम क्लासचे स्टॅटिक आउट व्हेरिएबल ).

आणि, तिसरे, काहीवेळा आपल्याला ऑब्जेक्ट्स तयार करणे शक्य होण्यापूर्वी पद्धत कॉल करणे आवश्यक आहे. उदाहरणार्थ, क्लासचे उदाहरण तयार होण्यापूर्वीच प्रोग्रामची अंमलबजावणी सुरू करण्यासाठी Java मशीन main() पद्धतीला कॉल करते.

वर्गाच्या उदाहरणाशी बांधील

जेव्हा एखादी सामान्य पद्धत कॉल केली जाते, तेव्हा एक युक्तिवाद — ज्या ऑब्जेक्टवर पद्धत कॉल केली जाते — त्यावर स्पष्टपणे पास केली जाते. या पॅरामीटरला म्हणतात this. हे अंतर्निहित पॅरामीटर (ज्या ऑब्जेक्टवर पद्धत म्हटले जाते त्याचा संदर्भ) सामान्य पद्धतींना स्थिर पद्धतींपासून वेगळे करते.

स्टॅटिक मेथड्समध्ये हे अंतर्निहित पॅरामीटर नसते, त्यामुळे तुम्ही thisस्टॅटिक मेथड्समध्ये कीवर्ड वापरू शकत नाही आणि तुम्ही स्टॅटिक पद्धतीमध्ये नॉन-स्टॅटिक मेथड कॉल करू शकत नाही. वर्गाच्या उदाहरणाचा संदर्भ मिळण्यासाठी कोठेही नाही.

वर्गाच्या सामान्य पद्धतींना कॉल करू शकता

सामान्य पद्धतीमध्ये नेहमीच अंतर्निहित thisपॅरामीटर असतो, म्हणून आपल्याकडे नेहमी त्या ऑब्जेक्टचा संदर्भ असतो ज्यावर पद्धत कॉल केली जाते. जेव्हा तुम्ही सामान्य पद्धतीला दुसर्‍या सामान्य पद्धतीमध्ये कॉल करता, तेव्हा thisतो कॉल करण्यासाठी अंतर्निहित पॅरामीटर वापरला जातो. उदाहरण

int min(int a, int b)
{
   return a < b ? a : b;
}

int min(int a, int b, int c)
{
   int t = min(a, b);
   return min(t, c);
}

int min(int a, int b)
{
   return a < b ? a : b;
}

int min(int a, int b, int c)
{
   int t = this.min(a, b);
   return this.min(t, c);
}

म्हणूनच आपण स्थिर पद्धतीवरून सामान्य पद्धत कॉल करू शकत नाही. thisस्टॅटिक पद्धतीमध्ये नाव दिलेले कोणतेही अंतर्निहित व्हेरिएबल नाही .

किंवा दुसर्‍या परिस्थितीची कल्पना करा: आमच्या प्रोग्राममध्ये आमच्या वर्गाची एकही वस्तू अद्याप तयार केलेली नाही. आपण आपल्या वर्गाची स्थिर पद्धत म्हणू शकतो का? होय. आणि या स्थिर पद्धतीला सामान्य (नॉन-स्टॅटिक) पद्धत म्हणता येईल का?

बरं, याला आपण कोणत्या वस्तू म्हणू? शेवटी, आमच्या वर्गाचे एकही उदाहरण अद्याप अस्तित्वात नाही!

वर्गाच्या स्थिर पद्धती कॉल करू शकता

स्टॅटिक पद्धती कुठूनही मागवल्या जाऊ शकतात — प्रोग्राममधील कोणत्याही ठिकाणाहून. याचा अर्थ असा की त्यांना स्थिर पद्धती आणि सामान्य दोन्हीमधून कॉल केले जाऊ शकते. येथे कोणतेही निर्बंध नाहीत.

वर्गाच्या सामान्य व्हेरिएबल्समध्ये प्रवेश करू शकतो

तुम्ही एका सामान्य पद्धतीने क्लासच्या सामान्य व्हेरिएबल्समध्ये प्रवेश करू शकता, कारण ते सहजपणे अंतर्निहित पॅरामीटरद्वारे वर्गाच्या उदाहरणाचा संदर्भ मिळवू शकते this.

स्टॅटिक मेथडला सामान्य व्हेरिएबल्सची व्हॅल्यू मिळवण्यासाठी क्लासचे कोणते उदाहरण वापरावे हे माहित नसते. आणि अधिक सामान्यपणे, आपल्याकडे अशी परिस्थिती सहज असू शकते जिथे स्थिर पद्धत कॉल केली जाते परंतु प्रोग्राममध्ये वर्गाचा एकही प्रसंग अद्याप तयार केलेला नाही.

परिणामी, स्थिर पद्धती वर्गाच्या सामान्य चलांमध्ये प्रवेश करू शकत नाहीत.

समजा स्टॅटिक मेथड एक सामान्य पद्धत कॉल करते. त्या सामान्य पद्धतीला कोणत्या वस्तूवर बोलावले पाहिजे?

कुणालाही माहित नाही! म्हणूनच आपण एखाद्या वस्तूचा संदर्भ न देता स्थिर पद्धतीवरून सामान्य पद्धत कॉल करू शकत नाही !

क्लासच्या स्थिर व्हेरिएबल्समध्ये प्रवेश करू शकतो

कॉल्स टू स्टॅटिक व्हेरिएबल्सची परिस्थिती स्टॅटिक पद्धतींच्या कॉल्ससारखीच असते. स्टॅटिक व्हेरिएबल्स प्रोग्राममध्ये कुठूनही ऍक्सेस करता येतात. याचा अर्थ असा की तुम्ही त्यांना स्थिर आणि सामान्य पद्धतींमधून प्रवेश करू शकता.

एखाद्या वस्तूवर कॉल केला जाऊ शकतो

ऑब्जेक्टवर स्थिर आणि सामान्य दोन्ही पद्धती कॉल केल्या जाऊ शकतात. एक सामान्य पद्धत कॉल शक्य आहे - खरंच, सामान्य पद्धत कॉल करण्याचा हा एकमेव मार्ग आहे. ऑब्जेक्टवर स्थिर पद्धत देखील कॉल केली जाऊ शकते: या प्रकरणात कंपाइलर स्वतः व्हेरिएबलचा प्रकार निर्धारित करतो आणि त्याच्या प्रकारावर आधारित स्थिर पद्धत कॉल करतो:

Thread th = Thread.current();
th.sleep(1000);

Thread th = Thread.current();
Thread.sleep(1000);

Integer i = 1;
int x = i.parseInt("12");

Integer i = 1;
int x = Integer.parseInt("12");

"".valueOf(12);

String.valueOf(12);

वर्गात बोलावता येईल

तुम्ही वर्गावर फक्त एक स्थिर पद्धत कॉल करू शकता. एक सामान्य पद्धत कॉल करण्यासाठी, तुम्हाला वर्गाच्या उदाहरणाचा संदर्भ आवश्यक आहे. म्हणून, आपण ही रचना वापरून सामान्य पद्धत कॉल करू शकत नाही:ClassName.methodName(arguments)