למדו תכנות C # עבור אנדרואיד

וִידֵאוֹ: How to Practice C Programs on Smartphone ?

תוֹכֶן

מבוא מהיר - C # לעומת Java
שלום עולם! ב- C #
תחילת העבודה עם C #: שיטות ושיעורים
בשיטות
שימוש במשתנים
מעביר ויכוחים ומשתמש במחרוזות
למד C # זרימת זרימה ובנה חידונים פשוטים!
בפעם הבאה

בפוסט זה תלמדו על תכנות C # עבור אנדרואיד, כמו גם היכן שהוא מתאים לתכנית הגדולה של פיתוח אנדרואיד.

אם אתה מעוניין להפוך למפתח אנדרואיד, אתה עשוי להיות תחת הרושם שאתה צריך ללמוד אחת משתי שפות: Java או Kotlin. אלה שתי השפות הנתמכות רשמית על ידי אנדרואיד סטודיו, ולכן שתי השפות המדריכים והמדריכים הרבים מתמקדים בהם. פיתוח אנדרואיד הרבה יותר גמיש ומגוון מזה, ויש עוד המון דרכים לגשת אליו. רבים מאלו כוללים C #.

לקרוא:אני רוצה לפתח אפליקציות אנדרואיד - אילו שפות עלי ללמוד?

C # היא שפת התכנות שתשתמש בה אם תבחר לבנות משחק ב- Unity למשל - שהיא גם במקרה המנוע הפופולרי והמשתמש ביותר בשימוש בחנות Play. באופן כללי, כדאי ללמוד תכנות C # אם אתה בכלל מעוניין בפיתוח משחקים.

עליך ללמוד גם תכנות C # אם אתה רוצה להשתמש ב- Xamarin. Xamarin הוא כלי המאפשר למפתחים לבנות אפליקציות באמצעות Visual Studio, שניתן בקלות להעביר אותם ל- iOS וגם לאנדרואיד, מושלם לפרויקטים חוצי פלטפורמות.

אז עם זאת, יש בהחלט סיבה טובה ללמוד תכנות C # לאנדרואיד. בואו נסתכל על מה שאתה צריך לדעת.

מבוא מהיר - C # לעומת Java

C # היא שפת תכנות מונחה עצמים שפותחה על ידי מיקרוסופט בסביבות 2000, במטרה להיות מודרנית, פשוטה וגמישה. בדומה ל- Java (שפותחה על ידי חברת Sun Microsystem בשנת 1990), היא התפתחה במקור מ- C ++, והבטיחה שיש הרבה קווי דמיון בין השניים. לדוגמה, שניהם משתמשים באותו "בסיס תחבירי", כלומר הם משתמשים למעשה בהרבה מאותם המינוחים והמבנים. ישנם כמה הבדלים קלים, אך אם אתה מכיר שפה אחת, אתה אמור להיות מסוגל להבין הרבה מהשני בלי שתצטרך ללמוד זאת באופן ספציפי. למתחילים עם זאת, רבים ימצאו שקל יותר ללמוד תכנות C #.

כשפות מונחות עצמים, C # וגם Java יתארו אובייקטים דרך שיעורים. זוהי גישה מודולרית לתכנות, המאפשרת להשתמש בקטעי קוד שוב ושוב.

אולם אם C # שונה מג'אווה, היא השימוש שלה בצירים, הגישה שלה להאזנת אירועים, נכסים וירטואליים לעומת סופיים, ליהוק מרומז ועוד.

החדשות הטובות: למעשה אינך צריך לדעת מה המשמעות של רוב זה כשתתחיל ללמוד C #. המוצא העיקרי הוא שהמבנה פשוט קל יותר ללמוד ב- C # ונוטה לדרוש פחות הקלדה. זה נכון במיוחד בהתחשב בעובדה שכאשר אתה לומד Java ל- Android, תצטרך גם להכיר את הכיתות הרבות והממשקי API הנחוצים לבניית אפליקציות אנדרואיד. לפיכך, תוכלו גם ללמוד תכנות C # כאבן מדרכה לג'אווה.

שלום עולם! ב- C #

המסורת בעולם הקידוד היא שבכל פעם שאתה לומד שפה חדשה, עליך ליצור תוכנית פשוטה שתציג "שלום עולם!" על המסך. בעיקרון זה מבטיח שתוכל להפעיל את הכלים הדרושים ולהרכיב משהו פשוט. זה כמו לקרוא "בדיקה, בדיקה, 1, 2, 3" במיקרופון!

במקרה זה, אנו נשתמש ב- Visual Studio כדי ליצור אפליקציית קונסולה. אז לאחר שתקדם להוריד את Visual Studio (זה בחינם), לחץ על:

קובץ> חדש> פרויקט

ואז:

Visual C #> שולחן העבודה הקלאסי של Windows> יישום המסוף (NET Framework)

כך אנו בונים אפליקציה שתפעל במסוף Windows.

עם זאת, מבנה העצמות החשופות של הפרויקט שלך יופיע בחלון הראשי. תוצג בפניך קוד שנראה כך:

מרחב השמות ConsoleApp3 {class תוכנית {static void ראשי (args מחרוזת) {}}}

עכשיו פשוט הוסף שתי שורות, כך:

מרחב שמות ConsoleApp3 {class תוכנית {static void ראשי (מחרוזת args) {Console.WriteLine ("שלום עולם!"); קונסולה. ReadKey (); }}}

זה הולך לכתוב "שלום עולם!" למסך ואז לחכות ללחיצת מקשים. ברגע שהמשתמש נוגע במקש כלשהו, התוכנית תסתיים ותצא אוטומטית.

שים לב ששני השורות הללו מסתיימות בפסיקולון. הסיבה לכך היא שכל הצהרה ב- C # חייבת להסתיים עם נקודה-פסיק שתעביר ל- C # כי הקו מסתיים (זה אותו ב- Java). היוצא מן הכלל היחיד הוא כאשר הקו אחריו מיד סוגר פתוח, אשר נסביר תוך רגע.

לחץ על כפתור "התחל" בחלקו העליון של המסך, וזה אמור להפעיל את האפליקציה, ולאפשר לך לראות זאת בפועל.

חוגים הם פיסות קוד המתארות אובייקטים שהם למעשה פיסות נתונים

אז מה בדיוק קורה כאן?

תחילת העבודה עם C #: שיטות ושיעורים

כדי ללמוד תכנות C # עבור אנדרואיד, עליכם להבין שיעורים ושיטות.

חוגים הם פיסות קוד המתארות אובייקטים שהם למעשה פיסות נתונים. אינך צריך לדאוג יותר מדי מלכתחילה: רק דע לך שעמוד הקוד שאתה עובד איתו כרגע מכונה "כיתה" ושאתה יכול ליצור אינטראקציה עם שיעורים אחרים בפרויקט שלך. לפרויקט יכול להיות מחלקה אחת בלבד, כאשר כל הקוד שלך עובד משם, או שהוא יכול להכיל מספר רב.

בתוך כל כיתה יהיו לך גם שיטות. שיטות אלה הן קטעי קוד אליהם אתה יכול להתייחס בכל עת מתוך אותה כיתה - ולעתים גם מחוץ לה.

במקרה זה, הכיתה נקראת תכנית. זה מוגדר למעלה בראש השורה שקוראת: תוכנית בכיתה. ואם תפתח את חלון "פתרונות סייר" בצד ימין, תוכל למצוא Program.cs. שם הכיתה תמיד זהה לשם הקובץ.

לאחר מכן אנו משתמשים בסוגלה מתולתלת כדי להכיל את כל הקוד הבא. סוגריים מתולתלים מספרים לנו שכל מה שבא אחריו שייך זה לזה. לפיכך, עד שה סוגר נסגר, כל הקוד הבא הוא חלק מהתכנית.

אחריה באה השיטה הראשונה שלנו, המגדירה בשורה הבאה:

static void ראשי (מחרוזת args)

לאחר מכן אחריהם סוגריים פתוחים יותר, כלומר, קוד הקוד הבא הוא חלק משיטת "הראשי" (שנמצאת עדיין בתוך כיתת התוכנית). וכאן שמנו את "שלום העולם" שלנו.

"חלל סטטי" אומר לנו בעצם שהשיטה הזו עושה משהו עצמאי (ולא מניפולציה של נתונים שישמשו את התוכנית הרחבה יותר) וכי לא ניתן להפנות אליו שיעורים חיצוניים. הדברים "מחרוזת טענות" מאפשרים לנו להעביר מידע לשיטה לתמרון אחר כך. אלה נקראים "פרמטרים" ו"טיעונים ". שוב, אינך צריך לדאוג לאף אחד מאלה עדיין. רק דעו ש"בטל סטטי "ואחריו מילה, סוגריים וסוגריים מתולתלים, מהווה התחלה של שיטה חדשה.

שתי השורות הבאות הן אלה שהוספנו: הם מקבלים את המסוף ואז ניגשים לפקודות שלה כדי לכתוב למסך ולחכות ללחיצת מקשים.

לבסוף, אנו סוגרים את כל הסוגריים: תחילה את השיטה, אחר כך הכיתה, ואז "מרחב השמות" שהוא שם הפרויקט שאליו שייכת הכיתה (במקרה זה "ConsoleApp3" - ביצעתי יישומי מבחן קודמים בצורה כזו) .

מבולבלים? אל תדאג, זה עומד להיות יותר הגיוני.

בשיטות

אז השיטות הן חבילות קוד עם שמות. כדי להדגים מדוע אנו משתמשים בשיטות, יכול להיות מועיל ליצור אחת חדשה ולהשתמש בה כדוגמה.

אז, צרו שיטה חדשה שחיה בתוך כיתת התוכנית (כך שהיא צריכה להיות בתוך הסוגריים המתולתלים האלה, אך מחוץ לסוגריים המתולתלים השייכים ל"עיקרי ").

קרא לזה "NewMethod" ואז הכנס את שתי השורות שכתבת כאן בפנים. זה אמור להיראות כך:

class תוכנית {static void Main (מחרוזת args) {} static void NewMethod () {Console.WriteLine ("שלום עולם!"); קונסולה. ReadKey (); }}

כעת הוסף הפניה ל- NewMethod בשיטה העיקרית שלך, כך:

חלל סטטי ראשי (מחרוזת args) {ar NewMethod (); }

זה הולך ואז "להתקשר" לשיטה שיצרת זה עתה, בעצם לכוון את התוכנית לכיוון זה. לחץ על התחל ותראה שאותו דבר קורה כמו קודם. למעט עכשיו אם רצית, אתה יכול לכתוב "NewMethod ();" כמה פעמים שרצית ולהמשיך לחזור על הטקסט מבלי שתצטרך לכתוב הרבה קוד.

במהלך תוכנית ענקית, היכולת להפנות לקטעי קוד כאלה הופכת לחזקה להפליא. זה אחד הדברים החשובים ביותר שכדאי להבין כשמנסים ללמוד תכנות C # לאנדרואיד.

אנו יכולים ליצור שיטות רבות ככל שאנו אוהבים בצורה כזו וככה יש קטע קוד מסודר ומאורגן מאוד. במקביל, אנו יכולים גם להפנות לשיטות "המובנות" ל- C # ולכל הספריות בהן אנו עשויים להשתמש. "ראשי" הוא דוגמה אחת לשיטת "מובנית". זו השיטה שכל התוכניות יתחילו איתה, וש- C # מבינה שהיא צריכה לבצע קודם. אם לא תכניסו שום דבר לכאן, שום דבר לא יקרה!

הטיעונים הכלולים בסוגריים במקרה זה נחוצים אפוא רק מכיוון שכך מיקרוסופט עיצבה את השיטה הראשי. עם זאת, היה לנו בסדר להשאיר את הסוגריים ריקים.

שימוש במשתנים

עכשיו הגיע הזמן לעשות משהו קצת מעניין בקוד שלנו. באופן ספציפי, נסתכל כיצד היית משתמש במשתנים כדי להפוך את התוכנית לדינאמית יותר. זה אחד הדברים החשובים ביותר להבנה אם ברצונכם ללמוד תכנות C #.

משתנה הוא בעצם מכל עבור פיסת נתונים. השב את דעתך חזרה למתמטיקה בתיכון, ואולי אתה זוכר שראית דברים כאלה:

10 + x = 13
מצא x

כאן, "x" הוא משתנה, וכמובן שהערך שהוא מייצג הוא "3".

כך בדיוק בדיוק משתנה עובד בתכנות. למעט כאן משתנה יכול לייצג המון סוגים שונים של נתונים: כולל טקסט.

כדי ליצור משתנה חדש, ראשית עלינו לספר ל- C # איזה סוג נתונים הוא ישמש להכיל.

אז בשיטת NewMethod () שלך, תחילה תיצור את המשתנה שלך ואז תקצה לו ערך. ואז אנו נוסיף את זה לפקודה "WriteLine" שלנו:

מספר int; מספר = 10; Console.WriteLine ("שלום עולם!" + מספר);

השתמשנו בסוג של משתנה שנקרא "מספר שלם" שיכול להיות כל מספר שלם. בסימן C #, אנו מתייחסים לאלה באמצעות "int". עם זאת, יכולנו פשוט להשתמש ב"ציפה "למשל, שהיא" משתנה של נקודה צפה "ומאפשר לנו להשתמש במקומות עשרוניים.

אם אתה מפעיל קוד זה, עליו כעת לכתוב "שלום עולם! 10 ”למסך. וכמובן, אנו יכולים לשנות את הערך של "מספר" בכל עת על מנת לשנות את.

מכיוון שנוצר "מספר" בתוך NewMethod (), איננו יכולים לגשת אליו ממקומות אחרים בקוד שלנו. אבל אם אנו ממקמים אותו מחוץ לכל השיטות, אז הוא יהפוך לזמין ברחבי העולם. לשם כך עלינו לוודא כי המשתנה הוא גם סטטי:

תוכנית בכיתה {מספר סטטי int = 10; static void ראשי (מחרוזת args) {NewMethod (); } חלל סטטי NewMethod () {Console.WriteLine ("שלום עולם!" + מספר); קונסולה. ReadKey (); }}

לבסוף, יש דרך אחת נוספת להעביר את הנתונים האלה, וזה יהיה להשתמש בהם כוויכוח ובכך להעביר אותם לשיטה שלנו. זה עשוי להיראות כך:

חלל סטטי ראשי (מחרוזת args) {מספר int = 10; Console.WriteLine ("היי שם, מה שמך?"); NewMethod (מספר); } חלל סטטי NewMethod (מספר int) {Console.WriteLine ("שלום עולם!" + מספר); קונסולה. ReadKey (); }}

כאן אנו מגדירים את שיטת ה- NewMethod שלנו כזקוקה לטיעון אחד, שאמור להיות מספר שלם, ואותו נקרא בשיטה "מספר". אנו עושים זאת על ידי הוספת מידע זה בסוגריים המתולתלים. ואז, כשאנחנו קוראים לשיטה מכל מקום אחר בתוכנית, עלינו "להעביר" ערך זה בסוגריים. אתה יכול ליצור שיטות עם מספר פרמטרים, ובמקרה זה אתה פשוט מפריד בין המשתנים הרשומים לפסיקים.

ישנם תרחישים שונים שבהם השימוש בכל האסטרטגיות השונות הללו בכדי ללהטט נתונים יהיה מתאים. תכנות טובה פירושה למצוא את המתאימה לתפקיד!

מעביר ויכוחים ומשתמש במחרוזות

נסה להריץ את קוד הקוד הבא ולראות מה קורה:

class תוכנית {static void Main (מחרוזת args) {Console.WriteLine ("היי שם, מה שמך?"); NewMethod (Console.ReadLine ()); } חלל סטטי NewMethod (שם משתמש מחרוזת) {Console.WriteLine ("שלום" + שם משתמש); קונסולה. ReadKey (); }}

עליך לגלות שאתה מתבקש להזין את שמך ושהקונסולה אז תגדיל אותך על ידו. קטע קוד פשוט זה מכיל מספר שיעורים שימושיים.

ראשית, אנו רואים דוגמא כיצד להשתמש בסוג שונה של משתנה, המכונה מחרוזת. מחרוזת היא סדרה של דמויות, שיכולות להיות שם, או יכולות להיות סיפור שלם.

אז אתה יכול באותה קלות לכתוב UserName = "Adam". במקום זאת, אנו מקבלים את המחרוזת מהקונסולה עם ההצהרה: Console.ReadLine ().

יכולנו לכתוב:

משתמש מחרוזת; משתמש = Console.ReadLine (); NewMethod (משתמש);

אבל כדי לשמור על הקוד שלנו מסודר ככל האפשר, דילגנו על הצעדים האלה והצבנו את "ReadLine" ישירות בתוך הסוגריים.

לאחר מכן אנו מעבירים את המחרוזת הזו ל- NewMethod שלנו, ואנו מברכים את המשתמש, בשיטה שאתה כבר מכיר.

מחרוזת היא סדרה של דמויות, שיכולות להיות שם, או יכולות להיות סיפור שלם.

אני מקווה שעכשיו אתה מתחיל להבין קצת את הסיבה מדוע C # כתוב כמו שהיא, ואיך אתה יכול להשתמש בדברים כמו משתנים ושיטות על מנת ליצור תוכנה גמישה וחזקה.

אבל יש עוד פן חשוב שאתה צריך לדעת אם תרצה ללמוד תכנות C #: בקרת זרימה.

למד C # זרימת זרימה ובנה חידונים פשוטים!

אחת הסיבות לכך שאנו משתמשים במשתנים בעת קידוד היא שנוכל בקלות לערוך את התוכניות שלנו לאחר מכן. דבר אחר הוא כך שתוכלו לקבל מידע מהמשתמש, או לייצר אותו באופן אקראי.

אך אולי הסיבה הטובה ביותר ללמוד משתני C # היא כך שהתוכניות שלך יכולות להיות דינמיות: כך שתוכלו להגיב אחרת, תלוי באופן השימוש בהן.

לשם כך אנו זקוקים ל"בקרת זרימה ", או" הצהרות מותנות ". אלה באמת רק דרכים מהודרות לומר שאנחנו הולכים לבצע קוד ביותר מאופן אחד, תלוי בערך של משתנה.

ואחת הדרכים החזקות ביותר לעשות זאת היא באמירה "אם". בדוגמה זו, בואו מברכים את המשתמש העיקרי שלנו באופן שונה מהאחרים על ידי חיפוש אחר שם המשתמש שלהם.

חלל סטטי NewMethod (שם משתמש מחרוזת) {Console.WriteLine ("שלום" + שם משתמש); if (UserName.Equals ("Adam")) {Console.WriteLine ("ברוך הבא אחורי"); } קונסולה. ReadKey (); }

הצהרות "אם" עובדות על ידי בדיקת תקפותה של הצהרה, שתיכנס לסוגריים. במקרה זה, אנו שואלים אם מחרוזת שם המשתמש זהה למחרוזת "אדם". אם הצהרה זו בסוגריים נכונה - שני המיתרים זהים - אז הקוד בסוגריים המתולתלים הבאים יבצע. אם לא, השורות האלה ידלגו.

באופן דומה, אנו יכולים להשוות מספרים שלמים וצופים, ואנחנו יכולים לבדוק אם האחד גדול יותר מהשני וכו '. אנו יכולים אפילו להשתמש במספר רב של שונים אם אמירות זה בזה כמו בובות רוסיות. אנו מכנים "ifs קינון".

בפעם הבאה

ישנן הרבה יותר אסטרטגיות בהן תוכלו להשתמש לבקרת זרימה - כולל דברים כמו הצהרות מתג. יש לקוות שאתה כבר יכול לראות כיצד אנו עשויים להשתמש בהצהרות וטכניקות אלה כדי להתחיל לעשות דברים מועילים. אתה יכול בקלות להפוך את הקוד הזה לחידון כבר!