תוֹכֶן

• הבנת שיעורים ותכנות מונחה עצמים
• יצירת כיתה חדשה
• הוספת התנהגויות
• בזה כמו ארנבים
• פיבונאצ'י
• לאן אנחנו הולכים מכאן? כיצד ללמוד C # עבור אנדרואיד

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

עליך לחזור להסתכל על זה אם לא קראת אותו כבר.

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

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

הבנת שיעורים ותכנות מונחה עצמים

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

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

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

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

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

יצירת כיתה חדשה

אם אתה מתכוון ללמוד C #, אתה צריך לדעת להכין שיעורים חדשים. למרבה המזל, זה קל מאוד. פשוט לחץ על פריט התפריט Project ואז בחר "+ הוסף כיתה."

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

אם אתה בודק את סייר הפתרונות שלך בצד ימין, תראה שקובץ חדש בשם Rabbit.cs נוצר ממש מתחת Program.cs. כל הכבוד - זה אחד הדברים החשובים ביותר לדעת אם תרצו ללמוד C # לאנדרואיד!

לקובץ Rabbit.cs החדש יש כמה מאותו קוד "לוח הדוד" כמו קודם. זה עדיין שייך לאותו מרחב שמות, ויש לו מחלקה עם אותו שם כמו הקובץ.

מרחב השמות ConsoleApp2 {class Rabbit {}}

כעת אנו הולכים לתת לארנבנו כמה נכסים עם מה שאנו מכנים "בנאי".

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

מרחב השמות ConsoleApp2 {class Rabbit {מחרוזת ציבורית RabbitName; מחרוזת ציבורית RabbitColor; אינטל ציבורי RabbitAge; אינטל ציבורי RabbitWeight; ארנב ציבורי (שם מחרוזת, צבע מחרוזת, גיל int, משקל int) {RabbitName = name; צבע Rabbit = צבע; RabbitAge = גיל; RabbitWeight = משקל; }}}

זה מאפשר לנו ליצור ארנב חדש ממעמד אחר ולהגדיר את תכונותיו כמונו:

ארנב ארנב 1 = ארנב חדש ("ג'ף", "חום", 1, 1);

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

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

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

וכדי להוכיח זאת, כעת תוכלו להשתמש בשורה זו:

Console.WriteLine (Rabbit1.RabbitName);

לאחר מכן זה יגיד לך את שם הארנב שיצרת זה עתה!

אנו יכולים גם להגדיל את משקל הארנב שלנו, כך:

Rabbit1.RabbitWeight ++; Console.WriteLine (Rabbit1.RabbitName + "שוקל" + Rabbit1.RabbitWeight + "kg");

שים לב כאן כי הוספת "++" בסוף דבר תגדיל את הערך שלו באופן הדרגתי (אתה יכול גם לכתוב "RabbitWeight = RabbitWeight + 1").

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

הוספת התנהגויות

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

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

חלל ציבורי Eat () {Console.WriteLine (RabbitName + ": לכרסם ניבלינג!"); RabbitWeight ++; }

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

ואז, מתוך Program.cs, נוכל לקרוא לשיטה זו וזה יגרום לארנב שבחרנו לאכול ולהגדיל:

Console.WriteLine (Rabbit1.RabbitName + "שוקל" + Rabbit1.RabbitWeight + "kg"); Rabbit1.Eat (); Rabbit1.Eat (); Rabbit1.Eat (); Console.WriteLine (Rabbit1.RabbitName + "שוקל" + Rabbit1.RabbitWeight + "kg");

זה יגרום לג'ף לאכול שלוש פעמים, אז נשמע את זה ונוכל לראות שהוא התחזק! אם היה לנו ארנב נוסף במקום, הם גם היו יכולים לאכול!

Console.WriteLine (Rabbit1.RabbitName + "שוקל" + Rabbit1.RabbitWeight + "kg"); Console.WriteLine (Rabbit2.RabbitName + "שוקל" + Rabbit2.RabbitWeight + "kg"); Rabbit1.Eat (); Rabbit1.Eat (); Rabbit2.Eat (); Rabbit2.Eat (); Rabbit1.Eat (); Console.WriteLine (Rabbit1.RabbitName + "שוקל" + Rabbit1.RabbitWeight + "kg"); Console.WriteLine (Rabbit2.RabbitName + "שוקל" + Rabbit2.RabbitWeight + "kg");

בזה כמו ארנבים

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

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

רשימה RabbitList = רשימה חדשה(); RabbitList.Td (ארנב חדש ("ג'ף", "חום", 1, 1)); RabbitList.Td (ארנב חדש ("סם", "לבן", 1, 2));

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

ארנב ארנב 3 = ארנב חדש ("ג'וני", "כתום", 1, 1); RabbitList.Td (Rabbit3);

כך או כך, אובייקט נוצר ונוסף לרשימה.

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

foreach (var Rabbit ב- RabbitList) {Console.WriteLine (Rabbit.RabbitName + "שוקל" + Rabbit.RabbitWeight + "kg"); }

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

RabbitList.Eat ();

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

פיבונאצ'י

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

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

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

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

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

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

במשך (int חודשים = 0; חודשים <100; חודשים ++) {// עשה משהו}

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

רוצה לראות איך זה יכול להפוך לרצף פיבונאצ'י? הנה:

מרחב השמות ConsoleApp2 {class תוכנית {static void ראשי (arging string) {רשימה RabbitList = רשימה חדשה(); RabbitList.Td (ארנב חדש ("ג'ף", "חום", 0, 1)); RabbitList.Td (ארנב חדש ("סם", "לבן", 0, 1)); במשך (int חודשים = 0; חודשים <10; חודשים ++) {int firstRabbit = 0; int timesToReproduce = 0; foreach (var Rabbit ב- RabbitList) {Console.Write ("R"); if (Rabbit.RabbitAge> 0) {if (firstRabbit == 0) {firstRabbit = 1; } else {firstRabbit = 0; timesTo Reproduce ++; }} ארנב. RabbitAge ++; } עבור (int i = 0; i <timesToReproduce; i ++) {RabbitList. הוסף (ארנב חדש ("NewBabyRabbit", "חום", 0, 1)); RabbitList.Td (ארנב חדש ("NewBabyRabbit", "חום", 0, 1)); קונסולה. כתוב ("r"); קונסולה. כתוב ("r"); } Console.WriteLine ("--- יש" + RabbitList.Count / 2 + "זוגות ארנבים!"); Console.WriteLine (""); } Console.WriteLine ("הכל נעשה!"); קונסולה. ReadKey (); }}}

אוקיי, זה היה קשה ממה שחשבתי!

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

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

אשמח לראות גישות אחרות, דרך אגב!

לאן אנחנו הולכים מכאן? כיצד ללמוד C # עבור אנדרואיד

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

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

כש- C # זה נמצא תחת חגורתך, אתה צריך להיות מוכן לקפוץ לאחת מהאפשרויות הללו ולהתחיל בראש גדול כשמדובר בהבנת המתרחש:

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

בשיעור הקרוב, נבדוק גם כיצד ניתן לפנות לפניות ולהשתמש בזה לבניית יישומי Windows במקום זאת!