रास्पबेरी पाई और जावा का एक कप, कृपया! (भाग 2)

यह लेख रास्पबेरी पाई पर जावा उपयोग लेखों के दूसरे भाग का अनुवाद है। रास्पबेरी पाई पर जावा का उपयोग करने की संभावना में पहले भाग के अनुवाद ने बहुत रुचि पैदा की। इस लेख का मूल १६ वें अंक में MagPi में प्रकाशित हुआ था।

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

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

नियंत्रण संरचनाओं के बारे में अधिक

MagPi # 14 में पहले लेख में , हमने दो नियंत्रण निर्माण पेश किए: यदि और जब । मुझे पता है कि आपको यह याद है, लेकिन सिर्फ मामले में, मैं आपको याद दिलाता हूं। यदि निर्माण खंड को केवल तभी निष्पादित किया जाएगा, जब कोष्ठकों में तार्किक अभिव्यक्ति का मूल्य सही हो। एक उदाहरण के लिए:

if (a > 3) { c = c + a; } 

हम a और c तभी जोड़ते हैं जब a का मान 3 से अधिक हो। कोष्ठक में अभिव्यक्ति, जिसे अवस्था कहते हैं, मान को सही (true) या असत्य (असत्य), अर्थात् ले सकते हैं। बूलियन डेटा प्रकार (तार्किक डेटा प्रकार के बारे में अधिक जानकारी के लिए, नीचे दिया गया पाठ देखें)।

अगर निर्माण में एक ब्लॉक शामिल हो सकता है जो झूठे होने पर शुरू होता है। एक उदाहरण के लिए:

  if (score > 50) { System.out.println("You won! :)"); } else { System.out.println("You lost. :("); } 

अगले निर्माण की समीक्षा हमने की थी। निर्माण के एक ब्लॉक को केवल उन मामलों में निष्पादित किया जा सकता है जब कोष्ठक में अभिव्यक्ति की स्थिति सत्य होती है , अर्थात। यह एक या अधिक बार हो सकता है, या शायद एक बार नहीं। एक उदाहरण के लिए:

  int f = 10; while (f < 20) { System.out.println(f); f++; } 

10 से 19 तक के इंटीग्रेटर तब तक प्रिंट किए जाएंगे जब तक कि वेरिएबल f 20 के बराबर न हो जाए और एक्सप्रेशन का परिणाम गलत हो जाए । साथ ही, क्या आपने चौथी लाइन पर ध्यान दिया है? ठीक है, अगर आप ध्यान दें। चर के बाद दो प्लस संकेत 1 से बढ़ाते हैं। यह एक छोटी संकेतन है:

  f = f + 1; 

इसी तरह:

  f--; 

माइनस संकेत चर f को निर्दिष्ट मान को कम करते हैं। अन्यथा, यह इस तरह दिखेगा:

  f = f - 1; 

अब आइए निर्माण के लिए देखें । निर्माण के समय के समान है, लेकिन इसके लिए, एक पंक्ति में, आप निष्पादन मानदंड और एक अभिव्यक्ति को जोड़ सकते हैं जो एक चर के मूल्य को बदलते हैं। इसलिए, 10 से 19 तक संख्याओं की गणना के लिए उपयोग करके लिखा जा सकता है:

  for (int f = 10; f < 20; f++) { System.out.println(f); } 

हां, यह विकल्प समय के उदाहरण की तुलना में अधिक कॉम्पैक्ट दिखता है। हालांकि, जबकि , कुछ मामलों में, लूपिंग के लिए अधिक सुविधाजनक हो सकता है।

निर्माण के लिए कोष्ठक में अनुभाग को तीन भागों में विभाजित किया गया है। पहला शुरुआत में चर को शुरू करने के लिए है, दूसरा चक्र के प्रत्येक दोहराने पर चर की जांच करने के लिए है, तीसरा प्रत्येक चक्र के अंत में चर को बदलना है।

अब अपना संपादक खोलें और एक नया कार्यक्रम बनाएँ:

  public class Countdown { public static void main(String[] args) throws InterruptedException { for (int t = 10; t >= 0; t--) { System.out.println("-> " + t); Thread.sleep(1000); } System.out.println("-> Fire!"); } } 

हम इसे जावा कमांड के साथ संकलित करते हैं और जावा ( पिछले लेख में अधिक) चलाते हैं। यह कार्यक्रम 10 सेकंड की गणना करेगा और फिर "फायर!" प्रिंट करेगा। प्रोग्राम चर चर को कैसे बदलता है ? डबल माइनस टी के मान को 10 से घटाकर 0. कर देता है लेकिन फिर आपको स्ट्रींग थ्रेड की आवश्यकता क्यों थी । स्लीप (1000); ? यह कार्यक्रम में चक्र के प्रत्येक चरण पर 1 सेकंड (1000 मिलीसेकंड) की देरी करता है। Thread.sleep पद्धति का उपयोग करते हुए , आप केवल ब्लॉक के दायरे में देरी करते हैं। अब इसे छोड़ दें जैसा कि यह है, मैं बाद में अपवाद से निपटने के बारे में बात करूंगा।

चलिए कार्य को जटिल बनाते हैं # 3 : एक सेकंड की देरी से 1 से 20 तक की गिनती के लिए एक नया प्रोग्राम Countup.java बनाएँ। और जब स्कोर 15 तक पहुंचता है तो हम संदेश "पांच जाने के लिए ..." प्रदर्शित करते हैं।

खैर, अंत में, स्विच पर एक और नज़र डालें। स्विच निर्माण चर के मूल्य की जांच करता है और, कोष्ठक में चर क्या है के आधार पर, बृहदान्त्र के बाद कोड निष्पादित करता है। एक उदाहरण:

  import java.util.Random; public class CardinalDirection { public static void main(String[] args) { Random r = new Random(); int dir = r.nextInt(4); switch (dir) { case 0: System.out.println("North"); break; case 1: System.out.println("West"); break; case 2: System.out.println("South"); break; default: System.out.println("East"); break; } } } 

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

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

खैर, अब आप जावा में एक बिल्कुल अलग विषय पर आगे बढ़ सकते हैं।

संख्याओं के बारे में बिट्स की एक जोड़ी

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

  int trees; // declaration trees = 17665785; // assignment 

लेकिन आप तुरंत इसके लिए एक मान निर्दिष्ट करने के लिए एक चर घोषित कर सकते हैं, इसके लिए हम दो लाइनों को एक में जोड़ते हैं:

  // declaration & assignment int trees = 17665785; 

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

और अब पूर्णांक चर के चार प्रकारों के लिए उपलब्ध मानों की श्रेणी:

  byte:  -128  127 short:  -32 768  32 767 int:  -2 147 483 648  2 147 483 647 long:  -9 223 372 036 854 775 808  9 223 372 036 854 775 807 

अधिक बार आपको तीसरे प्रकार ( इंट ) की आवश्यकता होगी। लेकिन अगर आपको दशमलव (फ्लोटिंग पॉइंट) नंबरों की आवश्यकता है, तो जावा में दो डेटा प्रकार हैं:

  float:  ±1,401298e-45  ±3,402823e+38 double:  ±4,94065645841246e-324  ±1,79769313486231e+308 

आमतौर पर, गणितीय गणना के लिए, वे फ्लोट प्रकार (7 दशमलव स्थानों) की तुलना में डबल प्रकार (15 दशमलव स्थानों) को पसंद करते हैं।

जावा में, चार अंकगणितीय ऑपरेटर + , - , * और / और कोष्ठक भी गणना को प्राथमिकता देते हैं। इन ऑपरेटरों के साथ गणना नीचे दी गई है:

  public class Numbers { public static void main(String[] args) { int x = 5; System.out.println(7 + x * 3); // 22 System.out.println((7 + x) * 3); // 36 System.out.println(7 / 3); // 2 // 1 (remainder) System.out.println(16 % 3); // 2.33333333 System.out.println(7.0 / 3.0); System.out.println(3.14159265 * x * x); } } 

गुणा और भाग के संचालन में जोड़ और घटाव की पूर्वता होती है। पूर्णांक विभाजित करते समय ऑपरेटरों / और % की कार्रवाई पर ध्यान दें, यदि पहले मामले में (ऑपरेटर / ) केवल पूर्णांक भाग विभाजन के बाद रहता है, तो दूसरे मामले में (ऑपरेटर % ), इसके विपरीत, पूर्णांक भाग को छोड़ दिया जाता है, और परिणामस्वरूप, विभाजन का शेष 1 रहता है 3 पर 7।

क्या आपको अधिक गणित कार्यों की आवश्यकता है? ठीक है, मैथ क्लास को बुलाओ। एक उदाहरण यह सूत्र है:



जावा में, यह इस तरह दिखेगा:

  double f = Math.abs(1.0 - Math.pow(x, 3.0)) / (4.0 / 3.0 * Math.sqrt(y - Math.PI))); 

जब हम पूर्णांक और भिन्नात्मक संख्या लिखते हैं, तो हम इसे एक बिंदु के साथ उजागर करते हैं। उदाहरण के लिए 3 पूर्णांक, और 3.0 भिन्नात्मक।

निम्नलिखित कार्यक्रम 1 से 10 तक सभी पूर्णांक प्रदर्शित करता है, 3 से विभाज्य नहीं, शेष के बिना:

  public class Sum { public static void main(String[] args) { int total = 0; for (int n = 1; n <= 10; n++) { if (n % 3 != 0) { total = total + n; System.out.println(total); } } System.out.println("Total: " + total); } } 

नतीजतन, हमें 1, 2, 4, 5, 7, 8, 10 मिलते हैं और उनका कुल योग 37 है।

चलिए कार्य # 4 को जटिल करते हैं : अंतिम कार्यक्रम को बदलें और उन संख्याओं को प्रदर्शित करें जो 4 से शेष के बिना विभाज्य नहीं हैं।

यदि आपको अधिक विवरणों की आवश्यकता है, तो गणित वर्ग में और कौन से कार्य उपलब्ध हैं:
docs.oracle.com/javase/7/docs/api/java/lang/Math.html

लेकिन क्या होगा यदि 15 दशमलव स्थान पर्याप्त नहीं है? फिर आपको बिगइंटर और बिगडेसीमल के प्रकारों की आवश्यकता है, ये बहुत उच्च सटीकता के साथ गणना करने के लिए कक्षाएं हैं। यदि आवश्यक हो, तो एक सौ, एक हजार या एक मिलियन दशमलव स्थानों पर। एक उदाहरण:

  import java.math.BigDecimal; public class HighPrecision { public static void main(String[] args) { BigDecimal a = new BigDecimal("2.7182818284" + "590452353602874713526624977572" + "4709369995"); // 50 decimal places BigDecimal b = new BigDecimal("3.1415926535" + "89793238462643383279502884197169399" + "375105820974944"); // 60 dec. places System.out.println("e*pi=" + a.multiply(b)); } } 

कार्यक्रम को चलाएं और आप अपने लिए सब कुछ देखेंगे।

तार के बारे में बिट्स की एक जोड़ी

तार के उपयोग से परिचित होने के लिए हमारे पास आपके प्रत्येक उदाहरण में पहले से ही अवसर था। स्ट्रिंग स्ट्रिंग अक्षरों, संख्याओं और वर्णों का एक क्रम है। सबसे सरल उदाहरण "हाय जॉन!" लेकिन अक्सर, तार का उपयोग पाठ के अनुभागों की खोज करने या कई हिस्सों से बड़े संदेशों की रचना करने के लिए किया जाता है। ऐसा करने के लिए, आप + चिह्न का उपयोग कर सकते हैं, यह एक में कई पंक्तियों को संयोजित करेगा:

  String qty = "50"; String message = "I found " + qty + " books."; 

यदि आपको स्ट्रिंग का हिस्सा प्राप्त करने की आवश्यकता है, तो प्रतिस्थापन विधि का उपयोग करें। प्रत्येक पंक्ति वर्ण में एक स्थिति होती है। नंबरिंग 0. है। निम्नलिखित उदाहरण में, हमें "घर" शब्द प्राप्त करने की आवश्यकता है, इसके वर्ण 4 से 8 स्थिति में हैं:

  String line = "The house is blue."; String word = line.substring(4, 8 + 1); 

ठीक है, अगर आपको यह पता लगाने की ज़रूरत है कि "घर" शब्द की शुरुआत कहाँ है, तो indexOf का उपयोग करें:

  String line = "The house is blue."; int position = line.indexOf("house"); // 4 int red = line.indexOf("red)"; // -1 

नोट इंडेक्सऑफ को एक पूंजी "O" के साथ लिखा जाता है। उदाहरण की अंतिम पंक्ति में हम "लाल" शब्द खोजने की कोशिश कर रहे हैं, लेकिन यह वहां नहीं है और यह विधि -1 हमारे पास लौट आई है।

आप लंबाई () विधि का उपयोग करके स्ट्रिंग की लंबाई का पता लगा सकते हैं। अलग-अलग वर्ण प्राप्त करने के लिए, हम charAt () का उपयोग करते हैं, निम्न उदाहरण दिखाता है कि अक्षरों में स्ट्रिंग को कैसे विघटित किया जाए और उन्हें अक्षरों में प्रदर्शित किया जाए।

  public class LetterByLetter { public static void main(String[] args) { if (args.length == 0) { System.out.println("Please type" + " a word."); } else { String word = args[0]; for (int i = 0; i < word.length(); i++){ System.out.println(word.charAt(i)); } } } } 

Javac संकलित करने के बाद, कमांड लाइन शब्द को हमारी कक्षा के नाम के बाद निर्दिष्ट करके प्रोग्राम को चलाएं।

  java LetterByLetter telephone 

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

स्ट्रिंग्स के साथ काम करने के लिए कई तरीके हैं। यह दस्तावेज़ में अधिक विवरण में वर्णित है docs.oracle.com/javase/7/docs/api/java/lang/String.html

चलिए कार्य को जटिल बनाते हैं # 5 : पिछले उदाहरण को बदलें और प्रत्येक अक्षर को कैपिटल बनाएं। संकेत: उस विधि का उपयोग करें जो तुरंत स्ट्रिंग अपरकेस के सभी अक्षर बनाती है, इस विधि को ऊपर दिए गए लिंक पर प्रलेखन में पाया जा सकता है।

तर्क के बारे में बिट्स की एक जोड़ी

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

  boolean painted = false; 

और इसलिए हम इसका मूल्य बदलते हैं:

  painted = true; 

या समय के लिए उपयोग करें:

  while (painted) { // do something } 

आप तार्किक चर के लिए ऑपरेटरों का भी उपयोग कर सकते हैं ! (नहीं), और& (और) और || (या)। ऑपरेटर ! किसी चर का रिटर्न मान। यदि अभिव्यक्ति के दोनों पक्ष सत्य हैं और & amp; यदि उनमें से कम से कम एक सत्य है, तो सच है । एक उदाहरण:

  boolean a = true; boolean b = false; boolean c = !a; // false boolean d = a || b; // true boolean e = a && b; // false boolean f = (!a && b) || a; // true 

भविष्य में, आप ऑपरेटरों और | । ये भी AND और OR ऑपरेटर हैं, लेकिन संख्यात्मक चर के लिए। लेकिन && का संस्करण और || अधिक कुशल चूंकि ऑपरेंड की व्यवस्था में कोई अंतर नहीं है। निम्नलिखित उदाहरण में, आप देख सकते हैं कि परिणाम ऑपरेंड के स्थान पर निर्भर नहीं करता है:

  boolean g = a || b; // true boolean h = b && a; // false 

न्यूमेरिक और स्ट्रिंग वैरिएबल भी बूलियन प्रकार का परिणाम दे सकते हैं। यह नियंत्रण संरचनाओं के लिए एक तुलना परिणाम है। एक उदाहरण:

  int total = 156; if (total > 100) { // do something } 

कोष्ठक में अभिव्यक्ति चर कुल की तुलना करती है, यदि कुल 100 से अधिक है, तो परिणाम सही होगा, अन्यथा गलत । आप दो संख्याओं की तुलना करने के लिए निम्नलिखित छह ऑपरेटरों का उपयोग कर सकते हैं:

  ==  !=   >  <  >=    <=    

सभी लौटे मान प्रकार बूलियन के होंगे , और आप उन्हें बूलियन के अन्य ऑपरेटरों के साथ जोड़ सकते हैं, उदाहरण के लिए:

  int sides = 6; boolean painted = false; if (sides >= 4 && !painted) { // paint it! } 

निष्कर्ष

इस लेख में कई विषय शामिल थे, और यह पहले की तुलना में अधिक जटिल निकला, लेकिन मैंने इसे बनाने की कोशिश की ताकि आप जावा की मूल बातें अधिक तेज़ी से पढ़ें।

अगले लेख में हम जावा के कुछ वर्ग पुस्तकालयों के साथ, जावा के तरीकों, कक्षाओं और वस्तुओं से परिचित होंगे। फिर आप एक कार्ड बनाने का कार्यक्रम बना सकते हैं।