आरंभ करणे

1. व्हेरिएबल्स सुरू करणे

तुम्हाला आधीच माहित आहे की, तुम्ही तुमच्या वर्गातील अनेक व्हेरिएबल्स घोषित करू शकता, आणि त्यांना फक्त घोषित करू शकत नाही, तर त्यांना त्यांच्या प्रारंभिक मूल्यांसह त्वरित प्रारंभ करू शकता.

आणि हेच व्हेरिएबल्स कन्स्ट्रक्टरमध्ये देखील सुरू केले जाऊ शकतात. याचा अर्थ असा की, सिद्धांतानुसार, या चलांना दोनदा मूल्ये नियुक्त केली जाऊ शकतात. उदाहरण

class Cat
{
   public String name;
   public int age = -1;

   public Cat(String name, int age)
   {
     this.name = name;
     this.age = age;
   }

   public Cat()
   {
     this.name = "Nameless";
   }
}

Cat cat = new Cat("Whiskers", 2);

Cat cat = new Cat();

अंमलात आणल्यावर असे होते Cat cat = new Cat("Whiskers", 2);:

• एक Catवस्तू तयार होते
• सर्व उदाहरण व्हेरिएबल्स त्यांच्या प्रारंभिक मूल्यांसह प्रारंभ केले जातात
• कन्स्ट्रक्टरला कॉल केला जातो आणि त्याचा कोड कार्यान्वित केला जातो.

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

2. वर्गातील व्हेरिएबल्सच्या प्रारंभाचा क्रम

कन्स्ट्रक्टर रन करण्यापूर्वी व्हेरिएबल्स केवळ इनिशियलाइज केले जात नाहीत - ते चांगल्या-परिभाषित क्रमाने सुरू केले जातात: ज्या क्रमाने ते वर्गात घोषित केले जातात.

चला काही मनोरंजक कोड पाहू:

public class Solution
{
   public int a = b + c + 1;
   public int b = a + c + 2;
   public int c = a + b + 3;
}

aहा कोड संकलित होणार नाही, कारण व्हेरिएबल तयार केले तेव्हा तेथे कोणतेही b आणि c व्हेरिएबल्स नाहीत. परंतु तुम्ही तुमचा कोड खालीलप्रमाणे लिहू शकता - हा कोड संकलित होईल आणि अगदी व्यवस्थित चालेल .

public class Solution
{
   public int a;
   public int b = a + 2;
   public int c = a + b + 3;
}

परंतु लक्षात ठेवा की तुमचा कोड इतर विकासकांसाठी पारदर्शक असणे आवश्यक आहे. अशा तंत्रांचा वापर न करणे चांगले आहे, कारण ते कोडची वाचनीयता बिघडवते.

येथे आपण हे लक्षात ठेवले पाहिजे की व्हेरिएबल्सला व्हॅल्यू नियुक्त करण्यापूर्वी त्यांना डीफॉल्ट मूल्य असते. प्रकारासाठी int, हे शून्य आहे.

जेव्हा JVM aव्हेरिएबल सुरू करते, तेव्हा ते फक्त int प्रकारासाठी डीफॉल्ट मूल्य नियुक्त करेल: 0.

जेव्हा ते पोहोचेल b, तेव्हा व्हेरिएबल आधीच ओळखले जाईल आणि त्याचे मूल्य असेल, म्हणून JVM त्याला मूल्य 2 नियुक्त करेल.

आणि जेव्हा ते cव्हेरिएबलपर्यंत पोहोचते, तेव्हा aआणि bव्हेरिएबल्स आधीच सुरू केले जातील, त्यामुळे JVM सहजपणे c: 0+2+3 साठी प्रारंभिक मूल्य मोजेल.

जर तुम्ही एखाद्या पद्धतीमध्ये व्हेरिएबल तयार केले, तर तुम्ही ते वापरु शकत नाही जोपर्यंत तुम्ही आधी मूल्य नियुक्त केले नाही. परंतु वर्गाच्या व्हेरिएबल्ससाठी हे खरे नाही! जर एखाद्या वर्गाच्या व्हेरिएबलला प्रारंभिक मूल्य नियुक्त केले नसेल, तर त्याला डीफॉल्ट मूल्य नियुक्त केले जाते.

3. स्थिरांक

ऑब्जेक्ट्स कसे तयार होतात याचे आम्ही विश्लेषण करत असताना, स्थिरांकांच्या सुरुवातीस स्पर्श करणे योग्य आहे, म्हणजे मॉडिफायरसह चल final.

व्हेरिएबलमध्ये सुधारक असल्यास final, प्रारंभिक मूल्य नियुक्त करणे आवश्यक आहे. तुम्हाला हे आधीच माहित आहे आणि यात आश्चर्य वाटण्यासारखे काहीच नाही.

पण तुम्हाला माहीत नाही ते म्हणजे तुम्ही जर कन्स्ट्रक्टरमध्ये असाइन केले तर तुम्हाला प्रारंभिक व्हॅल्यू लगेच नियुक्त करण्याची गरज नाही. हे अंतिम व्हेरिएबलसाठी चांगले कार्य करेल. फक्त आवश्यकता अशी आहे की जर तुमच्याकडे एकाधिक कन्स्ट्रक्टर असतील, तर अंतिम व्हेरिएबलला प्रत्येक कन्स्ट्रक्टरमध्ये एक मूल्य नियुक्त करणे आवश्यक आहे.

उदाहरण:

public class Cat
{
   public final int maxAge = 25;
   public final int maxWeight;

   public Cat (int weight)
   {
     this.maxWeight = weight; // Assign an initial value to the constant
   }
}

4. कन्स्ट्रक्टरमधील कोड

आणि कन्स्ट्रक्टरबद्दल आणखी काही महत्त्वाच्या टिपा. नंतर, तुम्ही जावा शिकत राहिल्यास, तुम्हाला वारसा, क्रमवारी, अपवाद इत्यादी गोष्टी आढळतील. त्या सर्व रचनाकारांच्या कामावर वेगवेगळ्या प्रमाणात प्रभाव टाकतात. आता या विषयांमध्ये खोलवर जाण्यात काही अर्थ नाही, परंतु किमान त्यांना स्पर्श करणे आम्हाला बंधनकारक आहे.

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

class FilePrinter
{
   public String content;

   public FilePrinter(String filename) throws Exception
   {
      FileInputStream input = new FileInputStream(filename);
      byte[] buffer = input.readAllBytes();
      this.content = new String(buffer);
   }

   public void printFile()
   {
      System.out.println(content);
   }
}

फाइलप्रिंटर क्लास कन्स्ट्रक्टरमध्ये, आम्ही फाइलवर लगेच बाइट स्ट्रीम उघडतो आणि त्यातील मजकूर वाचतो. हे गुंतागुंतीचे वर्तन आहे आणि त्यामुळे चुका होऊ शकतात.

अशी फाईल नसती तर? फाइल वाचण्यात समस्या आल्यास? जर ते खूप मोठे असेल तर?

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

उदाहरण 1 — अनुक्रमणिका

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

पण मग समजा तुमची फाईल इतर संगणकावर अस्तित्वात नाही. कन्स्ट्रक्टरमध्ये एक त्रुटी असेल आणि कोणीही ती हाताळणार नाही. आणि ते प्रोग्राम संपुष्टात आणण्यास सक्षम आहे.

उदाहरण २ — वर्गाची फील्ड आरंभ करणे

जर तुमचा क्लास कन्स्ट्रक्टर चेक केलेले अपवाद टाकू शकतो, म्हणजे थ्रो कीवर्डने चिन्हांकित केले असेल, तर तुम्ही तुमचा ऑब्जेक्ट तयार करणाऱ्या पद्धतीमध्ये सूचित अपवाद पकडले पाहिजेत.

पण अशी कोणतीही पद्धत नसल्यास काय? उदाहरण:

class Solution
{
   public FilePrinter reader = new FilePrinter("c:\\readme.txt");
}

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

5. बेस क्लास कन्स्ट्रक्टर

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

तुमच्या वर्गाला दुसर्‍या वर्गाचा वारसा मिळाल्यास, पालक वर्गाचा एक ऑब्जेक्ट तुमच्या वर्गाच्या ऑब्जेक्टमध्ये एम्बेड केला जाईल. इतकेच काय, पालक वर्गाचे स्वतःचे व्हेरिएबल्स आणि स्वतःचे कन्स्ट्रक्टर आहेत.

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

वर्ग

व्हेरिएबल्स कोणत्या क्रमाने सुरू होतात आणि कन्स्ट्रक्टर म्हणतात हे आपल्याला कसे कळेल? दोन वर्गांसाठी कोड लिहून सुरुवात करूया. एक दुसऱ्याला वारसा मिळेल:

class ParentClass
{
   public String a;
   public String b;

   public ParentClass()
   {
   }
}

class ChildClass extends ParentClass
{
   public String c;
   public String d;

   public ChildClass()
   {
   }
}

व्हेरिएबल्स कोणत्या क्रमाने सुरू केले जातात आणि कन्स्ट्रक्टर कॉल केले जातात हे आपल्याला निश्चित करणे आवश्यक आहे. लॉगिंग आम्हाला हे करण्यास मदत करेल.

लॉगिंग

लॉगिंग ही प्रोग्राम चालत असताना, कन्सोल किंवा फाइलवर लिहून केलेल्या क्रिया रेकॉर्ड करण्याची प्रक्रिया आहे.

कन्स्ट्रक्टरला कॉल केले गेले आहे हे निर्धारित करणे अगदी सोपे आहे: कन्स्ट्रक्टरच्या मुख्य भागामध्ये, कन्सोलवर संदेश लिहा. पण व्हेरिएबल इनिशियल केले आहे हे कसे सांगता येईल?

वास्तविक, हे देखील फार कठीण नाही: एक विशेष पद्धत लिहा जी व्हेरिएबल इनिशियलाइज करण्यासाठी वापरलेली व्हॅल्यू परत करेल आणि इनिशियलायझेशन लॉग करेल. हा कोड कसा दिसू शकतो:

अंतिम कोड

public class Main
{
   public static void main(String[] args)
   {
      ChildClass obj = new ChildClass();
   }

   public static String print(String text)
   {
      System.out.println(text);
      return text;
   }
}

class ParentClass
{
   public String a = Main.print("ParentClass.a");
   public String b = Main.print("ParentClass.b");

   public ParentClass()
   {
      Main.print("ParentClass.constructor");
   }
}

class ChildClass extends ParentClass
{
   public String c = Main.print("ChildClass.c");
   public String d = Main.print("ChildClass.d");

   public ChildClass()
   {
      Main.print("ChildClass.constructor");
   }
}

तुम्ही हा कोड कार्यान्वित केल्यास, स्क्रीनवर खालीलप्रमाणे मजकूर प्रदर्शित होईल:

ParentClass.a
ParentClass.b
ParentClass.constructor
ChildClass.c
ChildClass.d
ChildClass.constructor

त्यामुळे तुम्ही नेहमी वैयक्तिकरित्या खात्री करू शकता की कन्स्ट्रक्टरला कॉल करण्यापूर्वी क्लासचे व्हेरिएबल्स सुरू केले आहेत. इनहेरिटेड क्लासच्या इनिशियलायझेशनपूर्वी बेस क्लास पूर्णपणे इनिशियलाइज होतो.