Animal
वर्ग आहे:
public class Animal {
String name;
int age;
}
आम्ही 2 बाल वर्ग घोषित करू शकतो: Cat
आणि Dog
. हे विस्तार कीवर्ड वापरून केले जाते .
public class Cat extends Animal {
}
public class Dog extends Animal {
}
आम्हाला हे भविष्यात उपयुक्त वाटू शकते. उदाहरणार्थ, उंदीर पकडण्याचे कार्य असल्यास, आम्ही Cat
आमच्या प्रोग्राममध्ये एक ऑब्जेक्ट तयार करू. जर काडीचा पाठलाग करणे हे कार्य असेल तर आपण ऑब्जेक्ट वापरू Dog
. आणि जर आम्ही पशुवैद्यकीय क्लिनिकचे अनुकरण करणारा प्रोग्राम तयार केला, तर तो वर्गासह कार्य करेल Animal
(आणि अशा प्रकारे मांजरी आणि कुत्री दोघांवरही उपचार करू शकेल). हे लक्षात ठेवणे फार महत्वाचे आहे की जेव्हा एखादी वस्तू तयार केली जाते तेव्हा त्याच्या बेस क्लासच्या कन्स्ट्रक्टरला प्रथम म्हणतात . तो कन्स्ट्रक्टर पूर्ण झाल्यावरच प्रोग्राम आपण तयार करत असलेल्या ऑब्जेक्टशी संबंधित क्लासचा कन्स्ट्रक्टर कार्यान्वित करतो. दुसऱ्या शब्दांत, एखादी Cat
वस्तू तयार करताना, कन्स्ट्रक्टर Animal
प्रथम चालविला जातो आणि त्यानंतरचCat
कन्स्ट्रक्टर अंमलात आला . हे पाहण्यासाठी, Cat
आणि Animal
कन्स्ट्रक्टरमध्ये काही कन्सोल आउटपुट जोडा.
public class Animal {
public Animal() {
System.out.println("Animal constructor executed");
}
}
public class Cat extends Animal {
public Cat() {
System.out.println("Cat constructor executed!");
}
public static void main(String[] args) {
Cat cat = new Cat();
}
}
कन्सोल आउटपुट: अॅनिमल कन्स्ट्रक्टर निष्पादित केले कॅट कन्स्ट्रक्टर कार्यान्वित! खरंच, ते अशा प्रकारे कार्य करते! का? दोन वर्गांमध्ये सामायिक केलेली फील्ड डुप्लिकेट करणे टाळणे हे एक कारण आहे. उदाहरणार्थ, प्रत्येक प्राण्याला हृदय आणि मेंदू असतो, परंतु प्रत्येक प्राण्याला शेपटी नसते. आम्ही मेंदू आणि हृदय क्षेत्र घोषित करू शकतो, जे सर्व प्राण्यांसाठी सामान्य आहेत, Animal
पालक वर्गात आणि उपवर्गात शेपटीचेCat
क्षेत्र . . आता आम्ही एक Cat
क्लास कन्स्ट्रक्टर घोषित करू जो सर्व 3 फील्डसाठी वितर्क घेतो.
public class Cat extends Animal {
String tail;
public Cat(String brain, String heart, String tail) {
this.brain = brain;
this.heart = heart;
this.tail = tail;
}
public static void main(String[] args) {
Cat cat = new Cat("Brain", "Heart", "Tail");
}
}
टीप: क्लासमध्ये Cat
मेंदू आणि हृदयाची फील्ड नसली तरीही कन्स्ट्रक्टर योग्यरित्या कार्य करतो . ही फील्ड Animal
बेस क्लास कडून "वारसा" मिळालेली आहेत. इनहेरिटिंग क्लासला बेस क्लासच्या फील्डमध्ये प्रवेश असतो , त्यामुळे ते आमच्या Cat
वर्गात दृश्यमान असतात. परिणामी, आम्हाला या फील्डची वर्गात डुप्लिकेट करण्याची आवश्यकता नाही Cat
. आम्ही त्यांना वर्गातून घेऊ शकतो Animal
. इतकेच काय, आम्ही स्पष्टपणे चाइल्ड क्लास कन्स्ट्रक्टरमध्ये बेस क्लास कन्स्ट्रक्टर म्हणू शकतो. बेस क्लासला " सुपरक्लास " असेही म्हणतात. म्हणूनच जावा बेस क्लास दर्शवण्यासाठी सुपर हा कीवर्ड वापरतो. मागील उदाहरणात
public Cat(String brain, String heart, String tail) {
this.brain = brain;
this.heart = heart;
this.tail = tail;
}
आम्ही आमच्या पालक वर्गात प्रत्येक फील्ड स्वतंत्रपणे नियुक्त केले. आम्हाला प्रत्यक्षात हे करण्याची गरज नाही. पालक वर्ग कन्स्ट्रक्टरला कॉल करणे आणि आवश्यक युक्तिवाद पास करणे पुरेसे आहे:
public class Animal {
String brain;
String heart;
public Animal(String brain, String heart) {
this.brain = brain;
this.heart = heart;
}
public class Cat extends Animal {
String tail;
public Cat(String brain, String heart, String tail) {
super(brain, heart);
this.tail = tail;
}
public static void main(String[] args) {
Cat cat = new Cat("Brain", "Heart", "Tail");
}
}
कन्स्ट्रक्टरमध्ये Cat
, आम्ही Animal
कन्स्ट्रक्टरला कॉल केला आणि दोन फील्ड पार केली. स्पष्टपणे प्रारंभ करण्यासाठी आमच्याकडे फक्त एक फील्ड आहे: tail , जे मध्ये नाही Animal
. लक्षात ठेवा आम्ही नमूद केले आहे की जेव्हा एखादी वस्तू तयार केली जाते तेव्हा पॅरेंट क्लास कन्स्ट्रक्टरला प्रथम कॉल केला जातो? म्हणूनच कन्स्ट्रक्टरमध्ये सुपर() नेहमी पहिले असावे! अन्यथा, कन्स्ट्रक्टर लॉजिकचे उल्लंघन केले जाईल आणि प्रोग्राम त्रुटी निर्माण करेल.
public class Cat extends Animal {
String tail;
public Cat(String brain, String heart, String tail) {
this.tail = tail;
super(brain, heart);// Error!
}
public static void main(String[] args) {
Cat cat = new Cat("Brain", "Heart", "Tail");
}
}
कंपायलरला माहीत आहे की जेव्हा चाइल्ड क्लासचा ऑब्जेक्ट तयार केला जातो तेव्हा बेस क्लास कन्स्ट्रक्टरला प्रथम कॉल केला जातो. आणि जर तुम्ही हे वर्तन व्यक्तिचलितपणे बदलण्याचा प्रयत्न केला, तर कंपाइलर त्याला परवानगी देणार नाही.
एखादी वस्तू कशी तयार होते
आम्ही पूर्वी आधार आणि पालक वर्गासह उदाहरण पाहिले:Animal
आणि Cat
. या दोन वर्गांचा उदाहरणे म्हणून वापर करून, आता आपण ऑब्जेक्ट तयार करण्याची आणि व्हेरिएबल्स सुरू करण्याची प्रक्रिया पाहू. आम्हाला माहित आहे की तेथे स्थिर आणि उदाहरण (नॉन-स्टॅटिक) व्हेरिएबल्स आहेत . आम्हाला हे देखील माहित आहे की Animal
बेस क्लासमध्ये व्हेरिएबल्स आहेत आणि Cat
चाइल्ड क्लासचे स्वतःचे आहे. स्पष्टतेसाठी, आम्ही Animal
आणि Cat
वर्गांमध्ये प्रत्येकी एक स्थिर व्हेरिएबल जोडू. वर्गातील animalCount व्हेरिएबल पृथ्वीवरील एकूणAnimal
प्राण्यांच्या प्रजातींचे प्रतिनिधित्व करेल आणि catCountव्हेरिएबल मांजरीच्या प्रजातींची संख्या दर्शवेल. याव्यतिरिक्त, आम्ही दोन्ही वर्गांमधील सर्व नॉन-स्टॅटिक व्हेरिएबल्ससाठी प्रारंभिक मूल्ये नियुक्त करू (जी नंतर कन्स्ट्रक्टरमध्ये बदलली जातील).
public class Animal {
String brain = "Initial value of brain in the Animal class";
String heart = "Initial value of heart in the Animal class";
public static int animalCount = 7700000;
public Animal(String brain, String heart) {
System.out.println("Animal base class constructor is running");
System.out.println("Have the variables of the Animal class already been initialized?");
System.out.println("Current value of static variable animalCount = " + animalCount);
System.out.println("Current value of brain in the Animal class = " + this.brain);
System.out.println("Current value of heart in the Animal class = " + this.heart);
System.out.println("Have the variables of the Cat class already been initialized?");
System.out.println("Current value of static variable catCount = " + Cat.catCount);
this.brain = brain;
this.heart = heart;
System.out.println("Animal base class constructor is done!");
System.out.println("Current value of brain = " + this.brain);
System.out.println("Current value of heart = " + this.heart);
}
}
public class Cat extends Animal {
String tail = "Initial value of tail in the Cat class";
static int catCount = 37;
public Cat(String brain, String heart, String tail) {
super(brain, heart);
System.out.println("The cat class constructor has started (The Animal constructor already finished)");
System.out.println("Current value of static variable catCount = " + catCount);
System.out.println("Current value of tail = " + this.tail);
this.tail = tail;
System.out.println("Current value of tail = " + this.tail);
}
public static void main(String[] args) {
Cat cat = new Cat("Brain", "Heart", "Tail");
}
}
म्हणून आम्ही वर्गाचे एक नवीन उदाहरण तयार करत आहोत Cat
, ज्याला वारसा मिळतो Animal
. काय होत आहे आणि कोणत्या क्रमाने आहे हे पाहण्यासाठी आम्ही काही तपशीलवार कन्सोल आउटपुट जोडले आहे. Cat
ऑब्जेक्ट तयार केल्यावर हे प्रदर्शित केले जाईल :अॅनिमल बेस क्लास कन्स्ट्रक्टर चालू आहे अॅनिमल क्लासचे व्हेरिएबल्स आधीच सुरू केले आहेत का? स्टॅटिक व्हेरिएबल एनिमल काउंट = 7700000 मेंदूचे सध्याचे मूल्य प्राणी वर्गातील मेंदूचे प्रारंभिक मूल्य प्राणी वर्गातील हृदयाचे वर्तमान मूल्य = प्राणी वर्गातील हृदयाचे प्रारंभिक मूल्य मांजर वर्गाचे व्हेरिएबल्स आधीपासूनच आहेत प्रारंभ केला आहे? स्टॅटिक व्हेरिएबलचे वर्तमान मूल्य catCount = 37 Animal base class constructor पूर्ण झाले! मेंदूचे सध्याचे मूल्य = मेंदूचे वर्तमान मूल्य हृदय = हृदय मांजरीचे वर्ग कंस्ट्रक्टर सुरू झाले आहे (अॅनिमल कन्स्ट्रक्टर आधीच पूर्ण झाले आहे) स्टॅटिक व्हेरिएबलचे वर्तमान मूल्य catCount = 37 शेपटीचे वर्तमान मूल्य = मांजरीच्या वर्गातील शेपटीचे प्रारंभिक मूल्य = शेपटीचे वर्तमान मूल्य शेपूट तर, आता आपण नवीन ऑब्जेक्ट तयार केल्यावर व्हेरिएबल इनिशिएलायझेशन आणि कन्स्ट्रक्टर कॉल्सचा क्रम स्पष्टपणे पाहू शकतो:
- बेस क्लासचे स्टॅटिक व्हेरिएबल्स (
Animal
) इनिशियलाइज केले जातात. आमच्या बाबतीत,Animal
वर्गाचे व्हेरिएबल animalCount 7700000 वर सेट केले आहे. -
चाइल्ड क्लासचे स्टॅटिक व्हेरिएबल्स (
Cat
) सुरू केले जातात.टीप: आम्ही अजूनही कन्स्ट्रक्टरमध्ये आहोत
Animal
आणि आम्ही आधीच प्रदर्शित केले आहे:अॅनिमल बेस क्लास कन्स्ट्रक्टर चालू आहे
अॅनिमल क्लासचे व्हेरिएबल्स आधीच सुरू केले आहेत का?
स्टॅटिक व्हेरिएबल एनिमल काउंट = 7700000
मेंदूचे सध्याचे मूल्य प्राणी वर्गातील मेंदूचे प्रारंभिक मूल्य प्राणी वर्गातील हृदयाचे
वर्तमान मूल्य = प्राणी वर्गातील हृदयाचे प्रारंभिक मूल्य मांजर वर्गाचे
व्हेरिएबल्स आधीपासूनच आहेत आरंभ केला आहे?
स्टॅटिक व्हेरिएबल catCount चे वर्तमान मूल्य = 37 -
नंतर बेस क्लासचे नॉन-स्टॅटिक व्हेरिएबल्स इनिशियलाइज केले जातात. आम्ही त्यांना विशेषत: प्रारंभिक मूल्ये नियुक्त केली, जी नंतर कन्स्ट्रक्टरमध्ये बदलली जातात. अॅनिमल कन्स्ट्रक्टर अद्याप पूर्ण झाले नाही, परंतु मेंदू आणि हृदयाची प्रारंभिक मूल्ये आधीच नियुक्त केली गेली आहेत:
अॅनिमल बेस क्लास कन्स्ट्रक्टर चालू आहे
अॅनिमल क्लासचे व्हेरिएबल्स आधीच सुरू केले आहेत का?
स्टॅटिक व्हेरिएबल एनिमल काउंट = 7700000
मेंदूचे सध्याचे मूल्य प्राणी वर्गात = प्राणी वर्गातील मेंदूचे प्रारंभिक मूल्य
प्राणी वर्गातील हृदयाचे वर्तमान मूल्य = प्राणी वर्गातील हृदयाचे प्रारंभिक मूल्य -
बेस क्लास कन्स्ट्रक्टर सुरू होतो.
आम्ही आधीच स्वतःला पटवून दिले आहे की ही पायरी चौथी आहे: कन्स्ट्रक्टरच्या सुरूवातीस पहिल्या तीन चरणांमध्येAnimal
, अनेक व्हेरिएबल्सना आधीच मूल्य नियुक्त केले आहे. -
चाइल्ड क्लास ( ) ची नॉन-स्टॅटिक फील्ड
Cat
सुरू केली आहेत. कन्स्ट्रक्टर चालू
होण्यापूर्वी हे घडते . जेव्हा ते चालू होते, तेव्हा टेल व्हेरिएबलमध्ये आधीपासूनच एक मूल्य असते:Cat
कॅट क्लास कन्स्ट्रक्टर सुरू झाला आहे (अॅनिमल कन्स्ट्रक्टर आधीच पूर्ण झाला आहे) स्टॅटिक व्हेरिएबल catCount चे वर्तमान मूल्य = 37 शेपटीचे वर्तमान मूल्य = मांजर वर्गातील शेपटीचे प्रारंभिक मूल्य
-
बाल वर्गाच्या रचनाकाराला
Cat
म्हणतातआणि जावामध्ये ऑब्जेक्ट तयार करणे असे दिसते!
मला असे म्हणायचे आहे की आम्ही रोट-लर्निंगचे मोठे चाहते नाही, परंतु व्हेरिएबल इनिशिएलायझेशन आणि कन्स्ट्रक्टर कॉलचा क्रम लक्षात ठेवणे चांगले आहे .
हे प्रोग्रामच्या प्रवाहाबद्दल आणि कोणत्याही विशिष्ट क्षणी आपल्या वस्तूंच्या स्थितीबद्दलची आपली समज मोठ्या प्रमाणात वाढवेल.
शिवाय, अनेक वर्ग वारसा वापरत नाहीत. या प्रकरणात, बेस क्लासशी संबंधित पायऱ्या लागू होत नाहीत.
अधिक वाचन: |
---|
GO TO FULL VERSION