שאלה 4: תכנון מערכת לניהול חוות סוסים 🐴

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

📦 הגדרת המחלקות ההתחלתית:

// מחלקה שמייצגת אדם – עם שם ומספר מזהה
public class Person {
  private String _name;
  private String _id;
  ...
}

// מחלקה שמייצגת סוס – עם בעלים, האם הוא חד־קרן, ואורך זנב
public class Horse {
  private Person _owner;
  private boolean _isUnicorn;
  private double _tail;
  ...
}

// מחלקה שמייצגת חווה שמכילה מערך של סוסים
public class Farm {
  final int MAX = 100;
  private Horse[] _horses;
  private int _current;

  public Farm() {
    _horses = new Horse[MAX];
    _current = 0;
  }
}

🧩 סעיף א': בנאי למחלקת Horse

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

public Horse(Person owner, double tail) {
  if (tail < 0) tail = 1;
  this._owner = owner;
  this._tail = tail;

  if (owner != null && owner.isUnicorn())
    _isUnicorn = true;
  else
    _isUnicorn = false;
}

🧩 סעיף ב': השוואת אורך זנבות בין סוסים

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

public int compareTail(Horse other) {
  if (this._tail > other._tail) return 1;
  else if (this._tail < other._tail) return -1;
  else return 0;
}

🧩 סעיף ג': ממוצע אורך זנבות

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

public double tailAverage() {
  if (_current <= 0) return 0;
  double sum = 0;
  for (int i = 0; i < _current; i++) {
    sum += _horses[i].getTail();
  }
  return sum / _current;
}

🧩 סעיף ד': הוספת סוס למערך לפי סדר

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

public boolean addHorse(Horse b) {
  if (_current >= MAX) return false;
  int i = 0;
  while (i < _current && b.getTail() > _horses[i].getTail()) {
    i++;
  }
  for (int j = _current; j > i; j--) {
    _horses[j] = _horses[j - 1];
  }
  _horses[i] = b;
  _current++;
  return true;
}

🧩 סעיף ה': מציאת הבעלים של הסוס עם הזנב הארוך ביותר

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

public Person maxTailOwner() {
  - קודם נרשום את התנאי הראשון שאם אין סוסים בחווה נחזיר null //
  if (_current <= 0) return null;

- הוספת משתנים בשביל שיהיה עם מה לחשב //
  double maxTail = _horses[0].getTail();
  Person maxOwner = _horses[0].getOwner();

  - לואלה שעוברת על כל הרשימת סוסים
  for (int i = 1; i < _current; i++) {

  - תנאי - שאם הזנב של הסוס מהאינדקס הראשון ברשימה גדול מהזנב הכי ארוך
  - אז הזנב שלו יהיה הכי גדול וכך הלולאה חוזרת על עצמה
    if (_horses[i].getTail() > maxTail) {
      maxTail = _horses[i].getTail();

      - ואחרי שאנחנו יודעים לאיזה סוס יש את הזנב הכי ארוך נשייך אותו לבעלים
      maxOwner = _horses[i].getOwner();
    }
  }
  return maxOwner;
}

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

שאלה 3: פעולה במחלקת Line 📏

כתוב מחלקת Point המייצגת נקודה במישור XY עם שדות x ו־y, פעולה בונה ו־toString. כתוב מחלקת Line עם פעולות למציאת אורך, בדיקה אם הקו אופקי או אנכי, ותיאור.
💡 הסבר חשוב: בגלל ש-x ו-y הם private, ניגשים אליהם באמצעות getX ו-getY לפי עקרונות OOP (כמוסה).

📍 מחלקת Point:

// מחלקת Point מייצגת נקודה דו-ממדית עם שדות x ו-y.
public class Point {
  private double x;
  private double y;

  // פעולה בונה שמאתחלת את ערכי x ו-y
  public Point(double x, double y) {
    this.x = x;
    this.y = y;
  }

  // פעולות גישה לשדות — לפי עקרון Encapsulation
  public double getX() { return x; }
  public double getY() { return y; }

  // מייצרת תיאור טקסטואלי של נקודה
  public String toString() {
    return "(" + x + ", " + y + ")";
  }
}

📏 מחלקת Line:

public class Line {
  private Point start;
  private Point end;

  // פעולה בונה שמקבלת שתי נקודות
  public Line(Point start, Point end) {
    this.start = start;
    this.end = end;
  }

  // מחשבת את אורך הקו לפי נוסחת פיתגורס
  public double length() {
    double dx = end.getX() - start.getX();
    double dy = end.getY() - start.getY();
    return Math.sqrt(dx * dx + dy * dy);
  }

  // בודקת אם הקו אופקי (אותו ערך Y)
  public boolean isHorizontal() {
    return start.getY() == end.getY();
  }

  // בודקת אם הקו אנכי (אותו ערך X)
  public boolean isVertical() {
    return start.getX() == end.getX();
  }

  // מייצרת תיאור טקסטואלי של הקו
  public String toString() {
    return "Line from " + start + " to " + end;
  }
}

🧪 דוגמה להרצה (Main):

public class Main {
  public static void main(String[] args) {
    Point a = new Point(2, 3);
    Point b = new Point(6, 8);
    Line line = new Line(a, b);

    System.out.println("אורך הקו: " + line.length());
    System.out.println("האם אופקי? " + line.isHorizontal());
    System.out.println("האם אנכי? " + line.isVertical());
    System.out.println("תיאור: " + line);
  }
}