जावा और पायथन में ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग: समानताएँ और अंतर

नमस्कार, हेब्र! मैं जॉन फिंचर के लेख "ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग इन पायथन बनाम जावा" का अनुवाद आपके सामने प्रस्तुत करता हूं।

जावा और पायथन में ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग (OOP) का कार्यान्वयन अलग है। वस्तुओं के प्रकार, चर के प्रकार और अन्य भाषा क्षमताओं के साथ काम करने का सिद्धांत एक भाषा से दूसरी भाषा में स्विच करने में कठिनाई पैदा कर सकता है। यह आलेख, जो जावा प्रोग्रामर के लिए उपयोगी हो सकता है, जो पायथन सीखना चाहते हैं, और पायथन प्रोग्रामर, जो जावा को बेहतर सीखना चाहते हैं, के लिए OOP के संबंध में इन भाषाओं के बीच मुख्य समानताएं और अंतर हैं।

अधिक विवरण - कटौती के तहत।

पायथन और जावा में वर्ग उदाहरण

शुरू करने के लिए, आइए इन भाषाओं के कुछ अंतरों को स्पष्ट करने के लिए पायथन और जावा में सबसे सरल वर्ग को लागू करें, और हम धीरे-धीरे इस वर्ग में बदलाव करेंगे।
कल्पना करें कि हमारे पास जावा में कार वर्ग की निम्नलिखित परिभाषा है:

1 public class Car { 2 private String color; 3 private String model; 4 private int year; 5 6 public Car(String color, String model, int year) { 7 this.color = color; 8 this.model = model; 9 this.year = year; 10 } 11 12 public String getColor() { 13 return color; 14 } 15 16 public String getModel() { 17 return model; 18 } 19 20 public int getYear() { 21 return year; 22 } 23 } 

स्रोत जावा फ़ाइल का नाम उसमें संग्रहीत वर्ग के नाम से मेल खाना चाहिए, इसलिए हमें फ़ाइल का नाम Car.java रखना चाहिए। प्रत्येक जावा फ़ाइल में केवल एक सार्वजनिक वर्ग हो सकता है।
पायथन में एक ही वर्ग इस तरह दिखेगा:

  1 class Car: 2 def __init__(self, color, model, year): 3 self.color = color 4 self.model = model 5 self.year = year 

पायथन में, आप कभी भी, कहीं भी एक वर्ग घोषित कर सकते हैं। इस फ़ाइल को car.py के रूप में सहेजें।
इन वर्गों को एक आधार के रूप में उपयोग करते हुए, हम कक्षाओं और वस्तुओं के मुख्य घटकों का अध्ययन जारी रखते हैं।

वस्तु गुण

सभी ऑब्जेक्ट-ओरिएंटेड भाषाओं में, ऑब्जेक्ट के बारे में डेटा कहीं स्टोर किया जाता है। पायथन और जावा दोनों में, यह डेटा विशेषताओं में संग्रहीत है, जो विशिष्ट वस्तुओं से जुड़े चर हैं।

पायथन और जावा के बीच सबसे महत्वपूर्ण अंतर यह है कि वे वर्ग और ऑब्जेक्ट विशेषताओं को कैसे परिभाषित करते हैं और ये भाषाएं उन्हें कैसे नियंत्रित करती हैं। इनमें से कुछ अंतर भाषाओं द्वारा लगाए गए प्रतिबंधों के कारण होते हैं, जबकि अन्य अधिक प्रभावी अभ्यास से जुड़े होते हैं।

घोषणा और प्रारंभ

जावा में, हम क्लास के अंदर, लेकिन सभी तरीकों के बाहर, विशेषताओं (उनके प्रकार का संकेत देते हुए) की घोषणा करते हैं। वर्ग विशेषताओं का उपयोग करने से पहले, हमें उन्हें परिभाषित करना चाहिए:

  1 public class Car { 2 private String color; 3 private String model; 4 private int year; 

पायथन में, हम इनिट () वर्ग की विधि के अंदर विशेषताओं को घोषित और परिभाषित करते हैं, जो कि जावा में कंस्ट्रक्टर का एक एनालॉग है:

  1 def __init__(self, color, model, year): 2 self.color = color 3 self.model = model 4 self.year = year 

चर नाम के सामने कीवर्ड स्व निर्दिष्ट करके, हम पायथन को बताते हैं कि ये विशेषताएँ हैं। कक्षा के प्रत्येक उदाहरण को इसकी प्रतिलिपि मिलती है। अजगर में सभी चर शिथिल टाइप नहीं हैं, और विशेषताएँ कोई अपवाद नहीं हैं।

चर भी init () विधि के बाहर बनाए जा सकते हैं, लेकिन यह सबसे अच्छा समाधान नहीं होगा और हार्ड-टू-डिटेक्ट बग का कारण बन सकता है। उदाहरण के लिए, आप कार ऑब्जेक्ट में एक नया पहियों विशेषता जोड़ सकते हैं:

  1 >>> import car 2 >>> my_car = car.Car("yellow", "beetle", 1967) 3 >>> print(f"My car is {my_car.color}") 4 My car is yellow 5 6 >>> my_car.wheels = 5 7 >>> print(f"Wheels: {my_car.wheels}") 8 Wheels: 5 

हालाँकि, यदि हम 6 पंक्ति में my_car.wheels = 5 की अभिव्यक्ति निर्दिष्ट करना भूल जाते हैं, तो हमें एक त्रुटि मिलती है:

  1 >>> import car 2 >>> my_car = car.Car("yellow", "beetle", 1967) 3 >>> print(f"My car is {my_car.color}") 4 My car is yellow 5 6 >>> print(f"Wheels: {my_car.wheels}") 7 Traceback (most recent call last): 8 File "<stdin>", line 1, in <module> 9 AttributeError: 'Car' object has no attribute 'wheels' 

पायथन में, यदि आप विधि के बाहर एक चर घोषित करते हैं, तो इसे एक वर्ग चर माना जाएगा। आइए कार की क्लास बदलें:

  1 class Car: 2 3 wheels = 0 4 5 def __init__(self, color, model, year): 6 self.color = color 7 self.model = model 8 self.year = year 

अब चर पहियों का उपयोग बदल जाएगा। किसी ऑब्जेक्ट के माध्यम से इसे एक्सेस करने के बजाय, हम इसे क्लास नाम का उपयोग करके एक्सेस करते हैं:

  1 >>> import car 2 >>> my_car = car.Car("yellow", "beetle", 1967) 3 >>> print(f"My car is {my_car.color}") 4 My car is yellow 5 6 >>> print(f"It has {car.Car.wheels} wheels") 7 It has 0 wheels 8 9 >>> print(f"It has {my_car.wheels} wheels") 10 It has 0 wheels 

नोट: पायथन में, एक वर्ग चर को निम्नलिखित सिंटैक्स का उपयोग करके एक्सेस किया जाता है:

1. वर्ग युक्त फ़ाइल का नाम (.py एक्सटेंशन के बिना)
2. बिंदु
3. वर्ग का नाम
4. बिंदु
5. चर नाम

चूँकि हमने Car.py फ़ाइल में Car क्लास को बचाया है, इसलिए हम इस तरह से 6th लाइन में व्हील्स क्लास वेरिएबल को देखें: car.Car.wheels।

पहियों के चर के साथ काम करते समय, आपको इस तथ्य पर ध्यान देने की आवश्यकता है कि my_car.wheels वर्ग के उदाहरण चर के मान को बदलने से कार के चर को बदलने की ओर नहीं जाता है। Car.wheels वर्ग:

  1 >>> from car import * 2 >>> my_car = car.Car("yellow", "Beetle", "1966") 3 >>> my_other_car = car.Car("red", "corvette", "1999") 4 5 >>> print(f"My car is {my_car.color}") 6 My car is yellow 7 >>> print(f"It has {my_car.wheels} wheels") 8 It has 0 wheels 9 10 >>> print(f"My other car is {my_other_car.color}") 11 My other car is red 12 >>> print(f"It has {my_other_car.wheels} wheels") 13 It has 0 wheels 14 15 >>> # Change the class variable value 16 ... car.Car.wheels = 4 17 18 >>> print(f"My car has {my_car.wheels} wheels") 19 My car has 4 wheels 20 >>> print(f"My other car has {my_other_car.wheels} wheels") 21 My other car has 4 wheels 22 23 >>> # Change the instance variable value for my_car 24 ... my_car.wheels = 5 25 26 >>> print(f"My car has {my_car.wheels} wheels") 27 My car has 5 wheels 28 >>> print(f"My other car has {my_other_car.wheels} wheels") 29 My other car has 4 wheels 

2 और 3 की तर्ज पर, हमने दो कार वस्तुओं को परिभाषित किया: my_car और my_other_car।
सबसे पहले, दोनों वस्तुओं के पहियों की संपत्ति शून्य है। 16 वीं पंक्ति में, हम वर्ग चर सेट करते हैं: car.Car.wheels = 4, दोनों वस्तुओं में अब 4 पहिए हैं। हालाँकि, तब जब 24 वीं पंक्ति में हम ऑब्जेक्ट की संपत्ति को बदलते हैं my_car.wheels = 5, दूसरी ऑब्जेक्ट की संपत्ति अछूती रहती है।

इसका मतलब है कि अब हमारे पास पहियों की दो अलग-अलग प्रतियां हैं:

1. वर्ग चर जो सभी कार वस्तुओं पर लागू होता है
2. एक विशिष्ट श्रेणी उदाहरण चर जो केवल my_car ऑब्जेक्ट पर लागू होता है।
   इस वजह से, आप गलती से गलत उदाहरण को संदर्भित कर सकते हैं और एक सूक्ष्म गलती कर सकते हैं।

जावा में, क्लास विशेषता के बराबर एक स्थिर विशेषता है:

 public class Car { private String color; private String model; private int year; private static int wheels; public Car(String color, String model, int year) { this.color = color; this.model = model; this.year = year; } public static int getWheels() { return wheels; } public static void setWheels(int count) { wheels = count; } } 

आमतौर पर हम जावा में स्थिर चर को वर्ग नाम के माध्यम से एक्सेस करते हैं। आप उन्हें कक्षा के एक उदाहरण के माध्यम से एक्सेस कर सकते हैं, जैसा कि पायथन में है, लेकिन यह सबसे अच्छा समाधान नहीं होगा।

हमारा जावा वर्ग लंबा होने लगा है। जावा के कारणों में से एक है "क्रिया" पायथन के लिए सार्वजनिक और निजी तरीकों और विशेषताओं की धारणा है।

सार्वजनिक और निजी

जावा सार्वजनिक और निजी डेटा के बीच अंतर करके विधियों और विशेषताओं तक पहुंच को नियंत्रित करता है।
जावा में, यह उम्मीद की जाती है कि विशेषताओं को निजी घोषित किया जाएगा (या संरक्षित, यदि वर्ग के वंशजों को उन तक पहुंच की आवश्यकता है)। इस प्रकार, हम बाहर से उन तक पहुंच को प्रतिबंधित करते हैं। निजी विशेषताओं तक पहुंच प्रदान करने के लिए, हम इस पद्धति को स्थापित करने या प्राप्त करने वाले सार्वजनिक तरीकों की घोषणा करते हैं (इस पर बाद में)।

याद रखें कि हमारे जावा कोड में, रंग चर को निजी घोषित किया गया था। इसलिए, नीचे दिया गया कोड संकलित नहीं होगा:

 Car myCar = new Car("blue", "Ford", 1972); // Paint the car myCar.color = "red"; 

यदि आप विशेषताओं तक पहुंच के स्तर को निर्दिष्ट नहीं करते हैं, तो डिफ़ॉल्ट रूप से इसे पैकेज संरक्षित के रूप में सेट किया जाएगा, जो पैकेज के भीतर कक्षाओं तक पहुंच को सीमित करता है। यदि हम उपरोक्त कोड को काम करना चाहते हैं, तो हमें विशेषता को सार्वजनिक करना होगा।

हालांकि, जावा को विशेषताओं को सार्वजनिक घोषित करने के लिए प्रोत्साहित नहीं किया जाता है। यह अनुशंसा की जाती है कि आप उन्हें निजी घोषित करें, और फिर getColor (और getModel) जैसी सार्वजनिक विधियों का उपयोग करें, जैसा कि ऊपर दिए गए कोड में बताया गया है।

इसके विपरीत, पायथन में सार्वजनिक और निजी डेटा की धारणा का अभाव है। अजगर में, सब कुछ सार्वजनिक है। यह अजगर कोड धमाके के साथ काम करेगा:

 >>> my_car = car.Car("blue", "Ford", 1972) >>> # Paint the car ... my_car.color = "red" 

पायथन में निजी चर के बजाय, गैर-सार्वजनिक ( गैर-सार्वजनिक ) वर्ग उदाहरण चर की अवधारणा है। सभी चर जिनके नाम एकल अंडरस्कोर से शुरू होते हैं, उन्हें गैर-सार्वजनिक माना जाता है। यह नामकरण सम्मेलन हमें चर को सीधे एक्सेस करने से नहीं रोकता है।

निम्नलिखित पंक्ति को हमारे पायथन क्लास कार में जोड़ें:

 class Car: wheels = 0 def __init__(self, color, model, year): self.color = color self.model = model self.year = year self._cupholders = 6 

हम सीधे _cupholders चर का उपयोग कर सकते हैं:

 >>> import car >>> my_car = car.Car("yellow", "Beetle", "1969") >>> print(f"It was built in {my_car.year}") It was built in 1969 >>> my_car.year = 1966 >>> print(f"It was built in {my_car.year}") It was built in 1966 >>> print(f"It has {my_car._cupholders} cupholders.") It has 6 cupholders. 

अजगर आपको इस तरह के एक चर का उपयोग करने की अनुमति देता है, हालांकि, कुछ विकास वातावरण जैसे वीएस कोड एक चेतावनी देगा:

इसके अलावा, पायथन एक विशेषता को छिपाने के लिए एक चर नाम की शुरुआत में एक डबल अंडरस्कोर का उपयोग करता है। जब पायथन इस तरह के एक चर को देखता है, तो यह सीधे पहुंच को मुश्किल बनाने के लिए अपने नाम को बदल देता है। हालाँकि, यह तंत्र अभी भी हमें इसे मोड़ने से नहीं रोकता है। हम इसे निम्न उदाहरण के साथ प्रदर्शित करते हैं:

 class Car: wheels = 0 def __init__(self, color, model, year): self.color = color self.model = model self.year = year self.__cupholders = 6 

अब यदि हम __cupenders चर को देखते हैं, तो हमें एक त्रुटि मिलती है:

 >>> import car >>> my_car = car.Car("yellow", "Beetle", "1969") >>> print(f"It was built in {my_car.year}") It was built in 1969 >>> my_car.year = 1966 >>> print(f"It was built in {my_car.year}") It was built in 1966 >>> print(f"It has {my_car.__cupholders} cupholders.") Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'Car' object has no attribute '__cupholders' 

तो __cupenders विशेषता मौजूद क्यों नहीं है?
ये रही बात। जब पायथन शुरुआत में एक डबल अंडरस्कोर विशेषता देखता है, तो यह शुरुआत में एक रेखांकित वर्ग नाम जोड़कर इसे बदल देता है। विशेषता को सीधे एक्सेस करने के लिए, आपको नाम भी बदलना होगा:

 >>> print(f"It has {my_car._Car__cupholders} cupholders") It has 6 cupholders 

अब सवाल उठता है: यदि जावा वर्ग की विशेषता को निजी घोषित किया जाता है और पायथन वर्ग की विशेषता को नाम में डबल अंडरस्कोर से पहले लिया जाता है, तो इस डेटा को कैसे प्राप्त करें?

अभिगम नियंत्रण

जावा में, हम बसने वालों और गेटर्स का उपयोग करके निजी विशेषताओं का उपयोग करते हैं। उपयोगकर्ता को अपनी मशीन को फिर से लिखने के लिए, जावा वर्ग के लिए निम्नलिखित कोड कोड जोड़ें:

 public String getColor() { return color; } public void setColor(String color) { this.color = color; } 

चूंकि getColor () और setColor () विधियां सार्वजनिक हैं, कोई भी उपयोगकर्ता उन्हें कॉल कर सकता है और मशीन के रंग को प्राप्त / बदल सकता है। निजी विशेषताओं का उपयोग, जिनके लिए हम सार्वजनिक गेटर्स और बसने वालों तक पहुंचते हैं, पायथन की तुलना में जावा की अधिक "वर्बोसिटी" के कारणों में से एक है।

जैसा कि ऊपर दिखाया गया है, पायथन में हम सीधे विशेषताओं तक पहुंच सकते हैं। चूंकि सब कुछ सार्वजनिक है, हम किसी भी समय, कभी भी, कहीं भी पहुंच सकते हैं। हम सीधे उनके नाम से कॉल करके विशेषता मान प्राप्त और सेट कर सकते हैं। पायथन में, हम उन विशेषताओं को भी हटा सकते हैं, जो जावा में अकल्पनीय है:

 >>> my_car = Car("yellow", "beetle", 1969) >>> print(f"My car was built in {my_car.year}") My car was built in 1969 >>> my_car.year = 1966 >>> print(f"It was built in {my_car.year}") It was built in 1966 >>> del my_car.year >>> print(f"It was built in {my_car.year}") Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'Car' object has no attribute 'year' 

हालाँकि, यह भी होता है कि हम विशेषताओं तक पहुँच को नियंत्रित करना चाहते हैं। इस मामले में, पायथन गुण हमारी सहायता के लिए आते हैं।

पायथन में, गुण सज्जाकारों का उपयोग करके वर्ग विशेषताओं को नियंत्रित पहुंच प्रदान करते हैं। गुणों का उपयोग करते हुए, हम जावा में गेटर्स और सेटर जैसे पायथन कक्षाओं में कार्यों की घोषणा करते हैं (विशेषताओं को हटाते हुए एक बोनस है)।

गुणों का संचालन कार वर्ग के निम्नलिखित उदाहरण में देखा जा सकता है:

  1 class Car: 2 def __init__(self, color, model, year): 3 self.color = color 4 self.model = model 5 self.year = year 6 self._voltage = 12 7 8 @property 9 def voltage(self): 10 return self._voltage 11 12 @voltage.setter 13 def voltage(self, volts): 14 print("Warning: this can cause problems!") 15 self._voltage = volts 16 17 @voltage.deleter 18 def voltage(self): 19 print("Warning: the radio will stop working!") 20 del self._voltage 

इस उदाहरण में, हम इलेक्ट्रिक कारों को शामिल करने के लिए कार वर्ग की अवधारणा का विस्तार करते हैं। लाइन 6 में बैटरी वोल्टेज को स्टोर करने के लिए _voltage विशेषता घोषित की गई है।

नियंत्रित पहुंच के लिए 9 और 10 की पंक्तियों में, हम वोल्टेज () फ़ंक्शन बनाते हैं और निजी चर के मूल्य को वापस करते हैं। @Property डेकोरेटर का उपयोग करके, हम इसे एक गटर में बदल देते हैं, जिसे अब कोई भी उपयोगकर्ता एक्सेस कर सकता है।

13-15 की पंक्तियों में, हम एक फ़ंक्शन को वोल्टेज () भी कहते हैं। हालांकि, हम इसे अलग तरह से सजाते हैं: वोल्टेज ।सेट्टर। अंत में, 18-20 की पंक्तियों में, हम वोल्टेज () फ़ंक्शन को वोल्टेज .deleter से सजाते हैं और यदि आवश्यक हो तो _voltage विशेषता को हटा सकते हैं।

सजाए गए कार्यों का एक ही नाम है, यह दर्शाता है कि वे एक ही विशेषता तक पहुंच को नियंत्रित करते हैं। ये फ़ंक्शन नाम उनके मान प्राप्त करने के लिए उपयोग की जाने वाली विशेषताओं के नाम भी बन जाते हैं। यहां बताया गया है कि यह कैसे काम करता है:

  1 >>> from car import * 2 >>> my_car = Car("yellow", "beetle", 1969) 3 4 >>> print(f"My car uses {my_car.voltage} volts") 5 My car uses 12 volts 6 7 >>> my_car.voltage = 6 8 Warning: this can cause problems! 9 10 >>> print(f"My car now uses {my_car.voltage} volts") 11 My car now uses 6 volts 12 13 >>> del my_car.voltage 14 Warning: the radio will stop working! 

कृपया ध्यान दें कि हम वोल्टेज का उपयोग करते हैं, _ वोल्टेज का नहीं। तो हम पायथन को उन गुणों को लागू करने के लिए कहते हैं जिन्हें यह केवल परिभाषित करता है:

• जब हम 4th लाइन में value my_car.voltage को प्रिंट करते हैं, तो Python @proproty से सजाए गए वोल्टेज () फ़ंक्शन को कॉल करता है।
• जब हम 7 पंक्ति में my_car.voltage मान प्रदान करते हैं, तो पायथन वोल्टेज () फ़ंक्शन को वोल्टेजसेट के साथ सजाया जाता है।
• जब हम my_car.voltage को पंक्ति 13 में हटाते हैं, तो Python वोल्टेज () फ़ंक्शन को कॉल करता है, जिसे .deleter से सजाया जाता है।

उपरोक्त सज्जाकार हमें विभिन्न तरीकों का उपयोग किए बिना विशेषताओं तक पहुंच को नियंत्रित करने की क्षमता प्रदान करते हैं। आप इस विशेषता को केवल सजाया हुआ @ .terter और @ .delele फ़ंक्शन को हटाकर केवल पढ़ने के लिए संपत्ति बना सकते हैं।

स्व और यह

जावा में, एक वर्ग इस कीवर्ड का उपयोग करते हुए खुद को संदर्भित करता है:

 public void setColor(String color) { this.color = color; } 

यह जावा कोड में निहित है। सिद्धांत रूप में, इसे लिखना भी आवश्यक नहीं है, सिवाय इसके कि जब चरों के नाम मेल खाते हैं।

सेटर को इस तरह लिखा जा सकता है:

 public void setColor(String newColor) { color = newColor; } 

चूंकि कार वर्ग में रंग नामक एक विशेषता होती है और स्कोप में एक ही नाम के साथ अधिक चर नहीं होते हैं, इसलिए इस नाम का लिंक चालू हो जाता है। हमने इस कीवर्ड का उपयोग पहले उदाहरण में एक ही रंग के नाम के साथ एक विशेषता और एक पैरामीटर के बीच अंतर करने के लिए किया था।

पायथन में, स्वयं कीवर्ड एक समान उद्देश्य प्रदान करता है: विशेषता सदस्यों तक पहुंच, लेकिन जावा के विपरीत, यह आवश्यक है :

 class Car: def __init__(self, color, model, year): self.color = color self.model = model self.year = year self._voltage = 12 @property def voltage(self): return self._voltage 

पायथन को अनिवार्य होने के लिए स्वयं की आवश्यकता होती है। प्रत्येक स्वयं या तो एक विशेषता बनाता है या संदर्भित करता है। यदि हम इसे छोड़ देते हैं, तो पायथन केवल एक विशेषता के बजाय एक स्थानीय चर बनाएगा।

जिस तरह से हम स्वयं का उपयोग करते हैं और यह पायथन और जावा में अंतर दो भाषाओं के बीच मुख्य अंतर और वे चर और विशेषताओं का नाम देने के तरीके के कारण है।

तरीके और कार्य

विचाराधीन भाषाओं के बीच अंतर यह है कि पायथन में फ़ंक्शन हैं, लेकिन जावा में वे नहीं हैं।

पायथन में, निम्न कोड समस्याओं के बिना काम करेगा (और हर जगह उपयोग किया जाता है):

 >>> def say_hi(): ... print("Hi!") ... >>> say_hi() Hi! 

हम दृश्यता में कहीं से say_hi () कॉल कर सकते हैं। इस फ़ंक्शन में स्वयं का संदर्भ नहीं होता है, जिसका अर्थ है कि यह एक वैश्विक फ़ंक्शन है, न कि क्लास फ़ंक्शन। वह किसी भी वर्ग के किसी भी डेटा को बदलने या सहेजने में सक्षम नहीं होगा, लेकिन वह स्थानीय और वैश्विक चर का उपयोग कर सकता है।

इसके विपरीत, जावा में हम जो भी लाइन लिखते हैं वह एक वर्ग की होती है। एक फ़ंक्शन कक्षा के बाहर मौजूद नहीं है, और परिभाषा के अनुसार, सभी जावा फ़ंक्शन विधि हैं। जावा में, शुद्ध कार्य के लिए निकटतम चीज एक स्थिर विधि है:

 public class Utils { static void SayHi() { System.out.println("Hi!"); } } 

Utils। SayHi () को यूटिल्स वर्ग के पहले उदाहरण के बिना कहीं से भी बुलाया जाता है। चूंकि हम SayHi () को एक ऑब्जेक्ट बनाए बिना कहते हैं, इसलिए यह लिंक मौजूद नहीं है। हालाँकि, यह अभी भी इस अर्थ में एक फ़ंक्शन नहीं है कि say_hi () पायथन में है।

वंशानुक्रम और बहुरूपता

विरासत और बहुरूपता OOP में दो मौलिक अवधारणाएं हैं। पहले के लिए धन्यवाद, ऑब्जेक्ट्स (दूसरे शब्दों में, विरासत में) अन्य वस्तुओं की विशेषताओं और कार्यक्षमता को प्राप्त करते हैं, जो सामान्य वस्तुओं से अधिक विशिष्ट लोगों तक पदानुक्रम बनाते हैं। उदाहरण के लिए, कार वर्ग और नाव वर्ग दोनों वाहन वर्ग के विशिष्ट प्रकार हैं। दोनों वस्तुओं में एक माता-पिता या कई मूल वस्तुओं का व्यवहार होता है। इस मामले में, उन्हें बाल वस्तु कहा जाता है।

बहुरूपता, बदले में, एक ही फ़ंक्शन या विधि का उपयोग करके विभिन्न वस्तुओं के साथ काम करने की क्षमता है।

इन दोनों ओओपी अवधारणाओं को जावा और पायथन में पूरी तरह से अलग तरीके से लागू किया गया है।

विरासत

पायथन मल्टीपल इनहेरिटेंस का समर्थन करता है, यानी एक से अधिक अभिभावकों से एक वर्ग बनाना।

इसे प्रदर्शित करने के लिए, हम कार वर्ग को दो श्रेणियों में विभाजित करते हैं: एक वाहनों के लिए और दूसरा बिजली का उपयोग करने वाली कारों के लिए:

 class Vehicle: def __init__(self, color, model): self.color = color self.model = model class Device: def __init__(self): self._voltage = 12 class Car(Vehicle, Device): def __init__(self, color, model, year): Vehicle.__init__(self, color, model) Device.__init__(self) self.year = year @property def voltage(self): return self._voltage @voltage.setter def voltage(self, volts): print("Warning: this can cause problems!") self._voltage = volts @voltage.deleter def voltage(self): print("Warning: the radio will stop working!") del self._voltage 

वाहन वर्ग रंग और मॉडल विशेषताओं को परिभाषित करता है। डिवाइस वर्ग में _voltage विशेषता है। कार वर्ग इन दो वर्गों से निकला है, और रंग, मॉडल और _ वोल्ट वोल्टेज विशेषताएँ अब नई कक्षा का हिस्सा हैं।

कार वर्ग की init () विधि दोनों मूल वर्गों के init () विधियों को कॉल करती है ताकि यह सुनिश्चित किया जा सके कि सभी डेटा को ठीक से आरंभ किया गया है। उसके बाद, हम कार वर्ग में कोई भी वांछित कार्यक्षमता जोड़ सकते हैं। इस उदाहरण में, हम वर्ष विशेषता जोड़ेंगे, साथ ही _voltage के लिए गेट्टर और सेटर भी।

नए कार वर्ग की कार्यक्षमता समान रहती है। हम क्लास ऑब्जेक्ट बना सकते हैं और उपयोग कर सकते हैं, जैसा कि हमने पहले कुछ उदाहरण दिए थे:

 >>> from car import * >>> my_car = Car("yellow", "beetle", 1969) >>> print(f"My car is {my_car.color}") My car is yellow >>> print(f"My car uses {my_car.voltage} volts") My car uses 12 volts >>> my_car.voltage = 6 Warning: this can cause problems! >>> print(f"My car now uses {my_car.voltage} volts") My car now uses 6 volts 

जावा भाषा, बदले में, केवल एकल वंशानुक्रम का समर्थन करती है, जिसका अर्थ है कि जावा में कक्षाएं केवल एक मूल वर्ग से डेटा और व्यवहार विरासत में प्राप्त कर सकती हैं। लेकिन जावा में, कई इंटरफेस से विरासत संभव है। इंटरफेस संबंधित तरीकों का एक समूह प्रदान करता है जिसे लागू करने की आवश्यकता होती है, जिससे बाल वर्ग एक समान तरीके से व्यवहार कर सकते हैं।

इसे देखने के लिए, हम कार जावा वर्ग को उसके मूल वर्ग और इंटरफ़ेस में विभाजित करते हैं:

 public class Vehicle { private String color; private String model; public Vehicle(String color, String model) { this.color = color; this.model = model; } public String getColor() { return color; } public String getModel() { return model; } } public interface Device { int getVoltage(); } public class Car extends Vehicle implements Device { private int voltage; private int year; public Car(String color, String model, int year) { super(color, model); this.year = year; this.voltage = 12; } @Override public int getVoltage() { return voltage; } public int getYear() { return year; } } 

यह मत भूलो कि जावा में प्रत्येक वर्ग और प्रत्येक इंटरफ़ेस को अपनी फ़ाइल में रखा जाना चाहिए।

उपरोक्त पायथन उदाहरण के रूप में, हम वाहनों में निहित सामान्य डेटा और कार्यक्षमता को संग्रहीत करने के लिए एक नया वाहन वर्ग बना रहे हैं। हालांकि, डिवाइस की कार्यक्षमता को जोड़ने के लिए, हमें एक इंटरफ़ेस बनाने की आवश्यकता है जो डिवाइस के वोल्टेज को प्राप्त करने के लिए विधि को परिभाषित करता है।

कार क्लास वाहन क्लास से निकाले गए कीवर्ड का उपयोग करके बनाया गया है और डिवाइस कीवर्ड को इम्प्लीमेंट कीवर्ड का उपयोग करके कार्यान्वित किया गया है। क्लास कंस्ट्रक्टर में, हम सुपर () के साथ पैरेंट कंस्ट्रक्टर को बुलाते हैं। चूंकि केवल एक मूल वर्ग है, हम वाहन वर्ग के निर्माता को देखें। इंटरफ़ेस को लागू करने के लिए, हम ओवरराइड एनोटेशन का उपयोग करके getVoltage () को फिर से परिभाषित करते हैं।

डिवाइस से कोड का पुन: उपयोग करने के बजाय, जैसा कि पायथन करता है, जावा को आवश्यकता है कि हम हर वर्ग में समान कार्यक्षमता लागू करें जो इंटरफ़ेस को लागू करता है। इंटरफेस केवल तरीकों को परिभाषित करते हैं - वे वर्ग उदाहरण डेटा या कार्यान्वयन विवरण को परिभाषित नहीं कर सकते हैं।

Java? .

Java . , Java- , , . , .

Java- charge(), Device. , Device, charge().

Rhino.java:

 public class Rhino { } 

Main.java charge() , Car Rhino.

 public class Main{ public static void charge(Device device) { device.getVoltage(); } public static void main(String[] args) throws Exception { Car car = new Car("yellow", "beetle", 1969); Rhino rhino = new Rhino(); charge(car); charge(rhino); } } 

    ,    : Information:2019-02-02 15:20 - Compilation completed with 1 error and 0 warnings in 4 s 395 ms Main.java Error:(43, 11) java: incompatible types: Rhino cannot be converted to Device 

Rhino Device, charge().

( — strict variable typing, , Python ) , Java, Python , : « , » ( : " , , , , " – . ). , Python .

Python:

 >>> def charge(device): ... if hasattr(device, '_voltage'): ... print(f"Charging a {device._voltage} volt device") ... else: ... print(f"I can't charge a {device.__class__.__name__}") ... >>> class Phone(Device): ... pass ... >>> class Rhino: ... pass ... >>> my_car = Car("yellow", "Beetle", "1966") >>> my_phone = Phone() >>> my_rhino = Rhino() >>> charge(my_car) Charging a 12 volt device >>> charge(my_phone) Charging a 12 volt device >>> charge(my_rhino) I can't charge a Rhino 

charge() _voltage. Device , - (Car Phone) , , , . , Device ( Rhino), , , , (rhino) .

Java Object, . , . Object :

 class Object { boolean equals(Object obj) { ... } int hashCode() { ... } String toString() { ... } } 

equals() , , hashCode() , . Java . , , , .

toString() . . , , , , System.out.println():

 Car car = new Car("yellow", "Beetle", 1969); System.out.println(car); 

car:

 Car@61bbe9ba 

, ? , toString(). Car:

 public String toString() { return "Car: " + getColor() + " : " + getModel() + " : " + getYear(); } 

, , :

 Car: yellow : Beetle : 1969 

Python (dunder — double underscore). Python- , , , .

Python : repr () str (). repr (), str () . hashcode() toString() Java.

Java, Python :

 >>> my_car = Car("yellow", "Beetle", "1966") >>> print(repr(my_car)) <car.Car object at 0x7fe4ca154f98> >>> print(str(my_car)) <car.Car object at 0x7fe4ca154f98> 

, str () Python- Car:

 def __str__(self): return f'Car {self.color} : {self.model} : {self.year}' 

:

 >>> my_car = Car("yellow", "Beetle", "1966") >>> print(repr(my_car)) <car.Car object at 0x7f09e9a7b630> >>> print(str(my_car)) Car yellow : Beetle : 1966 

. repr (), .

Python , , , .

Python . Python , Java .

Python- Car :

 class Car: def __init__(self, color, model, year): self.color = color self.model = model self.year = year def __str__(self): return f'Car {self.color} : {self.model} : {self.year}' def __eq__(self, other): return self.year == other.year def __lt__(self, other): return self.year < other.year def __add__(self, other): return Car(self.color + other.color, self.model + other.model, int(self.year) + int(other.year)) 

, :

Python , , , .

Car:

 >>> my_car = Car("yellow", "Beetle", "1966") >>> your_car = Car("red", "Corvette", "1967") >>> print (my_car < your_car) True >>> print (my_car > your_car) False >>> print (my_car == your_car) False >>> print (my_car + your_car) Car yellowred : BeetleCorvette : 3933 

, , , Java.

– . Java, Python .

. Python type() isinstance () , :

 >>> my_car = Car("yellow", "Beetle", "1966") >>> print(type(my_car)) <class 'car.Car'> >>> print(isinstance(my_car, Car)) True >>> print(isinstance(my_car, Device)) True 

Java getClass() instanceof :

 Car car = new Car("yellow", "beetle", 1969); System.out.println(car.getClass()); System.out.println(car instanceof Car); 

:

 class com.realpython.Car true 

Python dir() , ( ). , getattr():

 >>> print(dir(my_car)) ['_Car__cupholders', '__add__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_voltage', 'color', 'model', 'voltage', 'wheels', 'year'] >>> print(getattr(my_car, "__format__")) <built-in method __format__ of Car object at 0x7fb4c10f5438> 

Java , , , .

getFields() . , Car , :

 Field[] fields = car.getClass().getFields(); 

Java , getDeclaredMethods(). get-, , , :

1) getDeclaredMethods()
2) :

• true, :
• • get ;
  
  
• • void;
  
  
• • ;
  
  
• false.

:

  1 public static boolean getProperty(String name, Object object) throws Exception { 2 3 Method[] declaredMethods = object.getClass().getDeclaredMethods(); 4 for (Method method : declaredMethods) { 5 if (isGetter(method) && 6 method.getName().toUpperCase().contains(name.toUpperCase())) { 7 return true; 8 } 9 } 10 return false; 11 } 12 13 // Helper function to get if the method is a getter method 14 public static boolean isGetter(Method method) { 15 if ((method.getName().startsWith("get") || 16 method.getParameterCount() == 0 ) && 17 !method.getReturnType().equals(void.class)) { 18 return true; 19 } 20 return false; 21 } 

getProperty() – . . true, , false.

Java, Python .
Java- true , , . , getDeclaredMethods() Method. Method invoke(), Method. 7 true, , method.invoke(object).

Python. , Python , , :

 >>> for method_name in dir(my_car): ... if callable(getattr(my_car, method_name)): ... print(method_name) ... __add__ __class__ __delattr__ __dir__ __eq__ __format__ __ge__ __getattribute__ __gt__ __init__ __init_subclass__ __le__ __lt__ __ne__ __new__ __reduce__ __reduce_ex__ __repr__ __setattr__ __sizeof__ __str__ __subclasshook__ 

Python , Java. str () :

 >>> for method_name in dir(my_car): ... attr = getattr(my_car, method_name) ... if callable(attr): ... if method_name == '__str__': ... print(attr()) ... Car yellow : Beetle : 1966 

, dir(). , getattr(), callable(), . , , str (), .