सामग्री

• वर्ग आणि ऑब्जेक्ट देणारं प्रोग्रामिंग समजून घेत आहे
• नवीन वर्ग तयार करत आहे
• वर्तन जोडणे
• त्यावर ससे सारखे
• फिबोनाची
• आपण इथून कुठे जायचे आहे? Android साठी C # कसे शिकावे

सी # शिकण्यावरील या Android ट्यूटोरियल मालिकेत भागातील आम्ही सी # प्रोग्रामिंगच्या निरपेक्ष मूलभूत गोष्टींकडे पाहिले. आम्ही पद्धती (विशिष्ट कार्ये करणार्‍या कोडचे गट), काही मूलभूत वाक्यरचना (जसे की अर्धविरामांची आवश्यकता), चल (डेटा संग्रहित करणारे कंटेनर) आणि प्रवाह नियंत्रणासाठी “if स्टेटमेंट्स” (मूल्यांवर अवलंबून असलेला शाखा कोड) चलांचे). मेथडसमधील अर्ग्युमेंटस प्रमाणे स्ट्रिंग्स सारखे व्हेरिएबल्स कसे पास करायचे तेही पाहिले.

आपण परत जाऊन याकडे आधीपासूनच वाचलेले नसल्यास हे पहा.

याक्षणी, आपण क्विझ, डेटा संचयित करणारे अ‍ॅप्स किंवा कॅल्क्युलेटर सारखे काही मूलभूत कन्सोल अ‍ॅप्स तयार करण्यास सक्षम असावे.

भाग दोन मध्ये, आम्ही आणखी काही महत्वाकांक्षी आहोत, ज्यात आणखी काही मूलतत्त्वे जसे - पळवाट पांघरुण घालणे - आणि वर्ग कसे तयार करावे आणि त्यांच्याशी संवाद कसा साधू शकतो याचा अभ्यास करीत आहोत. म्हणजेच आम्ही Android विकासावर वार करण्यास सुरवात करू आणि ते अंतर कसे पूर्ण करावे ते पाहू. आपण खरोखर सी # जाणून घेऊ इच्छित असल्यास वाचन सुरू ठेवा!

वर्ग आणि ऑब्जेक्ट देणारं प्रोग्रामिंग समजून घेत आहे

थोड्या थोड्या वेळाने, आम्ही ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंगची मूलतत्त्वे स्पष्ट केली, जे “ऑब्जेक्ट्स” चे वर्णन करण्यासाठी “वर्ग” वापरून भाषांभोवती फिरते. ऑब्जेक्ट डेटाचा एक तुकडा आहे, जो बर्‍याच गोष्टींचे प्रतिनिधित्व करू शकतो. एखाद्या वसंत .तुसारख्या खेळाच्या जगात ही शाब्दिक वस्तू असू शकते किंवा प्लेअरच्या स्कोअर हाताळणा a्या मॅनेजरप्रमाणे हे काहीतरी अधिक अमूर्त असू शकते.

एकल वर्ग अनेक वस्तू तयार करू शकतो. तर आपण कदाचित एक "शत्रू" वर्ग लिहू शकता, परंतु वाईट लोकांसह संपूर्ण पातळी तयार करण्यास सक्षम असाल. ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग वापरण्याचा हा एक मोठा फायदा आहे. अन्यथा, पुष्कळ शत्रूंचे वर्तन हाताळण्याचा एकमेव मार्ग म्हणजे बर्‍याच वैयक्तिक पद्धतींचा वापर करणे, प्रत्येक व्यक्ती वाईट परिस्थितीत वेगवेगळ्या परिस्थितीत कसे वागावे यासंबंधी सूचनांचा समावेश आहे.

जर आपले डोके फिरणे हे अद्याप थोडेच अवघड असेल तर आपल्याला खरोखर हे माहित असणे आवश्यक आहे की ऑब्जेक्ट्सचे गुणधर्म आणि वर्तन असतात. हे अगदी वास्तविक वस्तूंसारखे आहे. उदाहरणार्थ, ससाचे आकार, रंग आणि नाव यासारखे गुणधर्म असतात; आणि त्यात उडी मारणे, बसणे आणि खाणे यासारखे वर्तन आहेत. मूलभूतपणे, गुणधर्म म्हणजे व्हेरिएबल्स आणि वर्तन ही पद्धती आहेत.

आपण शेवटच्या धड्यात तयार केलेला प्रोग्राम हा देखील वर्गाचे एक उदाहरण आहे. आम्ही येथे वर्णन करीत असलेला "ऑब्जेक्ट" एक प्रकारची संकेतशब्द नियंत्रण प्रणाली आहे. त्याच्याकडे असलेली प्रॉपर्टी म्हणजे यूजरनेम ही स्ट्रिंग आहे आणि ती वर्तन म्हणजे न्यूमेथोड (वापरकर्त्याचे नाव तपासून त्यांना अभिवादन करणे) आहे.

जर ते असेलअजूनही थोडे गोंधळात टाकणारे, आपल्या डोक्यावर फिरण्याचा एकमेव मार्ग म्हणजे एक नवीन वर्ग तयार करणे किंवा दोन स्वत: ला!

नवीन वर्ग तयार करत आहे

आपण सी # शिकत असाल तर नवीन वर्ग कसे तयार करावे हे माहित असणे आवश्यक आहे. सुदैवाने, हे अगदी सोपे आहे. फक्त प्रोजेक्ट मेनू आयटमवर क्लिक करा आणि नंतर “+ वर्ग जोडा” निवडा.

“सी #” निवडा आणि त्याला “ससा” म्हणा. आम्ही संकल्पनात्मक ससे तयार करण्यासाठी हा वर्ग वापरणार आहोत. एका क्षणात मी काय म्हणालो ते पहा.

आपण आपल्या सोल्यूशन एक्सप्लोररला उजवीकडे तपासल्यास आपल्याला दिसेल की प्रोग्रामबॅकच्या खाली रॅबिट.क. नावाची एक नवीन फाईल तयार केली गेली आहे. चांगले केले - आपण Android साठी सी # जाणून घेऊ इच्छित असल्यास हे जाणून घेण्यास अत्यंत कठीण असलेल्यांपैकी एक आहे!

नवीन रॅबिट.सी.एस. फाइलमध्ये पूर्वीसारखा काही “बॉयलरप्लेट” कोड आहे. हे अद्याप त्याच नेमस्पेसशी संबंधित आहे आणि त्याचा फाईल सारख्याच नावाचा एक वर्ग आहे.

नेमस्पेस कन्सोलअपे 2 {वर्ग ससा {}

आता आम्ही आमच्या ससाला काही मालमत्ता देणार आहोत ज्यांना आपण "कन्स्ट्रक्टर" म्हणतो.

कन्स्ट्रक्टर ही वर्गातील एक पद्धत आहे जी ऑब्जेक्टला आरंभ करते, जेव्हा आम्ही प्रथम ती तयार करते तेव्हा त्याचे गुणधर्म परिभाषित करण्यास अनुमती देते. या प्रकरणात, आम्ही काय म्हणणार आहोत ते येथे आहे:

नेमस्पेस कन्सोलअपे 2 {वर्ग ससा {पब्लिक स्ट्रिंग रेबिटनेम; पब्लिक स्ट्रिंग रेबिट कलर; पब्लिक इन्ट रेबिटएज; पब्लिक इन्ट रॅबिटवेट; सार्वजनिक ससा (तार्याचे नाव, स्ट्रिंग रंग, इंट वयाज, इंट वेट) {रेबिटनेम = नाव; रेबिट कलर = रंग; रॅबिटएज = वय; रेबिटवेट = वजन; }}}

हे आम्हाला भिन्न वर्गाकडून नवीन ससा तयार करण्याची आणि त्याच्या गुणधर्मांची आम्ही परिभाषित करण्याची अनुमती देते:

ससा ससा 1 = नवीन ससा ("जेफ", "तपकिरी", 1, 1);

आता मला माहित आहे की पूर्वसूचनातील वजन दशांश मिळविण्यासाठी कदाचित फ्लोट किंवा डबल असावे, परंतु आपल्याला कल्पना येईल. आम्ही आमच्या ससाला जवळच्या संपूर्ण संख्येत गोल करणार आहोत.

आपण आपल्या ससाला लिहित असताना आपल्याला दिसेल की आपल्याला योग्य युक्तिवाद करण्यास प्रवृत्त केले जाईल. अशा प्रकारे, आपला वर्ग जवळजवळ कोडचा एक भाग बनला आहे.

यावर विश्वास ठेवा किंवा नाही, या कोडने एक ससा तयार केला आहे! आपण आपला ससा पाहू शकत नाही कारण आमच्याकडे कोणतेही ग्राफिक्स नाहीत, परंतु ते तेथे आहे.

आणि हे सिद्ध करण्यासाठी आपण आता ही ओळ वापरू शकता:

कन्सोल.राइटलाइन (रॅबिट 1. रॅबिटनेम);

हे नंतर आपण नुकतेच तयार केलेल्या ससाचे नाव सांगेल!

आम्ही आमच्या ससाचे वजन देखील वाढवू शकतो, तसेः

रॅबिट 1.राबिटवेट ++; कन्सोल.राइटलाइन (रॅबिट 1. रॅबिटनेम + "वजन" + रेबिट 1. रॅबवेट + "किलो");

येथे लक्षात घ्या की एखाद्या गोष्टीच्या शेवटी "++" जोडल्याने त्याचे मूल्य वाढत जाईल एकाने (आपण "रॅबिटवेट = रॅबिटवेट + 1" देखील लिहू शकता).

कारण आमचा वर्ग आपल्या आवडत्या प्रमाणात ससा बनवू शकतो, म्हणून आम्ही बरेच वेगवेगळे ससे तयार करु शकतो, त्या प्रत्येकाच्या स्वतःच्या गुणधर्मांसह.

वर्तन जोडणे

मग आम्ही आपल्या ससाला काही प्रकारची वागणूक देणे देखील निवडू शकतो. या प्रकरणात, आपण त्यांना खाऊ द्या.

हे करण्यासाठी, आम्ही "ईट" नावाची एक सार्वजनिक पद्धत तयार करू आणि यामुळे खाण्याचा आवाज होईल, तसेच ससाचे वजन वाढत जाईल:

सार्वजनिक शून्य ईट () so कन्सोल.राइटलाइन (रॅबिटनेम + ": निब्बल निबले!"); रेबिटवेट ++; }

लक्षात ठेवा, “सार्वजनिक” म्हणजे वर्गाच्या बाहेरून प्रवेश करण्यायोग्य आणि “शून्य” म्हणजे पद्धत कोणताही डेटा परत करत नाही.

नंतर प्रोग्रॅम. सी.एस. मधून, आम्ही ही पद्धत कॉल करू आणि यामुळे आपल्या पसंतीच्या ससा खाणे आणि मोठे होईल:

कन्सोल.राइटलाइन (रॅबिट 1. रॅबिटनेम + "वजन" + रेबिट 1. रॅबवेट + "किलो"); रॅबिट 1.एट (); रॅबिट 1.एट (); रॅबिट 1.एट (); कन्सोल.राइटलाइन (रॅबिट 1. रॅबिटनेम + "वजन" + रेबिट 1. रॅबवेट + "किलो");

यामुळे जेफला तीन वेळा जेवण मिळेल, मग आम्ही ते ऐकू आणि तो मोठा झाला आहे हे पाहण्यास सक्षम होऊ! जर आमच्याकडे देखावा वर दुसरा ससा असेल तर ते देखील खाऊ शकतील!

कन्सोल.राइटलाइन (रॅबिट 1. रॅबिटनेम + "वजन" + रेबिट 1. रॅबवेट + "किलो"); कन्सोल.राइटलाइन (रॅबिट 2. रॅबिटनेम + "वजन" + रेबिट 2. रॅबवेट + "किलो"); रॅबिट 1.एट (); रॅबिट 1.एट (); रॅबिट 2.एट (); रॅबिट 2.एट (); रॅबिट 1.एट (); कन्सोल.राइटलाइन (रॅबिट 1. रॅबिटनेम + "वजन" + रेबिट 1. रॅबवेट + "किलो"); कन्सोल.राइटलाइन (रॅबिट 2. रॅबिटनेम + "वजन" + रेबिट 2. रॅबवेट + "किलो");

त्यावर ससे सारखे

बर्‍याच ऑब्जेक्ट्स हाताळण्याचा हा खास मार्ग नाही, कारण आपल्याला प्रत्येक ससासाठी स्वत: हून आज्ञा लिहिणे आवश्यक आहे आणि आम्हाला पाहिजे तितक्या सशांची संख्या गतिकरित्या वाढवू शकत नाही. आम्हाला फक्त C # शिकायचं नाही - स्वच्छ C # कोड कसा लिहायचा हे आम्हाला शिकायचं आहे!

म्हणूनच आम्ही कदाचित यादी वापरू. यादी संग्रह आहे; व्हेरिएबलमध्येच मुळात इतर व्हेरिएबल्सचा संदर्भ असतो. या प्रकरणात, आम्ही सशांची यादी बनवू शकतो आणि चांगली बातमी ही आहे की हे समजणे खूप सोपे आहे:

यादी रॅबिटलिस्ट = नवीन यादी(); रॅबिटलिस्ट.एड (नवीन ससा ("जेफ", "तपकिरी", 1, 1)); रॅबिटलिस्ट.एड (नवीन ससा ("सॅम", "पांढरा", 1, 2));

हे पूर्वीसारखे नवीन ससा तयार करते, परंतु एकाच वेळी ससाला यादीमध्ये जोडते. तसेच, आम्ही हे म्हणू शकतो:

ससा ससा 3 = नवीन ससा ("जॉनी", "केशरी", 1, 1); रॅबिटलिस्ट.अॅड (रेबिट));

एकतर, एक ऑब्जेक्ट तयार केला गेला आहे आणि त्या सूचीमध्ये समाविष्ट केला आहे.

आम्ही आमच्या ससेच्या सूचीमधून सुलभतेने आणि सुरेखपणे माहिती परत आणू शकतो:

फोरच (रॅबिटलिस्टमध्ये वॅर रेबिट) {कन्सोल.राइटलाइन (रॅबिट. रॅबिटनेम + "वजन" + ससा. रॅबिटवेट + "किलो"); }

जसे आपण कदाचित समजण्यास सक्षम असाल, “फोरच” म्हणजेच सूचीतील प्रत्येक वस्तूसाठी आपण एकदा चरण पुन्हा केले. आपण आपल्या सूचीमधून यासारखी माहिती देखील मिळवू शकता:

रॅबिटलिस्ट.एट ();

येथे “1” ही अनुक्रमणिका आहे, याचा अर्थ आपण एका स्थानावर संग्रहित माहितीचा संदर्भ घेत आहात. हे घडते तसे, प्रत्यक्षात दुसरा आपण ससा जरी जोडला: कारण प्रोग्रामिंगमधील याद्या नेहमी 0 पासून सुरू होतात.

फिबोनाची

आपण अद्याप अंदाज केला नसल्यास, आम्ही आता फिबोनॅकी अनुक्रम तयार करण्यासाठी या सर्व माहितीचा वापर करणार आहोत. तथापि, आपण Android साठी C # शिकत असल्यास, आपण त्या सर्व सिद्धांतासह खरोखर काहीतरी रोचक करण्यास सक्षम असावे!

फिबोनॅकी अनुक्रमात, ससे एका खोलीत बंद केले जातात आणि जातीच्या डावीकडे सोडले जातात. ते एका महिन्यानंतर पुनरुत्पादित करू शकतात, ज्या वेळी ते लैंगिकदृष्ट्या प्रौढ आहेत (हे योग्य ससा जीवशास्त्र आहे की नाही हे मी पुष्टी करू शकत नाही). जर प्रत्येक ससा दाम्पत्य महिन्यातून एकदा दोन संतती उत्पन्न देऊ शकत असेल तर हा क्रम कसा आहे ते येथे आहेः

1,1,2,3,5,8,13,21,34

जादूने, अनुक्रमातील प्रत्येक संख्या मागील जोडलेल्या दोन संख्येचे मूल्य आहे. विज्ञानाच्या मते हा एक मोठा करार आहे.

मस्त गोष्ट म्हणजे आपण ती पुन्हा बनवू शकतो.

प्रथम, आम्हाला एक नवीन संकल्पना सादर करण्याची आवश्यकता आहे: लूप. अट पूर्ण होईपर्यंत हे समान कोडची पुन्हा पुन्हा पुनरावृत्ती करते. “For” लूप आपल्याला व्हेरिएबल तयार करून, आपल्याला भेटावयाची परिस्थिती सेट करुन त्यावर कार्य करू देते - सर्व कंसात परिभाषित:

साठी (पूर्ण महिने = ०; महिने <100; महिने ++) something // काहीतरी करा}

म्हणून आम्ही महिन्यांसारखे पूर्णांक तयार करीत आहोत आणि ते 100 च्या बरोबरीपर्यंत वळण लावतो. मग आम्ही महिन्यांची संख्या एक-एक करून वाढवितो.

हा फिबोनाकी क्रम कसा बनू शकतो हे पहायचे आहे का? पहा:

नेमस्पेस कन्सोल 2२ {क्लास प्रोग्राम {स्टॅटिक रिक्त मेन (स्ट्रिंग आर्क) {यादी रॅबिटलिस्ट = नवीन यादी(); रॅबिटलिस्ट.एड (नवीन ससा ("जेफ", "तपकिरी", 0, 1)); रॅबिटलिस्ट.अॅड (नवीन ससा ("सॅम", "पांढरा", 0, 1)); साठी (पूर्ण महिने = 0; महिने <10; महिने ++) first INR फर्स्ट रॅबिट = 0; इंट टाइट्सटोरप्रड्यूस = 0; फोरच (रॅबिटलिस्टमध्ये वॅर रेबिट) so कन्सोल.राइट ("आर"); if (ससा. रॅबिटएज> 0) {जर (फर्स्टराबिट == 0) {फर्स्टराबिट = 1; } else {firstRabbit = 0; timesToReproduce ++; }} ससा.रॅबिटएज ++; int साठी (int i = 0; i <timesToReproduce; i++) bit रॅबिटलिस्ट.आऊट (नवीन ससा ("न्यूबेबी रॅबिट", "ब्राउन", 0, 1)); रॅबिटलिस्ट.अॅड (नवीन ससा ("न्यूबीबी रॅबिट", "तपकिरी", 0, 1)); कन्सोल.राइट ("आर"); कन्सोल.राइट ("आर"); So कन्सोल.राइटलाइन ("--- येथे" + रॅबिटलिस्ट. खाते / 2 + "सशांच्या जोड्या आहेत!"); कन्सोल.राइटलाइन (""); So कन्सोल.राइटलाइन ("सर्व झाले!"); कन्सोल.रेडके (); }}}

ठीक आहे, हे माझ्या विचारापेक्षा कठीण होते!

मी या सर्वांमधून जाणार नाही, परंतु आपण आधीपासून शिकलेल्या गोष्टींचा वापर करून, आपण त्यास रिव्हर्स इंजिनियर सक्षम केले पाहिजे.

असे करण्याचे निश्चितपणे आणखी मोहक मार्ग आहेत - मी नाही गणितज्ञ. तथापि, मला वाटते की हा एक अतिशय मजेदार व्यायाम आहे आणि एकदा आपण हे करू शकलात तर आपण बराच वेळ तयार आहात.

मला तसे, इतर कोणतेही दृष्टिकोन पाहण्यास आवडेल!

आपण इथून कुठे जायचे आहे? Android साठी C # कसे शिकावे

आपल्या पट्ट्याखाली असलेल्या सर्व ज्ञानासह आपण मोठ्या गोष्टी प्रारंभ करण्यास तयार आहात. विशेषतः, आपण झॅमारीन किंवा युनिटी मधील सी # सह Android प्रोग्रामिंगमध्ये वार करण्यासाठी तयार आहात.

हे भिन्न आहे कारण आपण Google, मायक्रोसॉफ्ट आणि युनिटी द्वारे प्रदान केलेले वर्ग वापरत आहात. जेव्हा आपण "रिगिडबॉडी 2 डी.वेग" असे काहीतरी लिहित आहात तेव्हा आपण वर्गातील एखाद्या मालमत्तेत प्रवेश करणे म्हणजे काय करत आहात म्हणतात RigidBody2D. हे फक्त त्याच कार्य करते, फक्त एकच फरक आहे की आपण रिगिडबॉडी 2 डी पाहू शकत नाही कारण आपण ते स्वतः तयार केले नाही.

आपल्या पट्ट्याखालील या सी # सह, आपण यापैकी कोणत्याही पर्यायात जाण्यासाठी तयार असले पाहिजे आणि काय चालले आहे हे समजून घेताना आपण मोठी सुरुवात केली पाहिजे:

• Xamarin सह Android अनुप्रयोग कसे तयार करावे
• आपला पहिला Android गेम युनिटीसह 7 मिनिटात तयार करा

आगामी धड्यात आपण यू-टर्न कसा घेऊ शकता आणि त्याऐवजी विंडोज अ‍ॅप्स तयार करण्यासाठी याचा कसा वापर करू शकता हे आम्ही पाहू!