Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रोग्रामिंग >> Java

Java Abstract Class: अमूर्त क्लासेस और मेथड्स गाइड

Java के "Abstract" क्लासेस और मेथड्स का उपयोग कैसे करें

Abstraction ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग में तीन मुख्य सिद्धांतों में से एक है - encapsulation और inheritance के साथ।

Abstraction आपके प्रोग्राम्स की जटिलता को कम करने और आपके कोड को पढ़ने में आसान बनाने का एक तरीका है। Java में, abstraction आपको अनुमति देता है:

  1. क्लास के केवल कुछ विवरण दिखाएं और
  2. उस क्लास के अन्य सभी विवरण छिपाएं।

Abstraction को Java में क्लासेस और मेथड्स दोनों पर लागू किया जा सकता है।

यह ट्यूटोरियल Java में abstraction की मूल बातें, abstract क्लासेस का उपयोग कैसे करें, और abstract मेथड्स का उपयोग कैसे करें, इस पर चर्चा करेगा। हम आपको इस महत्वपूर्ण अवधारणा को बेहतर ढंग से समझने में मदद करने के लिए कुछ उदाहरणों के माध्यम से भी चलेंगे।

Java Abstraction

ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग एक प्रकार की प्रोग्रामिंग है जो डेटा और मेथड्स को दर्शाने के लिए ऑब्जेक्ट्स और क्लासेस का उपयोग करती है। ऑब्जेक्ट्स और क्लासेस का उपयोग कोड में दोहराव को कम कर सकता है और प्रोग्राम्स को अधिक कुशल बना सकता है।

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

Java में दो उदाहरण हैं जहां abstraction का उपयोग किया जाता है: क्लासेस में और मेथड्स में।

Java Abstract क्लासेस

Java में, एक abstract क्लास वह क्लास है जिससे आप कोई ऑब्जेक्ट नहीं बना सकते। दूसरे शब्दों में, abstract क्लासेस को इंस्टेंशिएट नहीं किया जा सकता।

Java में abstract क्लास बनाने के लिए, आप abstract कीवर्ड का उपयोग कर सकते हैं। यहां Java में abstract क्लास का एक उदाहरण है:

abstract class BankAccount { // Code here }

चूंकि यह abstract क्लास है, यदि हम इस क्लास के साथ ऑब्जेक्ट बनाने का प्रयास करते हैं, तो हमारा प्रोग्राम त्रुटि लौटाएगा।

उदाहरण के लिए, मान लीजिए हम BankAccount नामक क्लास का इंस्टेंस बनाने का प्रयास करते हैं। हम इस इंस्टेंस को lucyAccount कहना चाहते हैं, और हम चाहते हैं कि यह लूसी की बैंक जानकारी स्टोर करे। लूसी हमारी ग्राहकों में से एक है। हम इस इंस्टेंस को बनाने का प्रयास करने के लिए निम्न कोड का उपयोग करते हैं:

BankAccount lucyAccount = new BankAccount();

जब हम इस कोड को चलाते हैं, हालांकि, हमारा प्रोग्राम लौटाता है:

BankAccount is abstract; cannot be instantiated

जैसा कि आप देख सकते हैं, आप abstract क्लासेस को ऑब्जेक्ट को असाइन नहीं कर सकते।

हालांकि, आप abstract क्लासेस से सबक्लासेस बना सकते हैं। अगले भाग में, हम चर्चा करते हैं कि abstract क्लासेस से सबक्लासेस कैसे बनाएं।

Abstract क्लास इनहेरिटेंस

जैसा कि हमने उल्लेख किया, आप ऑब्जेक्ट को abstract क्लास असाइन नहीं कर सकते। इसलिए, abstract क्लास की सामग्री तक पहुंचने के लिए - दूसरे शब्दों में, उस क्लास से जुड़े एट्रिब्यूट्स और मेथड्स - हमें क्लास को inherit करना होगा।

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

इस उदाहरण के लिए, BankAccount abstract क्लास है। हम केवल इसका उपयोग चेकिंग अकाउंट बनाने के लिए करना चाहते हैं।

यहां वह कोड है जिसका उपयोग हम अपने BankAccount और CheckingAccount क्लासेस के साथ काम करने के लिए कर सकते हैं:

abstract class BankAccount { public void viewAccountNumber() { System.out.println("Account number: #1932042"); } } class CheckingAccount extends BankAccount { } class Main { public static void main(String[] args) { CheckingAccount lucyAccount = new CheckingAccount(); lucyAccount.viewAccountNumber(); } }

हमारा कोड लौटाता है:

Account number: #1932042

इस उदाहरण में, हमने तीन क्लासेस बनाईं:

  1. BankAccount. यह abstract क्लास है। इसमें viewAccountNumber() नामक एक मेथड है। क्योंकि BankAccount abstract क्लास है, हम क्लास का ऑब्जेक्ट नहीं बना सकते।
  2. CheckingAccount. यह चाइल्ड क्लास है। चाइल्ड क्लास के रूप में, यह BankAccount क्लास के एट्रिब्यूट्स और मेथड्स को इनहेरिट करती है।
  3. Main. इस क्लास में हमारे मेन प्रोग्राम का कोड है।

हमारे मेन प्रोग्राम में, हम CheckingAccount क्लास का इंस्टेंस बनाते हैं और इसे lucyAccount कहते हैं। lucyAccount एक ऑब्जेक्ट है। हमारे प्रोग्राम में तीन क्लासेस बनाने के बाद, हमने viewAccountNumber() मेथड में lucyAccount ऑब्जेक्ट का उपयोग किया।

निम्न तालिका इस उदाहरण के प्रमुख भागों को सारांशित करती है:

NAME TYPE DESCRIPTION
BankAccount abstract/parent class बैंक अकाउंट के साथ काम करने के लिए एट्रिब्यूट्स और मेथड्स स्टोर करता है।
CheckingAccount child class पैरेंट क्लास के मेथड्स को इनहेरिट करता है।
Main class हमारे मेन प्रोग्राम का कोड समाहित करता है।
lucyAccount object हमारे प्रोग्राम का वास्तविक-विश्व एप्लिकेशन।

यदि आप Java में इनहेरिटेंस के बारे में अधिक जानने में रुचि रखते हैं, तो यहां हमारा पूरा गाइड पढ़ें।

Java Abstract मेथड्स

क्लासेस के अलावा, मेथड्स भी abstract हो सकते हैं।

जब आप abstract मेथड घोषित करते हैं, तो आप ऊपर की तरह ही abstract कीवर्ड का उपयोग करते हैं। आप कोई सामग्री निर्दिष्ट नहीं करते, और आप abstract मेथड को केवल abstract क्लास के भीतर घोषित कर सकते हैं।

यहां Java में abstract मेथड का एक उदाहरण है:

abstract void checkBalance();

इस उदाहरण में, हमने checkBalance() नामक abstract मेथड बनाया है। इस मेथड की कोई बॉडी नहीं है - दूसरे शब्दों में, मेथड से जुड़ा कोई कोड नहीं है।

आइए पहले के अपने बैंक उदाहरण पर लौटें। उस प्रोग्राम में एक abstract मेथड है: lucyAccount.viewAccountNumber();।

हमने इस abstract मेथड का उपयोग अपने प्रोग्राम को ग्राहक के बैंक अकाउंट नंबर प्रदर्शित करने में सक्षम बनाने के लिए किया। ऊपर के उदाहरण में (पिछले भाग से), BankAccount पैरेंट क्लास चाइल्ड क्लास(एस) के लिए एक प्रकार के टेम्पलेट के रूप में कार्य करती है।

इस मामले में, चाइल्ड क्लासेस विभिन्न प्रकार के बैंक अकाउंट्स हैं। ऐसा इसलिए है क्योंकि हमारे ग्राहकों के पास एक से अधिक प्रकार के बैंक अकाउंट हो सकते हैं, और हम प्रत्येक प्रकार के अकाउंट पर समान फंक्शन परफॉर्म करना चाह सकते हैं। ऊपर हमने जो चाइल्ड क्लास बनाई वह थी: CheckingAccount।

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

चूंकि हमने BankAccount पैरेंट क्लास बनाई, हम न्यूनतम कोड दोहराव के साथ कुशलतापूर्वक सभी तीन अकाउंट प्रकारों के अकाउंट नंबर प्रदर्शित कर सकते हैं।

नीचे दिए गए कोड में, हम abstract कीवर्ड का दो बार उपयोग करते हैं। पहले, हम abstract क्लास (BankAccount) घोषित करते हैं। फिर, हम abstract मेथड घोषित करते हैं जो बाद में प्रोग्राम को ग्राहक के अकाउंट नंबर(एस) प्रदर्शित करने का निर्देश देने में मदद करेगा। वह abstract मेथड घोषणा है: abstract void viewAccountNumber();। फिर हम CheckingAccount चाइल्ड क्लास पर viewAccountNumber() मेथड इनिशियलाइज़ करते हैं। यहां कोड है:

abstract class BankAccount { abstract void viewAccountNumber(); } class CheckingAccount extends BankAccount { public void viewAccountNumber() { System.out.println("Checking account number: #1932042"); } } class Main { public static void main(String[] args) { CheckingAccount lucyAccount = new CheckingAccount(); lucyAccount.viewAccountNumber(); } }

हमारा कोड लौटाता है:

Checking account number: #1932042

यह उदाहरण हमारे पहले के उदाहरण के समान आउटपुट लौटाता है, लेकिन कुछ कोड अंतर हैं जिन पर ध्यान देना चाहिए। वे हैं:

  1. Abstract मेथड की घोषणा। यहां उदाहरण में, हम BankAccount नामक abstract क्लास घोषित करते हैं। इस क्लास में viewAccountNumber() नामक abstract मेथड है।
  2. Abstract मेथड का विस्तार। हम CheckingAccount क्लास के माध्यम से BankAccount क्लास का विस्तार करते हैं। CheckingAccount क्लास BankAccount मेथड में स्टोर किए गए मानों को इनहेरिट करती है।

CheckingAccount क्लास में, हम viewAccountNumber() नामक मेथड परिभाषित करते हैं जो केवल CheckingAccount ऑब्जेक्ट्स के लिए सुलभ है। फिर, ग्राहक का अकाउंट नंबर देखने के लिए, हम CheckingAccount ऑब्जेक्ट बनाते हैं।

Java Abstraction उदाहरण

अब जब हमने Java abstract क्लासेस और abstract मेथड्स दोनों पर चर्चा कर ली है, तो हम Java में abstraction के पूर्ण उदाहरण का पता लगा सकते हैं। ऐसा करने के लिए, हम ऊपर चर्चा की गई हर चीज को एक साथ लाएंगे।

मान लीजिए हम एक बैंक संचालित कर रहे हैं जो दो प्रकार के बैंक अकाउंट्स प्रदान करता है: चेकिंग अकाउंट्स और सेविंग्स अकाउंट्स। हम एक प्रोग्राम लिखने का निर्णय लेते हैं जो बैंक अकाउंट होल्डर्स को उनके अकाउंट नंबर चेक करने की अनुमति देता है।

हमारे बैंक में, यदि बैंक अकाउंट चेकिंग अकाउंट है, तो अकाउंट नंबर ग्राहक के ID नंबर से शुरू होता है और 555 पर समाप्त होता है। यदि अकाउंट सेविंग्स अकाउंट है, तो अकाउंट नंबर 777 पर समाप्त होता है।

हम इस प्रोग्राम को बनाने के लिए निम्न कोड का उपयोग कर सकते हैं:

abstract class BankAccount { abstract void viewAccountNumber(); } class CheckingAccount extends BankAccount { public void viewAccountNumber() { System.out.println("Checking account number: #1932042555"); } } class SavingsAccount extends BankAccount { public void viewAccountNumber() { System.out.println("Savings account number: #1932042777"); } } class Main { public static void main(String[] args) { CheckingAccount ellieCheckingAccount = new CheckingAccount(); ellieCheckingAccount.viewAccountNumber(); SavingsAccount ellieSavingsAccount = new SavingsAccount(); ellieSavingsAccount.viewAccountNumber(); } }

हमारा कोड लौटाता है:

Checking account number: #1932042555 Savings account number: #1932042777

इस उदाहरण में, हमने एक क्लास बनाई और इसे BankAccount कहा। इस क्लास में एक abstract मेथड था, जिसे viewAccountNumber() कहा जाता है।

प्रत्येक प्रकार का अकाउंट अकाउंट नंबर्स को अलग तरह से असाइन करता है, इसलिए हम viewAccountNumber() मेथड को BankAccount क्लास में इम्प्लीमेंट नहीं कर सकते। इसके बजाय, BankAccount क्लास का प्रत्येक सबक्लास viewAccountNumber() मेथड को इम्प्लीमेंट करता है।

इस उदाहरण में, CheckingAccount क्लास अकाउंट नंबर्स को एक नंबर के रूप में असाइन करती है जो ग्राहक के ID से शुरू होता है और 555 पर समाप्त होता है। SavingsAccount क्लास अकाउंट नंबर्स को एक नंबर के रूप में असाइन करती है जो ग्राहक के ID से शुरू होता है और 777 पर समाप्त होता है।

हमारे कोड में, हम Ellie नामक ग्राहक के लिए CheckingAccount क्लास का इंस्टेंस इनिशियलाइज़ करते हैं। इस इंस्टेंस को ellieCheckingAccount नाम असाइन किया जाता है, और हम अकाउंट का नंबर देखने के लिए viewAccountNumber() मेथड इनवोक करते हैं। यह लौटाता है:

Checking account number: #1932042555

हम SavingsAccount क्लास का इंस्टेंस भी इनिशियलाइज़ करते हैं, जिसे ellieSavingsAccount कहा जाता है, और हम अकाउंट का नंबर देखने के लिए viewAccountNumber() मेथड इनवोक करते हैं। यह लौटाता है:

Savings account number: #1932042777

निष्कर्ष

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

इस ट्यूटोरियल ने उदाहरणों के साथ चर्चा की कि abstraction कैसे काम करता है, abstraction क्यों उपयोगी है, और आप Java में abstract मेथड्स और क्लासेस कैसे बना सकते हैं। अब आप एक प्रोफेशनल प्रोग्रामर की तरह Java में abstract क्लासेस और मेथड्स के साथ काम करना शुरू करने के लिए तैयार हैं!

  1. - Java में final कीवर्ड

    final Java एलिमेंट्स के लिए एक नॉन-एक्सेस मॉडिफायर है। final मॉडिफायर का उपयोग क्लासेज, मेथड्स और वेरिएबल्स के कार्यान्वयन को अंतिम रूप देने के लिए किया जाता है।Final Variablesएक final वेरिएबल को केवल एक बार स्पष्ट रूप से इनिशियलाइज़ किया जा सकता है। final घोषित एक रेफरेंस वेरिएबल को कभी भी किसी अलग

  1. - Java में super कीवर्ड

    super वेरिएबल तत्काल पैरेंट क्लास इंस्टेंस को संदर्भित करता है।super वेरिएबल तत्काल पैरेंट क्लास मेथड को इनवोक कर सकता है।super() तत्काल पैरेंट क्लास कंस्ट्रक्टर के रूप में कार्य करता है और चाइल्ड क्लास कंस्ट्रक्टर में पहली लाइन होनी चाहिए।ओवरराइडन मेथड के सुपरक्लास संस्करण को इनवोक करते समय super क

  1. - Java में Aggregation

    Aggregation HAS-A संबंध को संदर्भित करता है। आइए पहले उदाहरण देखें −उदाहरणpublic class Vehicle{} public class Speed{} public class Van extends Vehicle { private Speed sp; }यह दर्शाता है कि क्लास Van HAS-A Speed। Speed के लिए एक अलग क्लास होने से, हमें Van क्लास के अंदर स्पीड से संबंधित संपूर