כלומר אם אני יוצר מטריצה ב-AdvancedRobot אני אוכל להכניס לה אובייקטים מסוג Robot ללא (או עם) casting ?

לא, אבל את ההיפך כן תוכל לעשות (להכניס AdvancedRobot למטריצה של Robot).

אבל אני סה"כ רוצה להפעיל את move של Robot על אחד התאים (כלומר על רובוט) כלומר להפעיל שיטה מהמחלקה של רובוט על אובייקט מסוג רובוט שנמצא בתא... למה הוא לא מאפשר את זה ?

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

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

אוקיי, בזה טיפלתי, אבל יש משהו שמפריע לי...

במח' רובוט כתבתי את move כפי שמופיע במח' כך:

public class Robot {

  private int roboId;
  private Point location;
  private int direction;
  // Direction of the Robot
  static final int UP=0;
  static final int DOWN=1;
  static final int RIGHT=2;
  static final int LEFT=3;
  // DX,DY: A single move of the Robot

  public static final int DX=1;
  public static final int DY=1;
  public static final int NO_MOVEMENT=0;

  public Robot (int id, Point location, int dir){

    this.roboId = id;  // initialize roboID

    if ((location.getX() <0)||(location.getY()<0))  // initialize Point location
      {this.location.setLocation(0,0);}  // in case (x,y) negative coordinate, set (0,0).
    else
      {this.location.setLocation(location.getX(),location.getY());}

    if (dir>3 || dir<0)
      {System.out.println("Error in int dir value!");}
    else
      {this.direction = dir;}    // initialize Direction

  }//Robot constructor

public int getId(){  //returns robot ID#
  return roboId;
}

public Point getLocation(){  //returns robot (x,y) location
  return location;    
}

public int getDir(){  //returns robot direction
  return direction;
}

public void move(){
  switch (direction) {

      case RIGHT:
        if (((location.getX())+1)>=0)
        {
          location.translate(DX, NO_MOVEMENT);          
        }
        break;
      case UP:
        if (((location.getY())-1)>=0)
        {
          location.translate(NO_MOVEMENT, -DY);
        }
         break;
      case LEFT:
        if (((location.getX())-1)>=0)
        {
          location.translate(-DX, NO_MOVEMENT);
        }
        break;
      case DOWN:
        if (((location.getY())+1)>=0)
        {
          location.translate(NO_MOVEMENT, DY);
        }
         break;

      }//switch
}//move()

public void turnLeft(){
  if (direction == RIGHT || direction == LEFT)  //in both cases we need to decrement 2
    {direction-=2;}
  else if (direction == UP)
    {direction+=3;}
  else {direction+=1;}  // case DOWN
}

public void turnRight(){
  if (direction == UP || direction == DOWN)
    {direction+=2;}
  if (direction == LEFT)
    {direction-=3;}
  else
    {direction-=1;}  // case RIGHT
}
}//class Robot

ובמחלקה RobotsWorld כתבתי את השיטה להזזת רובוט כך:

public boolean moveRobot(Point p){
    roboArr[(int)p.getX()][(int)p.getY()].move();    
  }

הבעיה היא שבמחלקה Robot מבקשים לבדוק שלאחר הזזת הרובוט בצעד בודד לא יהיה מצב לקואורדינטה שלילית, ובשיטה של המחלקה RobotsWorld מבקשים להזיז את הרובוט ולהחזיר true אבל אם המיקום (העתידי לאחר הצעד הרצוי) יוצא מחוץ לעולם להחזיר false אבל יש בעיה, והיא שכפול קטע הקוד של move ב-Robot בעיקרון זה אותו switch case מ-Robot רק עם עוד כמה תנאים:

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

אין לי בעיה לכתוב את זה אבל זה לא ייראה כשכפול קוד ויהיה מיותר ? כי אני מאמין שאני סה"כ יכול לנצל את move של Robot לא ?

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

היא מתודת move של העולם. היא תבדוק גבולות ואם הכל בסדר. אם אכן הכל בסדר, היא תזיז את הרובוט ותחזיר true. אחרת, false.

כתבתי בנתיים את הקוד הבא כפיילוט לפני שאני מסיים עם כל ארבעת ה-case-ים. האם התנאי לגבי חריגה מגבולות העולם שבשיטה canMoveAsWell נכון ?

public boolean moveRobot(Point p){
    if (  (!inBoundary(p)) || (!anEmptyCell(p)) || (!canMoveAsWell(p))  )
    {
      return false;
    }
    else
    {
      roboArr[(int)p.getX()][(int)p.getY()].move();
      return true;
    }

  }

  private boolean canMoveAsWell(Point p) {
    switch ((roboArr[(int)p.getX()][(int)p.getY()]).getDir()){
    case Robot.RIGHT:
      if (((roboArr[(int)p.getX()+1][(int)p.getY()]) == null) &&  (((p.getX())+1) <n))
      {
        return true;
      }
    }

תודה.

המתודה בסדר רק לא הבנתי, מה ההבדל בינה לבין inBoundry וגם anEmptyCell?

שם כמו canMoveAsWell הוא אסון.

inBoundry אומר אם הנק' הנוכחית בגבולות העולם, anEmptyCell אומר אם התא הנוכחי הוא ריק.

המתודה canMoveAsWell מדברת על 'מה יקרה אם' במידה ואני זז צעד (לפי כיוון הרובוט כמובן).

סיימתי לכתוב את canMoveAsWell והוא אומר לי על החתימה:

This method must return a result of type boolean

ועל כל אחד מה-break-ים:

Unreachable code

המתודה כרגע נראית כך:

private boolean canMoveAsWell(Point p) {

    switch ((roboArr[(int)p.getX()][(int)p.getY()]).getDir()){

    case Robot.RIGHT:
      if (((roboArr[((int)p.getX())+1][(int)p.getY()]) == null) &&  (((p.getX())+1) <n))  //if next move's cell will be empty and inside world's borders, means can move as well and return true will be issued. 
      {
        return true;
      }
      else
      {
        return false;
      }
      break;
    case Robot.UP:
      if( ((roboArr[(int)p.getX()][((int)p.getY())-1]) == null) && (((p.getY())-1) <n))
      {
        return true;
      }
      else
      {
        return false;
      }
      break;
    case Robot.LEFT:
      if (((roboArr[((int)p.getX())-1][(int)p.getY()]) == null) &&  (((p.getX())-1) <n))
      {
        return true;
      }
      else
      {
        return false;
      }
      break;
    case Robot.DOWN:
      if( ((roboArr[(int)p.getX()][((int)p.getY())+1]) == null) && (((p.getY())+1) <n))
      {
        return true;
      }
      else
      {
        return false;
      }
      break;
    }

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

הקומפיילר יוצא מנקודת הנחה שבלוק של תנאי (if או switch) לא בהכרח ירוץ. אתה חייב פקודת return בסוף.

במקרה שלך אתה יכול לותר לחלוטין על כל ה-elseים ובסוף המתודה פשוט להחזיר false. וגם, אם יש לך return לא צריך break.

עזר, תודה !

האם תקין למרות שטכנית ניתן, לוותר על break במשפט switch - case ?

אם תוותר על ה-break הסוויץ' ימשיך לבדוק את כל הקייסים (מה שלא נראה נורא) אבל בנוסף הוא יכנס לבלוק ה-default מה שאנחנו ממש לא רוצים.

זה ברור, אבל השאלה אם במקרה הספציפי הזה זה ייראה מבחינה ויזואלית לחלוטין תקין סינטקטית לוותר על מרכיב כזה גם אם הוא לא הכרחי כאן בגלל ה-return ? אגב אם אני לא כותב default אז תמיד אפשר לדעתי (מבחינה טכנית נטו) לוותר על ה-break-ים כי הוא פשוט יסתיים ללא מקרה במידה ואין מקרה שעונה על ה-switch.

מותר לוותר על ה-break אם בהכרח יש לפניו return (בגלל זה הוא צועק על unreachable code - הוא לעולם לא יגיע ל-break).

^^תקין.

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

אגב, זה תמיד תקין סינטקטית לוותר על break (הקומפיילר לא מחייב את זה) - אבל זה לא תקין לוגית, דהיינו הקוד לא יעשה מה שאתה רוצה.

הגעתי לרמת ה-GUI, וכתבתי משהו התחלתי כזה:

import javax.swing.*;

public class RobotWorldSimulation {

  public static void main(String args[])
  {
    int worldSize;

    JLabel lblHelloInput = new JLabel ("Hello! Please enter number of cells for your world");
    JTextField txtAreaWorldSize = new JTextField ("Enter Number HERE",1);
    txtAreaWorldSize.addActionListener(createWorld());

    private void createWorld(){
      worldSize=txtAreaWorldSize.getText();
      RobotsWorld myWorld = new RobotsWorld(worldSize);

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