נושא 13: עצמים

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

public class Player
{
    private string name;
    private int score;
    private bool active;
}

public Player(string name, int score)
{
    this.name = name;
    if (score < 0)
    {
        this.score = 0;
    }
    else
    {
        this.score = score;
    }
    this.active = true;
}

Player p1 = new Player("Dana", 40);
Player p2 = new Player("Omer", 25);
p1.AddPoints(10);
Console.WriteLine(p1.GetScore());
Console.WriteLine(p1);

50
Dana: 50

public int GetScore()
{
    return this.score;
}

public void SetScore(int score)
{
    this.score = score;
}

public void AddPoints(int points)
{
    this.score = this.score + points;
}

public bool IsHigh()
{
    if (this.score >= 50)
    {
        return true;
    }
    else
    {
        return false;
    }
}

public string Level()
{
    if (this.IsHigh() == true)
    {
        return "Pro";
    }
    else
    {
        return "Rookie";
    }
}

public override string ToString()
{
    return this.name + ": " + this.score;
}

Player a = new Player("Noa", 10);
Player b = a;
b.AddPoints(5);
Console.WriteLine(a.GetScore());
Player c = null;
if (c == null)
{
    Console.WriteLine("No player");
}

15
No player

static Player Better(Player a, Player b)
{
    if (a.GetScore() > b.GetScore())
    {
        return a;
    }
    else
    {
        return b;
    }
}

public bool Beats(Player other)
{
    if (this.score > other.score)
    {
        return true;
    }
    else
    {
        return false;
    }
}

Player[] arr = new Player[3];
arr[0] = new Player("Dana", 40);
arr[1] = new Player("Omer", 25);
arr[2] = new Player("Noa", 60);
for (int i = 0; i < arr.Length; i++)
{
    Console.WriteLine(arr[i]);
}

static Player Best(Player[] arr)
{
    Player best = arr[0];
    for (int i = 1; i < arr.Length; i++)
    {
        int s = arr[i].GetScore();
        if (s > best.GetScore())
        {
            best = arr[i];
        }
    }
    return best;
}

public class Quiz
{
    private string topic;
    private int[] points;

    public Quiz(string topic, int[] points)
    {
        this.topic = topic;
        this.points = points;
    }

    public double Average()
    {
        int sum = 0;
        int n = this.points.Length;
        for (int i = 0; i < n; i++)
        {
            sum += this.points[i];
        }
        return (double)sum / n;
    }
}

public class Car
{
    private string model;
    private Owner owner;

    public Car(string model, Owner owner)
    {
        this.model = model;
        this.owner = owner;
    }

    public Owner GetOwner()
    {
        return this.owner;
    }

    public override string ToString()
    {
        return this.model + ", " + this.owner;
    }
}

Owner o = new Owner("Dana", 30);
Car c = new Car("Mazda", o);
Car d = new Car("Kia", new Owner("Tom", 45));
Console.WriteLine(c.GetOwner().GetName());

private Player[] squad;

public int Total()
{
    int sum = 0;
    int n = this.squad.Length;
    for (int i = 0; i < n; i++)
    {
        sum += this.squad[i].GetScore();
    }
    return sum;
}

תרגול

1. 13.1 עצמים — כתיבת מחלקה 20 רמות לתרגול ‹
   פירוט ▾

   מה מתרגלים ב־עצמים — כתיבת מחלקה C# · 200 שאלות · 20 רמות

   • מחלקה ותכונות private
   • כותרת של פעולה בונה
   • this. לפני תכונה (חובה כשלפרמטר ולתכונה יש אותו שם)
   • יצירת עצם ב‑new
   • פעולת Get וקריאה לפעולה של עצם בעזרת נקודה
   • פעולה בונה שמאתחלת תכונה לערך קבוע
   • פעולות פנימיות שמשנות תכונה (ובהן Set)
   • פעולות פנימיות שמחזירות ערך מחושב
   • ToString והדפסת עצם
   • תכונה בוליאנית
   • ההבדל בין פרמטר לתכונה
   • פעולה שנעזרת בפעולה אחרת של אותו עצם
   • כתיבת פעולה בונה
   • כתיבת פעולה פנימית
   • כתיבת מחלקה שלמה
   • בדיקת תקינות בפעולה הבונה
   • פעולה פנימית עם פרמטרים ושני תנאים נפרדים
   • פעולה פנימית שחייבת להשתמש בפעולה קיימת של המחלקה ובודקת תכונה בוליאנית ותנאי מורכב
   • כתיבת מחלקה שלמה עם בדיקת תקינות ופעולה שנעזרת בפעולה בוליאנית של המחלקה
   • כתיבת מחלקה שלמה שבה פעולה נעזרת בפעולה שנעזרת בפעולה שלישית
2. 13.2 עצמים — שימוש במחלקה 15 רמות לתרגול ‹
   פירוט ▾

   מה מתרגלים ב־עצמים — שימוש במחלקה C# · 150 שאלות · 15 רמות

   • יצירת כמה עצמים מאותה מחלקה ב‑new ולכל אחד ערכים משלו
   • שמירת ערך מוחזר במשתנה והדפסתו
   • תכונות private כפי שהן נראות מהתוכנית הראשית
   • קריאה מקוננת כמו a.SetX(a.GetX() + 5)
   • השוואה בין שני עצמים דרך פעולות Get
   • שגיאות אופייניות בתוכנית הראשית (פעולת void בתוך ביטוי, סדר ארגומנטים שגוי, קריאה לפעולה בלי עצם)
   • כתיבת שורות בתוכנית הראשית מול מחלקה נתונה
   • b = a שנותן שם נוסף לאותו עצם ולא עצם חדש
   • null כמשתנה שאינו מצביע על שום עצם
   • פעולה חיצונית שמקבלת עצם ומשנה אותו
   • פעולה חיצונית שמקבלת שני עצמים ומחזירה bool
   • פעולה חיצונית שמחזירה אחד מהעצמים שקיבלה
   • תוכנית ראשית מול מחלקה שנתונה במילים עם "הניחו שקיימות פעולות Get ו‑Set"
   • פעולה פנימית שמקבלת עצם אחר other מאותה מחלקה ומי this ומי other
   • פעולת other שבודקת שוויון של כל התכונות כולל תכונת char
   • פעולת other שמשווה סדר לפי שתי תכונות יחד עם פעולה חיצונית שחייבת להשתמש בה
3. 13.3 עצמים — מערך של עצמים 20 רמות לתרגול ‹
   פירוט ▾

   מה מתרגלים ב־עצמים — מערך של עצמים C# · 200 שאלות · 20 רמות

   • יצירת מערך של עצמים ב‑new X[n] ותאים ריקים (null)
   • הכנסת עצם לתא ב‑new והפעלת פעולה על תא (arr[i].GetName())
   • לולאה על arr.Length והדפסת עצמים דרך ToString
   • הפעלת פעולת void על כל התאים
   • פעולה חיצונית שמקבלת מערך של עצמים ומחזירה סכום
   • ספירה לפי תנאי
   • הדפסה לפי פרמטר סף
   • תכונה בוליאנית מול פרמטר בוליאני
   • "האם קיים" ו"האם כולם" עם return בתוך הלולאה
   • הערך הקיצוני עם החזרת העצם עצמו (Hotel best = arr[0])
   • מינימום בעזרת פעולת other נתונה ומי this ומי other
   • פעולה שחייבת להשתמש בפעולה אחרת לכל עצם
   • פעולה שמחזירה מערך חדש
   • מערך סכומים לפי תכונה (הקוד כמיקום)
   • החזרה והדפסה באותה פעולה
   • מערך חדש בגודל שנקבע בספירה עם מיקום כתיבה נפרד
   • לולאה על טווח ערכים שקוראת לפעולה אחרת
   • מקסימום של סכום לכל ערך של תכונה
   • זוגות עם j != i
   • מערך חדש בלי כפילויות
4. 13.4 עצמים — הכלה 18 רמות לתרגול ‹
   פירוט ▾

   מה מתרגלים ב־עצמים — הכלה C# · 180 שאלות · 18 רמות

   • תכונה מטיפוס int[]
   • תכונה שהיא עצם ממחלקה אחרת ופעולה בונה שמקבלת עצם
   • פעולה בונה שמקבלת מערך ופעולות פנימיות שעוברות על המערך של העצם
   • new בתוך new
   • פעולת Get שמחזירה עצם ושרשור קריאות
   • מחלקה שמחזיקה מערך של עצמים ופעולות שמפעילות את הפעולות של העצמים שבמערך
   • ToString שכולל את העצם הפנימי
   • שני עצמים שחולקים עצם פנימי אחד
   • השוואה בין תאים סמוכים במערך של העצם
   • פעולה עם other שמשווה את העצמים הפנימיים של שני העצמים
   • פעולה שמשתמשת בפעולה של העצם הפנימי במקום לחשב בעצמה
   • החזרת עצם מתוך המערך בעזרת פעולה שמשווה בין שני עצמים
   • הפרשים עם Math.Abs ופרמטר בוליאני שקובע מה הפעולה מחשבת
   • פעולה שנעזרת בפעולה אחרת של אותו עצם
   • פעולה שמקבלת עצם ומחפשת במערך של העצם
   • לולאות מקוננות על המערכים של שני עצמים
   • פעולה חיצונית על מערך של עצמים שבתוכם עצמים אחרים