java constructor class
यह ट्यूटोरियल जावा कंस्ट्रक्टर, इसके प्रकारों और अवधारणाओं जैसे कि कंस्ट्रक्टर ओवरलोडिंग और कोड उदाहरणों के साथ कंस्ट्रक्शन चाइनिंग पर चर्चा करेगा:
हमारे पहले के ट्यूटोरियल्स से, हम जानते हैं कि क्लास के उदाहरण को ऑब्जेक्ट कहा जाता है। 'नया' कीवर्ड का उपयोग करके एक वर्ग का एक ऑब्जेक्ट बनाया जाता है। एक विशेष विधि जिसे 'कंस्ट्रक्टर' कहा जाता है, जब हम एक नए कीवर्ड के साथ एक ऑब्जेक्ट बनाते हैं या जब ऑब्जेक्ट को त्वरित किया जाता है।
क्लास ऑब्जेक्ट को इनिशियलाइज़ करने के लिए एक कंस्ट्रक्टर को कोड के ब्लॉक के रूप में परिभाषित किया गया है। यह विधि के समान है लेकिन यह एक विधि नहीं है। हालाँकि, इसे जावा में एक 'विशेष विधि' कहा जा सकता है।
=> जावा प्रशिक्षण ट्यूटोरियल के ए-जेड को देखने के लिए यहां देखें।
आप क्या सीखेंगे:
- जावा कंस्ट्रक्टर
- निष्कर्ष
जावा कंस्ट्रक्टर
जावा कंस्ट्रक्टर का उपयोग अभी बनाई गई वस्तु को इनिशियलाइज़ करने के लिए किया जाता है। किसी ऑब्जेक्ट को प्रोग्राम में उपयोग करने से पहले कुछ डेटा होना चाहिए। इसलिए हम कंस्ट्रक्टर का उपयोग करते हैं ताकि हम ऑब्जेक्ट को कुछ प्रारंभिक डेटा असाइन कर सकें।
एक सरल उदाहरण के रूप में, एक वर्ग एबीसी पर विचार करें जिसके लिए हमें एक ऑब्जेक्ट बनाने की आवश्यकता है। कक्षा एबीसी के लिए एक नए कीवर्ड का उपयोग करके एक ऑब्जेक्ट 'myObj' बनाएं।
ABC myObj = new ABC ();उपरोक्त कथन एक ऑब्जेक्ट myObj बनाता है। जब यह ऑब्जेक्ट बनाया जा रहा है, तो बिना किसी तर्क के क्लास एबीसी के लिए एक कंस्ट्रक्टर को बुलाया जाता है (एबीसी) यह दर्शाता है कि कंस्ट्रक्टर के लिए कोई तर्क नहीं हैं)। जैसा कि उपर्युक्त कंस्ट्रक्टर के लिए कोई तर्क नहीं दिया गया है, myObj के सदस्य क्षेत्रों को उनके डिफ़ॉल्ट प्रारंभिक मानों से आरंभ किया जाएगा।
उदाहरण के लिए,
- आंतरिक डेटा प्रकार जैसे int 0 पर सेट हैं।
- चार डेटा प्रकार परिवर्तनशील मान शून्य (( 0) वर्ण पर सेट है।
- संदर्भ शून्य करने के लिए सेट किए गए हैं।
इस ट्यूटोरियल में, हम जावा में उपयोग किए जाने वाले विभिन्न निर्माणकर्ताओं के साथ विस्तार से चर्चा करेंगे।
जावा में एक कंस्ट्रक्टर कैसे बनाएं
जावा में एक कंस्ट्रक्टर बनाने के लिए, हमें नीचे दिए गए कुछ नियमों का पालन करना होगा।
- क्लास कंस्ट्रक्टर का वही नाम होता है जो क्लास का होता है।
- ऐसा कोई रचनाकार नहीं हो सकता जो अंतिम, सार, समकालिक या स्थिर हो। ऐसा इसलिए है क्योंकि अंतिम एक स्थिर के रूप में कार्य करता है, सार को तत्काल नहीं किया जा सकता है। जबकि मल्टी थ्रेडिंग के मामले में सिंक्रनाइज़ का उपयोग किया जाता है, और क्लास स्तर पर स्थिर कीवर्ड का उपयोग किया जाता है।
- हम कंस्ट्रक्टर्स के साथ एक्सेस मॉडिफायर का उपयोग कर सकते हैं।
- एक निर्माता के पास रिटर्न प्रकार नहीं हो सकता है।
उदाहरण के लिए,कक्षा के छात्र को इस प्रकार परिभाषित करें:
class Student{ String name; int roll_no; } हम नए कीवर्ड का उपयोग करके उपरोक्त वर्ग की वस्तुएँ बना सकते हैं। जबकि ऑब्जेक्ट बनाया जा रहा है, हम एक निर्माणकर्ता प्रदान करके इस वर्ग के दो-सदस्यीय चर को इनिशियलाइज़ कर सकते हैं। ध्यान दें कि भले ही हम एक निर्माता प्रदान नहीं करते हैं और बस नीचे दिए गए कथन को निष्पादित करते हैं,
छात्र छात्र = नया छात्र ();
फिर भी, जावा एक डिफ़ॉल्ट कंस्ट्रक्टर को निष्पादित करेगा जो दो-सदस्यीय चर को उनके सिस्टम डिफॉल्ट्स के लिए आरंभ करेगा। अब, यदि हम Student.name का प्रारंभिक मान 'कीथ' और रोल_नो 27 चाहते हैं, तो ऐसा करने के लिए हम निम्नलिखित कंस्ट्रक्टर विधि बना सकते हैं।
Student () { name = 'Keith'; roll_no = 27; } जब हम नीचे दिए गए कथन के साथ छात्र वर्ग की एक वस्तु बनाते हैं
Student student = new Student ();फिर सदस्य चर नाम और रोल_नो के प्रारंभिक मूल्य क्रमशः कीथ और 27 होंगे।
अब जब एक कंस्ट्रक्टर बनाया जाता है, तो उसे कब बुलाया जाएगा?
एक निर्माणकर्ता को हर बार कहा जाता है जब एक वस्तु को नए कीवर्ड के साथ उपरोक्त मामले में बनाया जाता है। जैसा कि पहले ही उल्लेख किया गया है, यदि कोई निर्माता प्रदान नहीं किया गया है, तो जावा एक डिफ़ॉल्ट निर्माणकर्ता प्रदान करता है जिसे तब कहा जाता है जब ऑब्जेक्ट नए कीवर्ड का उपयोग करके बनाया जाता है।
कंस्ट्रक्टर उदाहरण
निम्नलिखित कार्यक्रम एक निर्माता का उदाहरण दिखाता है जिसमें हमारे पास बिना किसी तर्क के एक साधारण निर्माता है। यह कंस्ट्रक्टर केवल अपने सदस्य चर के लिए प्रारंभिक मान प्रदान करता है।
//class definition class classDemo{ int num1; int num2; //constructor classDemo(){ num1 = 100; num2 = 250; System.out.println('Inside ClassDemo::Constructor'); } public void display(){ System.out.println('num1 = '+ num1); System.out.println('num2 = '+ num2); } } class Main{ public static void main(String args()){ classDemo cd1 = new classDemo(); //create object of ClassDemo cd1.display(); } }आउटपुट:
जावा में डिफ़ॉल्ट कंस्ट्रक्टर
डिफ़ॉल्ट कंस्ट्रक्टर को खाली कंस्ट्रक्टर भी कहा जाता है । यह कंस्ट्रक्टर जावा कंपाइलर द्वारा क्लास कोड में डाला जाता है जहां प्रोग्रामर द्वारा कोई कंस्ट्रक्टर लागू नहीं किया जाता है। डिफ़ॉल्ट कंस्ट्रक्टर को संकलन के दौरान डाला जाता है और इसलिए यह केवल ass .class ’फ़ाइल में दिखाई देगा और स्रोत कोड में नहीं।
निम्नलिखित जावा वर्ग पर विचार करें।
स्रोत फ़ाइल (.java) कक्षा फ़ाइल (.class)
उपरोक्त आंकड़े में, पहला आंकड़ा स्रोत कोड दिखाता है जिसमें हमने किसी भी निर्माता को निर्दिष्ट नहीं किया है। इसलिए जब हम इस कोड को संकलित करते हैं और .class फ़ाइल जेनरेट होती है, तो हम देख सकते हैं कि जावा कंपाइलर ने एक डिफ़ॉल्ट कंस्ट्रक्टर डाला है जैसा कि आसन्न आकृति (नीले रंग में) में दिखाया गया है।
ध्यान दें:
कभी-कभी जावा में नो-आर्ग कंस्ट्रक्टर का वर्णन करने के लिए एक डिफ़ॉल्ट कंस्ट्रक्टर का उपयोग किया जाता है। लेकिन वास्तविकता में ये दोनों शब्द अलग-अलग हैं। नो-आर्ग कंस्ट्रक्टर जावा में एक प्रकार का कंस्ट्रक्टर है जो प्रोग्रामर द्वारा निर्दिष्ट किया जाता है। डिफ़ॉल्ट कंस्ट्रक्टर वह कंस्ट्रक्टर है जिसे जावा कंपाइलर द्वारा डाला जाता है।
कंपनियों में सेलेनियम साक्षात्कार प्रश्न पूछे गए
इसलिए, हालांकि इन दो शब्दों का उपयोग अधिकतर प्रोग्रामर द्वारा किया जाता है, यह सलाह दी जाती है कि इन दो शब्दों को भ्रमित न करें।
जब जावा एक डिफ़ॉल्ट कंस्ट्रक्टर को सम्मिलित करता है, यदि प्रोग्राम में कोई चर है, तो उन्हें डिफ़ॉल्ट मान असाइन किए जाते हैं।
नीचे दी गई तालिका प्रत्येक डेटा प्रकार के डिफ़ॉल्ट मानों को दिखाती है।
| प्रकार | डिफ़ॉल्ट मान |
|---|---|
| char | u0000 |
| वस्तु | संदर्भ अशक्त |
| बूलियन | असत्य |
| बाइट | ० |
| कम | ० |
| पूर्णांक | ० |
| लंबा | 0 एल |
| नाव | 0.0f |
| दोहरा | 0.0 डी |
निम्न प्रोग्राम जावा में एक डिफॉल्ट कंस्ट्रक्टर का उदाहरण देता है।
class Main { int num; boolean flag; public static void main(String() args) { // A default constructor is called Main obj = new Main(); System.out.println('num:default value = ' + obj.num); System.out.println('flag:default value = ' + obj.flag); } }आउटपुट:
जावा में कंस्ट्रक्टर्स के प्रकार
जावा में दो प्रकार के निर्माणकर्ता हैं जैसा कि नीचे दिखाया गया है।
(1) नो-आर्ग कंस्ट्रक्टर
बिना किसी तर्क के एक निर्माणकर्ता को नो-आर्ग या नो-तर्क निर्माता कहा जाता है। यदि हमारे पास कोई तर्क के बिना एक कंस्ट्रक्टर नहीं है, तो जावा कंपाइलर क्लास के लिए डिफ़ॉल्ट कंस्ट्रक्टर नहीं बनाता है।
सामान्य तौर पर, यदि हम अपनी कक्षा में एक कंस्ट्रक्टर को परिभाषित करते हैं, तो जावा कंपाइलर द्वारा डिफॉल्ट कंस्ट्रक्टर नहीं डाला जाता है।
नीचे दिए गए नो-आर्ग कंस्ट्रक्टर का एक उदाहरण है
import java.io.*; class DemoClass { int num; String name; // no-args Constructor called when object is created DemoClass() { System.out.println('DemoClass::Constructor called'); System.out.println('Initial member variable values:'); System.out.println('num = ' + num + ' name = ' + name); } } class Main{ public static void main (String() args) { // this will invoke no-args Constructor DemoClass dc1 = new DemoClass(); } } आउटपुट:
इस कार्यक्रम में, हमने एक नो-आर्ग्स कंस्ट्रक्टर प्रदान किया है। यहां, हम सदस्य चर सहित कुछ संदेश मुद्रित करते हैं। हम आउटपुट में देख सकते हैं कि कंस्ट्रक्टर के संदेश यह दर्शाते हैं कि नो-आर्ग्स कंस्ट्रक्टर को निष्पादित किया गया है।
# 2) परिमापक संवाहक
एक पैरामीटर निर्मित निर्माता में एक या अधिक पैरामीटर होते हैं। यदि हम कक्षा के सदस्य चर के लिए कुछ प्रारंभिक मानों को पारित करने की आवश्यकता है, तो हम एक पैरामीटर निर्मित निर्माता का उपयोग कर सकते हैं।
import java.io.*; class DemoClass { // data members of the class. String name; int id; // parameterized constructor called when object is created DemoClass(String name, int id) { this.name = name; this.id = id; } } class Main { public static void main (String() args) { // this will invoke the parameterized constructor. DemoClass dc1 = new DemoClass('Java', 1); System.out.println('Tutorial Name :' + dc1.name + ', Id :' + dc1.id); } } आउटपुट:
यहां हमने एक पैरामीटर निर्मित कंस्ट्रक्टर प्रदान किया है जो दो तर्क लेता है यानी नाम और आईडी।
कंस्ट्रक्टर बॉडी के अंदर, तर्क क्रमशः सदस्य चर नाम और आईडी के मान के रूप में असाइन किए जाते हैं।
फिर मुख्य विधि में जब हम नए कीवर्ड का उपयोग करके एक नया ऑब्जेक्ट बनाते हैं, तो हम नए कीवर्ड के बाद क्लास के नाम से दो मान पास करते हैं। यह इंगित करता है कि हम पैरामीटर निर्मित निर्माता को बुला रहे हैं। जब हम सदस्य चर प्रदर्शित करते हैं, तो हम देख सकते हैं कि उनके पास वे मान हैं जो हमने ऑब्जेक्ट बनाते समय पारित किए थे।
जावा में ओवरलोडेड कंस्ट्रक्टर्स
अब सवाल यह उठता है कि क्या एक वर्ग में एक से अधिक कंस्ट्रक्टर हो सकते हैं या क्या यह है कि एक क्लास में केवल एक कंस्ट्रक्टर हो सकता है?
ठीक है, हमारे पास एक कक्षा में कई निर्माता हो सकते हैं। एक वर्ग के पास उतने ही निर्माता हो सकते हैं जब तक कि वे ठीक से ओवरलोडेड न हों।
तो कन्स्ट्रक्टर्स के ओवरलोडिंग से वास्तव में क्या मतलब है?
कन्स्ट्रक्टर ओवरलोडिंग एक ऐसा तंत्र है जो एक वर्ग को कई निर्माणकर्ताओं के रूप में अनुमति देता है, ताकि इन सभी निर्माणकर्ताओं के पास पैरामीटर प्रकार या मापदंडों के क्रम के आधार पर अलग-अलग पैरामीटर सूचियां हों।
नीचे दिए गए कार्यक्रम कन्स्ट्रक्टर ओवरलोडिंग को प्रदर्शित करते हैं।
//class with multiple constructors class DemoClass{ int val1; int val2; //no args Constructor DemoClass(){ val1 = 10; val2 = 20; System.out.println('DemoClass:: No argument Constructor'); } //Overloaded Constructor DemoClass(int num1){ val1 = num1; val2 = num1; System.out.println('DemoClass:: Overloaded Constructor with one argument'); } //Overloaded DemoClass(int num1,int num2){ val1 = num1; val2 = num2; System.out.println('DemoClass:: Overloaded Constructor with two arguments'); } public void display(){ System.out.println('val1 === '+val1 + ' ; val2 === '+val2 ); } } class Main{ public static void main(String args()){ DemoClass d1 = new DemoClass(); //object with no-args Constructor d1.display(); DemoClass d2 = new DemoClass(10); //object with 1 arg Constructor d2.display(); DemoClass d3 = new DemoClass(20,40); //object with 2 arg Constructor d3.display(); } }आउटपुट:
उपरोक्त कार्यक्रम में, हमारे पास एक क्लास है जिसमें तीन कंस्ट्रक्टर हैं। पहला कंस्ट्रक्टर एक नो-आर्ग कंस्ट्रक्टर है, और फिर हमारे पास क्रमशः एक तर्क और दो तर्क हैं। जैसा कि कंस्ट्रक्टर की एक अद्वितीय पैरामीटर सूची होती है, हम कह सकते हैं कि कंस्ट्रक्टर ओवरलोड हैं।
‘यह () जावा में कंस्ट्रक्टर
एक वर्ग में एक से अधिक कंस्ट्रक्टर होते हैं, अगर हम इस क्लास में किसी अन्य कंस्ट्रक्टर से एक कंस्ट्रक्टर को बुलाना चाहते हैं तो क्या होगा?
इस उद्देश्य के लिए, हम 'इस' शब्द का उपयोग उस निर्माणकर्ता के अंदर करते हैं, जहाँ से हम किसी अन्य निर्माता को कॉल करना चाहते हैं।
इसलिए जब एक क्लास में कई कंस्ट्रक्टर होते हैं, एक नो-आर्ग कंस्ट्रक्टर, और एक पैरामीटर कंस्ट्रक्टर होता है, तो हम नो-आर्ग्स कंस्ट्रक्टर से एक पैरामीटरेड कंस्ट्रक्टर को कॉल करने के लिए 'इस' कीवर्ड का उपयोग करते हैं। इसे भी कहा जाता है 'निर्माणकर्ता का स्पष्ट आह्वान'।
हमें इस कीवर्ड की आवश्यकता क्यों है?
हमें इसकी आवश्यकता है क्योंकि केवल निर्माणकर्ता के नाम का उपयोग करके सीधे निर्माणकर्ताओं का स्पष्ट आह्वान संभव नहीं है।
नोट करने के लिए अंक:
- कीवर्ड 'यह' कॉलिंग कंस्ट्रक्टर में पहला स्टेटमेंट होना चाहिए।
- यदि किसी कंस्ट्रक्टर के पास 'यह' कीवर्ड है, तो इसमें 'सुपर' नहीं हो सकता है। इसका मतलब यह है कि कंस्ट्रक्टर या तो सुपर हो सकता है या यह।
class TestClass { TestClass() { //calling Parameterized Constructor this('SoftwareTestingHelp'); System.out.println('TestClass::No-args Constructor'); } TestClass(String str) { System.out.println('TestClass:: Parameterized Constructor(String):' + str); } } class Main{ public static void main(String() args) { TestClass obj = new TestClass(); } }आउटपुट:
उपरोक्त कार्यक्रम में, हमारे पास दो निर्माणकर्ताओं के साथ एक 'टेस्टक्लास' है। हम इसे ('SoftwareTestingHelp') नो-आर्ग्स कंस्ट्रक्टर से कहते हैं। यह पैरामीटर निर्मित निर्माता का स्पष्ट आह्वान है।
जावा में कॉपी कंस्ट्रक्टर
हमें C ++ में कॉपी कंस्ट्रक्टर के बारे में पता है। कॉपी कंस्ट्रक्टर एक कंस्ट्रक्टर होता है जिसमें एक तर्क के रूप में एक ऑब्जेक्ट संदर्भ होता है और संदर्भ ऑब्जेक्ट के डेटा का उपयोग करके एक नया ऑब्जेक्ट बनाया जाता है।
यदि प्रोग्राम में कोई उपलब्ध नहीं है, तो C ++ एक डिफ़ॉल्ट कॉपी कंस्ट्रक्टर प्रदान करता है।
जावा कॉपी कंस्ट्रक्टर के लिए समर्थन भी प्रदान करता है, लेकिन यह एक डिफ़ॉल्ट कॉपी कंस्ट्रक्टर प्रदान नहीं करता है।
निम्नलिखित जावा प्रोग्राम वास्तविक और काल्पनिक घटकों वाले जटिल संख्याओं के क्लासिक उदाहरण का उपयोग करके प्रतिलिपि निर्माता को प्रदर्शित करता है।
class Complex { private double real, imaginary; // parametrized constructor public Complex(double real, double imaginary) { System.out.println('Complex:: parametrized constructor'); this.real = real; this.imaginary = imaginary; } // copy constructor Complex(Complex c) { System.out.println('Complex::Copy constructor called'); real = c.real; imaginary = c.imaginary; } // Overriding the toString of Object class @Override public String toString() { return '(' + real + ' + ' + imaginary + 'i)'; } } public class Main { public static void main(String() args) { Complex c1 = new Complex(1, 5); //calls parametrized constructor System.out.println('C1 = ' + c1); // copy constructor called Complex c2 = new Complex(c1); System.out.println('C2 = ' + c2); // this is a simple assignment operator Complex c3 = c2; } } आउटपुट:
उपरोक्त कार्यक्रम में एक ‘कॉम्प्लेक्स’ वर्ग है जिसमें एक पैरामीटर निर्माणकर्ता और एक प्रतिलिपि निर्माता है। पहले मुख्य विधि में, हम एक पैरामीटर निर्माणकर्ता का उपयोग करके ऑब्जेक्ट c1 बनाते हैं। फिर नीचे दिए गए कथन का उपयोग करते हुए,
Complex c2 = new Complex (c1); उपरोक्त कथन कॉपी कंस्ट्रक्टर को कॉल करता है क्योंकि रेफरेंस c1 को कंस्ट्रक्टर को पास किया जाता है जबकि एक नया ऑब्जेक्ट c2 बनाया जाता है।
जावा में कंस्ट्रक्टर चेनिंग
कंस्ट्रक्टर चेनिंग एक कंस्ट्रक्टर की एक प्रक्रिया है जो एक ही क्लास के दूसरे कंस्ट्रक्टर को बुलाती है।
यहां तक कि जब हमें बेस क्लास से विरासत में मिला होता है, तब बेस क्लास का कंस्ट्रक्टर पहले तब लागू किया जाता है जब चाइल्ड क्लास ऑब्जेक्ट बनाया जाता है। यह कंस्ट्रक्टर चेनिंग का भी एक उदाहरण है।
जावा में, दो तरीकों का उपयोग करके कंस्ट्रक्टर चेनिंग को प्राप्त किया जा सकता है:
- उसी वर्ग के भीतर : जब हम एक कंस्ट्रक्टर को एक ही क्लास के दूसरे कंस्ट्रक्टर से कॉल कर रहे हैं, तो हम इस () कीवर्ड का उपयोग कर सकते हैं।
- आधार वर्ग से: बेस क्लास के एक कंस्ट्रक्टर को सुपर कीवर्ड का उपयोग करके व्युत्पन्न वर्ग द्वारा बुलाया जा सकता है।
हमें कंस्ट्रक्टर चेनिंग की आवश्यकता क्यों है?
जब हम अपने कंस्ट्रक्टर में कई कार्य करना चाहते हैं, तो हम एक कंस्ट्रक्टर में प्रत्येक कार्य करने के बजाय, हम कई कंस्ट्रक्टरों में कार्यों को तोड़ते हैं, और फिर हम एक दूसरे से कंस्ट्रक्टरों को कॉल करते हैं, जिसके परिणामस्वरूप कंस्ट्रक्टर चेनिंग होता है।
नीचे दिए गए कुछ नियम हैं जिनका हमें कंस्ट्रक्टर चेनिंग करते समय पालन करने की आवश्यकता है।
- कन्स्ट्रक्टर चाइनिंग किसी भी क्रम में किया जाता है और वही परिणाम देगा।
- अभिव्यक्ति 'यह' कीवर्ड निर्माता में पहली अभिव्यक्ति होनी चाहिए।
- इस कीवर्ड के बिना हमारे पास कम से कम एक कंस्ट्रक्टर होना चाहिए।
जब हमारे कार्यक्रम में एक विरासत होती है, तो हम कंस्ट्रक्टर चाइनिंग भी कर सकते हैं। इस मामले में, उपवर्ग बेस क्लास के कंस्ट्रक्टर को कॉल करेगा। ऐसा करने से उपवर्ग वस्तुओं का निर्माण सुपरक्लास सदस्यों के आरंभ के साथ शुरू होता है।
अब हम उपर्युक्त दृष्टिकोणों का उपयोग करते हुए जावा में कंस्ट्रक्टर चाइनिंग को लागू करेंगे।
(1) कंस्ट्रक्टर चेनिंग द सेम क्लास
class DemoClass { // No args constructor DemoClass() { System.out.println('DemoClass::No args constructor'); } // parameterized constructor DemoClass(int val1) { // calls default constructor this(); System.out.println('DemoClass::Constructor with 1 argument: ' + val1); } // parameterized constructor DemoClass(int val1, int val2) { // invokes parameterized constructor with 1 argument this(5); System.out.print('DemoClass::constructor with 2 arguments:'); System.out.println('Product of 2 arguments = ' + val1 * val2); } } class Main{ public static void main(String args()) { // call parameterized constructor with 2 arguments new DemoClass(10, 15); } } आउटपुट:
जैसा कि पहले ही उल्लेख किया गया है, हम keyword इस ’कीवर्ड का उपयोग करके एक ही वर्ग के भीतर कंस्ट्रक्टर का निर्माण करते हैं उपरोक्त कार्यक्रम में, हमारे पास तीन कंस्ट्रक्टर हैं और हम keyword इस ’कीवर्ड का उपयोग करके एक कंस्ट्रक्टर को दूसरे से कहते हैं।
बेस क्लास से
जब एक वर्ग दूसरे वर्ग को विरासत में देता है, तब मूल वर्ग के निर्माता को पहले आमंत्रित किया जाता है, जब हम एक व्युत्पन्न वर्ग की एक वस्तु बनाते हैं, जो कंस्ट्रक्टर चेनिंग होता है।
यदि हम व्युत्पन्न वर्ग में बेस क्लास कंस्ट्रक्टर को स्पष्ट रूप से कॉल करना चाहते हैं, तो हमें इस उद्देश्य के लिए 'सुपर' कीवर्ड का उपयोग करना चाहिए। Ass सुपर ’कीवर्ड का उपयोग करके हम सुपरक्लास कंस्ट्रक्टर्स को उत्तराधिकार श्रेणी में तब तक कॉल कर सकते हैं जब तक हम सबसे ऊपरी वर्ग तक नहीं पहुंच जाते।
नीचे दिए गए कार्यक्रम में कंस्ट्रक्टर चेनिंग के लिए एक 'सुपर' कीवर्ड के उपयोग को दिखाया गया है।
class BaseClass { String name; // no args constructor BaseClass() { this(''); System.out.println('BaseClass::No-argument constructor'); } // Parameterized constructor BaseClass(String name) { this.name = name; System.out.println('BaseClass::Parameterized constructor'); } } class DerivedClass extends BaseClass { // No-argument constructor DerivedClass() { System.out.println('DerivedClass::No-argument constructor'); } // parameterized constructor DerivedClass(String name) { super(name); // invokes Parameterized constructor of BaseClass System.out.println('DerivedClass::Parameterized constructor'); } } class Main { public static void main(String args()) { // invokes DerivedClass parameterized constructor DerivedClass obj = new DerivedClass('Java'); } }आउटपुट:
उपरोक्त कार्यक्रम में, हम 'जावा' मान के साथ व्युत्पन्न वर्ग के पैरामीटरित निर्माता को लागू करते हैं। बदले में इस निर्माणकर्ता के पास 'सुपर (नाम);' का उपयोग करके बेस क्लास कंस्ट्रक्टर के लिए एक कॉल है; जो बेस क्लास के पैरामीटर किए गए कंस्ट्रक्टर को निष्पादित करता है।
बार बार पूछे जाने वाले प्रश्न
Q # 1) जावा में कंस्ट्रक्टर कैसे बनाते हैं?
उत्तर: हम एक विशेष विधि के रूप में एक निर्माता का निर्माण करते हैं जिसका वर्ग के नाम के समान नाम है। एक निर्माता के पास रिटर्न प्रकार भी नहीं हो सकता है। इसमें एक्सेस मॉडिफायर हो सकते हैं लेकिन यह अंतिम, स्टैटिक, एब्सट्रैक्ट या सिंक्रोनाइज़ नहीं हो सकता है।
अगर एबीसी एक वर्ग है, तो हम इसके निर्माता को परिभाषित कर सकते हैं
ABC(){} //no args constructor OR ABC(param1, param 2, …, param n) {} //parameterized constructorQ # 2) जावा में एक कंस्ट्रक्टर का लाभ क्या है?
उत्तर: कंस्ट्रक्टर का उपयोग करते हुए, हम कक्षा के सदस्यों को पहली चीज के रूप में आरंभ कर सकते हैं क्योंकि पल वस्तु बनाई जाती है। कंस्ट्रक्टर सामान्य तरीके से कॉल करने की आवश्यकता को समाप्त करता है।
हम कंस्ट्रक्टर में इनिशियलाइज़िंग, स्टार्टिंग टास्क आदि से संबंधित विभिन्न कार्य कर सकते हैं क्योंकि ऑब्जेक्ट क्रिएशन फेज के दौरान कंस्ट्रक्टर्स को इनवाइट किया जाता है।
Q # 3) कंस्ट्रक्टर्स का उपयोग क्यों किया जाता है?
उत्तर: कन्स्ट्रक्टर्स का उपयोग मुख्य रूप से क्लास के सदस्यों को इनिशियलाइज़ करने के लिए किया जाता है और इनवॉइस तब किया जाता है जब क्लास का ऑब्जेक्ट बनाया जाता है।
Q # 4) क्या कंस्ट्रक्टर प्राइवेट हो सकता है?
पीसी के लिए सबसे अच्छा ऑपरेटिंग सिस्टम क्या है
उत्तर: हां, हमारे पास एक निजी कंस्ट्रक्टर हो सकता है। जब कंस्ट्रक्टर निजी होता है, तो क्लास को तत्काल होने से रोका जा सकता है।
Q # 5) कंस्ट्रक्टर फाइनल हो सकता है?
उत्तर: नहीं, हमारे पास अंतिम कंस्ट्रक्टर नहीं हो सकता है।
निष्कर्ष
इस ट्यूटोरियल में, हमने जावा में कंस्ट्रक्टर्स पर अपनी चर्चा शुरू की है। हमने निर्माणकर्ता की मूल बातें, इसके निर्माण और पालन करने के नियमों को सीखा। हमने जावा में कॉपी कंस्ट्रक्टर्स पर भी चर्चा की।
डिफॉल्ट कंस्ट्रक्टर और प्रकार के कंस्ट्रक्टर और कॉन्सेप्ट जैसे कंस्ट्रक्टर ओवरलोडिंग और कंस्ट्रक्टर चेनिंग को उदाहरणों के साथ ब्रीफ किया गया। इन विषयों के एक भाग के रूप में, हमने निर्माणकर्ताओं में 'इस' कीवर्ड के उपयोग को भी देखा।
=> आसान जावा प्रशिक्षण श्रृंखला के माध्यम से पढ़ें।
अनुशंसित पाठ
- जावा क्लास बनाम ऑब्जेक्ट - जावा में क्लास और ऑब्जेक्ट का उपयोग कैसे करें
- जावा बेसिक्स: जावा सिंटैक्स, जावा क्लास और कोर जावा कॉन्सेप्ट
- जावा इंटेगर एंड जावा बिगइन्टेगर क्लास विद एग्जाम्पल्स
- उदाहरण के साथ जावा स्कैनर क्लास ट्यूटोरियल
- जावा ऐरे क्लास ट्यूटोरियल - java.util.Arays क्लास उदाहरण के साथ
- जावा वेक्टर क्या है | उदाहरणों के साथ जावा वेक्टर क्लास ट्यूटोरियल
- उदाहरण के साथ जावा इंटरफेस और एब्सट्रैक्ट क्लास ट्यूटोरियल
- जावा के साथ सेलेनियम वेबड्राइवर में रोबोट क्लास