कोड स्निपेट चलाने की सुविधा के लिए JShell जावा 9 में एक नई सुविधा है। JShell कोड स्निपेट ठीक उसी तरह हैं जैसे किसी एप्लिकेशन के लिए फ़ाइल में जावा स्रोत कोड। जैसा कि पहले के एक लेख में चर्चा की गई थी, "नेटबीन्स 9.0, भाग 3 में जावा 9 में JShell का उपयोग करना," JShell कई संशोधकों की अनुमति नहीं देता है - जिसमें डिफ़ॉल्ट, एक्सेस, सिंक्रनाइज़, सार्वजनिक, निजी और संरक्षित शामिल हैं - जो एक स्रोत कोड फ़ाइल में समर्थित हैं। . JShell को मुख्य रूप से जावा कोड के परीक्षण और डिबगिंग के लिए डिज़ाइन किया गया है न कि संपूर्ण एप्लिकेशन चलाने के लिए। इस निरंतरता लेख में, हम कक्षाओं, इंटरफेस और सरणियों के लिए स्निपेट चलाएंगे। हमने पहले के लेखों की तरह NetBeans 9 का उपयोग किया है। हम अनियंत्रित अपवादों पर भी चर्चा करेंगे। इस लेख में निम्नलिखित भाग हैं:
- कक्षाओं का उपयोग करना
- कक्षा को संशोधित करना
- सूचीबद्ध कक्षाएं
- क्लास कंस्ट्रक्टर्स का उपयोग करना
- कक्षा का विस्तार करना
- विधि ओवरराइड करना
- इंटरफ़ेस का उपयोग करना
- किसी विधि के लिए डिफ़ॉल्ट कार्यान्वयन का उपयोग करना
- इंटरफ़ेस विधि को स्थिर घोषित करना
- सरणी का उपयोग करना
- अनियंत्रित अपवादों का उपयोग करना
- निष्कर्ष
कक्षाओं का उपयोग करना
इस खंड में, हम कक्षाओं के लिए चल रहे कोड स्निपेट पर चर्चा करेंगे। एक साधारण वर्ग घोषित करें C इस प्रकार है।
[1]-> class C {
}
| created class C
कक्षा C बनाया जाता है। एक विधि के विपरीत जिसे सीधे लागू किया जा सकता है, एक वर्ग को पहले निम्नानुसार तत्काल किया जाना चाहिए।
[3]-> new C() | $1 ==> [email protected]
कक्षा का एक नया उदाहरण C, $1 बनाया जाता है। विधि घोषणाओं की तरह, वर्ग की घोषणाओं को कक्षा को फिर से घोषित करके संशोधित किया जा सकता है। एक वर्ग कार्यान्वयन . का उपयोग करके एक इंटरफ़ेस लागू कर सकता है . एक उदाहरण के रूप में, एक इंटरफ़ेस घोषित करें I ।
[1]-> interface I{}
| created interface I
क्लास बनाएं C इंटरफ़ेस को लागू करने के लिए I ।
[3]-> class C implements I{}
| replaced class C
[4]->
. को बदला गया कक्षा C , पहले बनाया गया, बदल जाता है।
JShell में एक क्लास डिक्लेरेशन में किसी एप्लिकेशन की अवधारणा नहीं होती है जैसा कि किसी फ़ाइल में घोषित जावा क्लास में होता है। सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] argv) . के साथ फ़ाइल में एक जावा वर्ग विधि एक जावा अनुप्रयोग है। सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] argv) विधि JShell में जोड़ी जा सकती है लेकिन यह सिर्फ एक और कोड स्निपेट है। एक क्लास बनाएं नमस्ते जिसमें विधि शामिल है सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] argv) ।
[1]-> class Hello{
public static void main(String[] argv){System.out.println
(argv[0]+argv[1]);}
}
| created class Hello
[2]->
मुख्य(स्ट्रिंग[]) विधि एक स्थिर . है विधि और कक्षा के उदाहरण के बजाय कक्षा के लिए परिभाषित किया गया है। एक स्ट्रिंग[]बनाएं मुख्य(स्ट्रिंग[]) . को आपूर्ति करने के लिए सरणी विधि।
String[] strArray={"Hello"," JShell"}; मुख्य(स्ट्रिंग[]) . को आमंत्रित करें स्ट्रिंग[] . के साथ विधि एक तर्क के रूप में।
Hello.main(strArray)
एक हेलो JShell संदेश आउटपुट प्राप्त करता है, जैसा कि चित्र 1 में दिखाया गया है।
चित्र 1: कक्षा में स्थिर विधि को लागू करना
कक्षा को संशोधित करना
किसी भी विधि घोषणा को संशोधित या हटाकर या नई विधियों को जोड़कर एक वर्ग को आवश्यकतानुसार संशोधित किया जा सकता है। कक्षा को फिर से घोषित करें नमस्कार बिना मुख्य(स्ट्रिंग[]) विधि और वर्ग बदल जाता है।
[4]-> class Hello{
}
| replaced class Hello
[5]->
मुख्य(स्ट्रिंग[]) को फिर से जोड़ें विधि लेकिन थोड़ी भिन्न System.out.println . के साथ बयान। कक्षा नमस्कार फिर से बदल दिया जाता है।
[5]-> class Hello{
public static void main(String[] argv)
{System.out.println(argv[0]);}
}
| replaced class Hello
[5]->
स्थिर . का आह्वान करें विधि मुख्य(स्ट्रिंग[]) Hello.main(strArray) . के साथ एक अलग आउटपुट के लिए, जैसा कि चित्र 2 में दिखाया गया है।
चित्र 2: मुख्य विधि के रूपांतर को लागू करना
एक वर्ग को विकसित करते समय एक वर्ग को बदलने का प्रावधान उपयोगी होता है। एक समय में एक विधि जोड़ी जा सकती है और कक्षा का परीक्षण किया जा सकता है। उदाहरण के तौर पर, दूसरी विधि जोड़ें hello(String) . फिर से, कक्षा नमस्कार बदल दिया जाता है।
[9]-> class Hello{
void main(String[] argv){System.out.println(argv[0]);}
String hello(String name){return name;}
}
| replaced class Hello
विधि hello(String) जोड़ा गया, एक उदाहरण विधि होने के नाते, आह्वान करने के लिए एक वर्ग उदाहरण की आवश्यकता होगी। एक क्लास इंस्टेंस बनाएं।
[10]-> new Hello() | $2 ==> [email protected]
आह्वान विधि hello(String) क्लास इंस्टेंस का उपयोग करना $2 ।
[11]-> $2.hello("John")
| $6 ==> "John"
सूचीबद्ध कक्षाएं
एक जावा वर्ग एक प्रकार है। एक इंटरफ़ेस भी एक प्रकार है। JShell सत्र में परिभाषित सभी प्रकार /types . के साथ सूचीबद्ध हैं आज्ञा। कुछ वर्गों और इंटरफेस को परिभाषित करें।
[4]-> [1]-> class C{}
| created class C
[2]-> class D{}
| created class D
[3]-> class B{}
| created class B
[4]-> interface I{}
| created interface I
[5]-> interface J{}
| created interface J
/प्रकार चलाएं कमांड और सभी वर्ग और इंटरफेस सूचीबद्ध हो जाते हैं।
[6]-> /types | class C | class D | class B | interface I | interface J
क्लास कंस्ट्रक्टर्स का उपयोग करना
नो-आर्ग क्लास को एक क्लास में परोक्ष रूप से परिभाषित किया जाता है यदि यह किसी भी कंस्ट्रक्टर को आर्ग्स के साथ परिभाषित नहीं करता है। हमने पहले एक क्लास C . को इंस्टेंट किया था जिसने किसी भी कंस्ट्रक्टर को स्पष्ट रूप से new C() . के साथ घोषित नहीं किया . नो-आर्ग कंस्ट्रक्टर को स्पष्ट रूप से परिभाषित किया जा सकता है।
इसके बाद, एक क्लास बनाएं Hello जो एक क्लास कंस्ट्रक्टर घोषित करता है। कंस्ट्रक्टर के पास एक प्रकार का पैरामीटर होता है String . कंस्ट्रक्टर को सार्वजनिक . के साथ घोषित किया जा सकता है संशोधक और परोक्ष रूप से सार्वजनिक . है अगर सार्वजनिक . पर सेट नहीं है ।
[6]->
class Hello{
String name;
public Hello(String name){this.name=name;}
void hello(){System.out.println("Hello "+name);}
}
कक्षा का एक उदाहरण बनाएं नमस्ते ।
Hello hello=new Hello("John") इंस्टेंस विधि hello() को कॉल करें संदेश को आउटपुट करने के लिए, जैसा कि चित्र 3 में दिखाया गया है।
चित्र 3: कंस्ट्रक्टर के साथ क्लास का उपयोग करना
कक्षा का विस्तार करना
एक वर्ग को जावा स्रोत कोड फ़ाइल की तरह ही विस्तारित किया जा सकता है। उदाहरण के तौर पर, क्लास D . बनाएं जो tt>String, एक नो-आर्ग कंस्ट्रक्टर और एक विधि hello(String) के चर नाम की घोषणा करता है। . नमस्ते(स्ट्रिंग) विधि एक "Hello" . आउटपुट करती है नाम . का उपयोग कर संदेश आपूर्ति की गई तर्क।
class D{
String name="Michael";
public D(){}
void hello(String name){System.out.println("Hello "+name);}
}
एक वर्ग बनाएं C जो कक्षा C . का विस्तार करता है और hello() . की घोषणा करता है विधि, जो वर्ग D . को ओवरराइड नहीं करती है नमस्ते(स्ट्रिंग) विधि और पैरामीटर अलग हैं। नमस्ते () विधि एक फ़ील्ड नाम का आह्वान करती है, जो कक्षा D . से विरासत में मिली है ।
class C extends D{
void hello(){System.out.println("Hello "+name);}
}
इंस्टैंटियेट क्लास C और hello() . का आह्वान करें विधि।
new C().hello()
एक "हैलो" संदेश आउटपुट प्राप्त करता है, जैसा कि चित्र 4 में दिखाया गया है। नाम D . वर्ग में फ़ील्ड मान सेट उपयोग किया जाता है।
चित्र 4: कक्षा का विस्तार करना
अगर हम hello(String) . का आह्वान करते हैं विधि उस वर्ग C D . वर्ग से विरासत में मिला है , हमें एक अलग आउटपुट मिलेगा, जैसा कि चित्र 5 में दिखाया गया है।
चित्र 5: एक विस्तारित कक्षा से विरासत में मिली विधि को लागू करना
किसी विधि को ओवरराइड करना
एक वर्ग अपनी स्वयं की विधि परिभाषा प्रदान करके एक विस्तारित वर्ग से विरासत में मिली विधि को ओवरराइड कर सकता है। एक वर्ग बनाएं D जो एक फ़ील्ड नाम . घोषित करता है और एक विधि hello() ।
class D{
String name="Michael";
void hello(){System.out.println("Hello "+name);}
}
एक वर्ग घोषित करें C जो कक्षा D . का विस्तार करता है और hello() . को ओवरराइड करता है तरीका। कक्षा C नाम . फ़ील्ड को भी छुपाता है ।
class C extends D{
String name="John";
void hello(){System.out.println("Hello "+name);
}
कक्षा C . का एक उदाहरण बनाएं और विधि का आह्वान करें hello() ।
new C().hello()
नमस्ते () कक्षा C . से विधि लागू हो जाता है क्योंकि यह कक्षा D . से विधि को ओवरराइड करता है . फ़ील्ड नाम कक्षा में C नाम फ़ील्ड को छुपाता है कक्षा में D . संदेश आउटपुट चित्र 6 में दिखाया गया है।
चित्र 6: किसी विधि को ओवरराइड करना
अगर कक्षा C फ़ील्ड नाम . को छुपाता नहीं है कक्षा D . से , नाम कक्षा D . में फ़ील्ड का उपयोग किया जाता है, जैसा कि चित्र 7 में दिखाया गया है।
चित्र 7: विस्तारित कक्षा से फ़ील्ड एक्सेस करना
एक वर्ग C ऑब्जेक्ट D class वर्ग का एक उदाहरण है क्योंकि यह वर्ग D . का विस्तार करता है . C . वर्ग का एक उदाहरण खोजने के लिए निम्न कथन चलाएँ D . वर्ग का एक उदाहरण भी है ।
new C() instanceof D
सत्य . का मान C class वर्ग के उदाहरण की पुष्टि करता है D . वर्ग का एक उदाहरण भी है , जैसा कि चित्र 8 में दिखाया गया है।
चित्र 8: सत्यापित करना कि कक्षा सी का एक उदाहरण भी कक्षा डी का एक उदाहरण है
क्योंकि कक्षा C . का एक उदाहरण D . वर्ग का एक उदाहरण भी है , इसे D . पर डाला जा सकता है इस प्रकार है:
D d=(D)(new C());
इसके बाद, पहुंच फ़ील्ड नाम वस्तु के लिए d प्रकार का D ।
d.name;
और, विधि का आह्वान करें hello() वस्तु के लिए d प्रकार का D ।
d.hello();
फ़ील्ड मान आउटपुट D . वर्ग से है क्योंकि d D . प्रकार की वस्तु है , जैसा कि चित्र 9 में दिखाया गया है। विधि hello() इनवॉइस क्लास C . से है ।
चित्र 9: C से D प्रकार की किसी वस्तु को कास्ट करना
इंटरफ़ेस का उपयोग करना
इस खंड में, हम JShell में इंटरफेस के लिए कुछ स्निपेट चलाएंगे। एक इंटरफ़ेस को लागू करने के लिए एक मौजूदा वर्ग को संशोधित किया जा सकता है। क्लास बनाएं C ।
[1]-> class C{}
| created class C
एक इंटरफ़ेस बनाएं I जो एक विधि को परिभाषित करता है hello() ।
[2]-> interface I {
String hello();
}
| created interface I
कक्षा C . को फिर से घोषित करें इंटरफ़ेस को लागू करने के लिए I . कक्षा C विधि के लिए कार्यान्वयन प्रदान करता है hello() ।
[3]-> class C implements I{
public String hello(){
return "Hello JShell";
}
}
| replaced class C
कक्षा C . का एक उदाहरण बनाएं ।
[4]-> new C() | $1 ==> [email protected]
क्लास इंस्टेंस वेरिएबल का उपयोग करते हुए, इनवोक मेथड hello() और विधि आउटपुट प्रदर्शित हो जाता है।
[5]-> $1.hello() | $2 ==> "Hello JShell" [6]->
क्योंकि इंटरफ़ेस में विधियाँ परोक्ष रूप से सार्वजनिक हैं जबकि एक वर्ग में विधियाँ एक विधि नहीं हैं, कक्षा में कार्यान्वयन C सार्वजनिक . के साथ घोषित किया जाना चाहिए पहुँच संशोधक। अगर घोषित नहीं किया गया सार्वजनिक , एक त्रुटि संदेश आउटपुट है क्योंकि सार्वजनिक . निर्दिष्ट नहीं कर रहा है एक्सेस संशोधक एक कमजोर एक्सेस संशोधक के लिए डिफ़ॉल्ट है, जिसे इंटरफ़ेस लागू करते समय अनुमति नहीं है।
[3]-> class C implements I{
String hello(){
return "Hello JShell";
}
}
| Error:
| hello() in C cannot implement hello() in I
| attempting to assign weaker access privileges; was public
| String hello(){
| ^--------------...
किसी विधि के लिए डिफ़ॉल्ट कार्यान्वयन का उपयोग करना
जावा 8 के अनुसार, एक इंटरफ़ेस विधि कीवर्ड डिफ़ॉल्ट का उपयोग करके किसी विधि के लिए एक डिफ़ॉल्ट कार्यान्वयन प्रदान कर सकती है। . एक इंटरफ़ेस घोषित करें जो hello() method विधि के लिए एक डिफ़ॉल्ट कार्यान्वयन प्रदान करता है डिफ़ॉल्ट . का उपयोग करना कीवर्ड।
[1]-> interface I {
default String hello(){
return "Hello JShell";
}
}
| created interface I
एक वर्ग घोषित करें C जो इंटरफ़ेस को लागू करता है I ।
[2]-> class C implements I{
}
| created class C
कक्षा C . का एक उदाहरण बनाएं और विधि का आह्वान करें hello() . इंटरफ़ेस में डिफ़ॉल्ट कार्यान्वयन से विधि I आउटपुट मिलता है।
[3]-> new C().hello(); | $1 ==> "Hello JShell"
इंटरफ़ेस विधि को स्थिर घोषित करना
जावा 8 के बाद से, इंटरफ़ेस विधियों को स्थिर . घोषित किया जा सकता है . एक इंटरफ़ेस बनाएं I जो एक स्थिर . घोषित करता है विधि।
[1]-> interface I {
static String hello(){
return "Hello JShell";
}
}
| created interface I
इंटरफ़ेस I . का उपयोग करके स्थिर विधि को लागू करें ।
[2]-> I.hello() | $1 ==> "Hello JShell"
एक वर्ग को अंतिम घोषित नहीं किया जा सकता है और, यदि अंतिम संशोधक का उपयोग किया जाता है, इसे अनदेखा कर दिया जाता है।
[5]-> [1]-> final class C{}
| Warning:
| Modifier 'final' not permitted in top-level declarations,
| ignored
| final class C{}
| ^---^
| created class C
सरणी का उपयोग करना
इस खंड में, हम सरणियों के लिए कुछ कोड स्निपेट चलाएंगे। सरणियों को घोषित करना, त्वरित करना और एक्सेस करना जावा स्रोत कोड फ़ाइल-आधारित एप्लिकेशन से अलग नहीं है। उदाहरण के तौर पर, String[] . प्रकार की एक सरणी घोषित करें . ऐरे को null . में इनिशियलाइज़ किया गया है ।
[1]-> String[] strArray; | strArray ==> null
सरणी को स्मृति आवंटित करें। एक बार सेट हो जाने के बाद ऐरे का आकार संशोधित नहीं किया जा सकता है। ऐरे एलिमेंट को null . में इनिशियलाइज़ किया जाता है ।
[2]-> strArray =new String[3];
| strArray ==> String[3] { null, null, null }
सरणी सूचकांकों का उपयोग करके सरणी तत्वों को प्रारंभ करें।
[3]-> strArray[0]="A"; strArray[1]="B"; strArray[2]="C"; | $4 ==> "A" | $5 ==> "B" | $6 ==> "C"
सरणी की लंबाई और तत्व को इंडेक्स 1 पर आउटपुट करें।
[6]-> strArray.length; strArray[1]; | $9 ==> 3 | $10 ==> "B"
सरणी लंबाई 3 के रूप में आउटपुट है। इंडेक्स 1 पर तत्व "बी" है। निम्नानुसार घोषित होने पर एक सरणी प्रारंभ की जा सकती है।
[1]-> String[] strArray={"A","B","C"};
| strArray ==> String[3] { "A", "B", "C" }
सरणी की लंबाई आउटपुट करें।
[2]-> strArray.length; | $1 ==> 3
तत्व को इंडेक्स 0 पर आउटपुट करें।
[3]-> strArray[0]; | $4 ==> "A" [4]->
एक बहु-आयामी सरणी को जावा एप्लिकेशन की तरह ही घोषित किया जा सकता है। String[][][] type प्रकार की त्रि-आयामी सरणी बनाएं और ऐरे को इनिशियलाइज़ करें।
[1]-> String[][][] strArray={{{"A","B","C"},{"AA","AB","AC"}},
{{"B","C","A"},{"BB","BC","BA"}},{{"C","A","B"},
{"CC","CA","CB"}}};
| strArray ==> String[3][][] { String[2][] { String[3]
| { "A", "B", "C" }, String[3] { "AA", ...
सरणी की लंबाई आउटपुट करें।
[2]-> strArray.length; | $1 ==> 3
अनुक्रमणिका 0 पर सरणी की लंबाई आउटपुट करें।
[3]-> strArray[0].length; | $4 ==> 2
अनुक्रमणिका 1 पर सरणी की लंबाई को अनुक्रमणिका 0 पर सरणी के भीतर आउटपुट करें।
[4]-> strArray[0][1].length; | $6 ==> 3
सरणी को इंडेक्स 0 पर आउटपुट करें।
[5]-> strArray[0]
| $10 ==> String[2][] { String[3] { "A", "B", "C" },
| String[3] { "AA", "AB", "AC" } }
इंडेक्स 0 पर ऐरे के अंदर इंडेक्स 1 पर ऐरे को आउटपुट करें।
strArray[0][1]
| $11 ==> String[3] { "AA", "AB", "AC" }
इंडेक्स 0 पर ऐरे में ऐरे में इंडेक्स 0 पर ऐरे में एलिमेंट को आउटपुट करें।
strArray[0][1][0] | $12 ==> "AA" [8]->
अनियंत्रित अपवादों का उपयोग करना
JShell रनटाइम पर अनियंत्रित अपवाद फेंकता है। उदाहरण के तौर पर, यदि स्ट्रिंग . प्रकार का एक चर जिसे इसके डिफ़ॉल्ट मान null . में प्रारंभ किया गया है पहुँचा है। java.lang.NullPointerException फेंक दिया जाता है।
[1]-> String str; | str ==> null [2]-> str.length(); | java.lang.NullPointerException thrown: | at (#2:1) [3]->
एक अन्य उदाहरण के रूप में, यदि किसी सरणी के आकार के बाहर किसी सरणी अनुक्रमणिका को एक्सेस किया जाता है, तो java.lang.ArrayIndexOutOfBoundsException फेंक दिया जाता है।
[4]->
String[] str={"A","B","C"};
| str ==> String[3] { "A", "B", "C" }
[5]-> str[3];
| java.lang.ArrayIndexOutOfBoundsException thrown: 3
| at (
यदि कोई विधि जो शून्य से भाग को परिभाषित करती है, लागू की जाती है, java.lang.ArithmeticException फेंक दिया जाता है।
[1]-> int average(int i,int j){
return (i+j)/0;
}
| created method average(int,int)
[2]-> average(2,4)
| java.lang.ArithmeticException thrown: / by zero
| at average (#1:2)
| at (#2:1)
[3]->
निष्कर्ष
इन पहले चार लेखों में, हमने चर, कथनों, विधियों, कक्षाओं, इंटरफेस और सरणियों के लिए चल रहे कोड स्निपेट पर चर्चा की। JShell को केवल कोड स्निपेट चलाने के लिए डिज़ाइन किया गया है और इस तरह कुछ सुविधाएँ स्रोत कोड फ़ाइल से संपूर्ण Java एप्लिकेशन चलाने से भिन्न होती हैं। दो और लेखों में, हम JShell की कुछ अन्य विशेषताओं के बारे में जानेंगे।
