Question

问候。我已经完成了一个除了一个要求之外的所有学校项目。

要求是：

请注意，SeaCreature类为各个方向定义了四个常量。确保使用它们。您的代码不应该依赖于分配给这些常量的特定值，尽管您可能认为它们始终是int类型。

我没有看到这里的价值。分配的常量值是逻辑的，允许使用Random来返回方向。如果分配的值是四个非连续的数字，那将使代码复杂化。

下面是作业中提到的原始SeaCreature类，然后是我的一个使用Random的生物的代码。除了在涉及随机移动的每个类别中为NORTH，SOUTH，EAST，WEST分配新值之外，是否有更简洁的方式返回基本方向而不是0-3的值？

提前感谢您的建议，如果需要澄清，请询问。

import java.util.*;
/**
 * Defines the attributes and behaviors common to all SeaCreatures in order to participate
 * in the SeaCreature simulation.
 * 
 * Each SeaCreature is represented by a char.
 * Each SeaCreature can answer back its char when asked.
 * Each SeaCreature can answer its next move, NORTH, SOUTH, EAST, WEST.
 * 
 */

public abstract class SeaCreature {
    private char ch;

    /** defined constant to facilitate random movement*/
    public static final Random rand = new Random();

    /** defined constant to move one unit NORTH */
    public static final int NORTH = 0;

     /** defined constant to move one unit SOUTH */
    public static final int SOUTH = 1;

     /** defined constant to move one unit EAST */
    public static final int EAST = 2;

     /** defined constant to move one unit WEST */
    public static final int WEST = 3;


    /**
     * Construct a SeaCreature object with the given character representation
     * @param c  the character for this SeaCreature
     */
    public SeaCreature (char c){
        ch = c;
    }

    /** 
     * Answers back the character representation for this SeaCreature
     * @return this SeaCreature's initial
     */
    public char getChar(){
        return ch;
    }

    /** Answers back the next move for this SeaCreature.
     *  Must be overridden by subclasses
     * @return NORTH, SOUTH, EAST, or WEST
     */
    public abstract int getMove(); 
}

My SeaLion课程：

/**
 * Defines the attributes and behaviors specific to SeaLions in order to participate 
 * in the SeaCreature simulation.
 * 
 * @author Justin Ashburn
 * @version 6/5/2011
 */
public class SeaLion extends SeaCreature {

    /** defined char to represent a SeaLion*/
    private static final char SEALION = 'L';

    /** defined steps before SeaLion cycle repeats*/    
    private static final int CYCLE_LENGTH = 3;

    /** defined steps before SeaLion's first direction*/
    private static final int DIRECTION_ONE_LENGTH = 2;

    private int directionOne;

    private int count;

    /**
     * Construct a SeaLion object with the given character representation
     */
    public SeaLion(){
        super(SEALION);
        // establishes an initial direction
        directionOne = rand.nextInt(4);
        count = 0;        

    }

    /** Moves like the 'Knight' chess piece. ie. Picks a random direction, moves 2 times
     * in that direction, and then randomly chooses a direction perpendicular to the first
     * and moves in that direction once.
     * 
     * @return 0, 1, 2, or 3
     */
    public int getMove() {
        int direction;
        int directionTwo;
        // continues with direction one for the appropriate length
        if (count < DIRECTION_ONE_LENGTH) {
            count ++;
            direction = directionOne;
        }
        // if directionOne was east or west chooses a new north or south direction for last move
        else if (count < CYCLE_LENGTH && directionOne > 1) {
            directionTwo = rand.nextInt(2);
            direction = directionTwo;
            // resets count and establishes new direction in next cycle
            count = 0;
            directionOne = rand.nextInt(4);
        }
        // if directionOne was north or south chooses a new east or west direction for last move        
        else { 
            directionTwo = rand.nextInt(2) + 2;
            direction = directionTwo;            
            // resets count and establishes new direction in next cycle
            count = 0;           
            directionOne = rand.nextInt(4);
        }
        return direction;
    }
}

Answer 1

您需要的是从0到3之间的整数到4个命名常量的值的简单映射...而不对这些值是什么做出任何假设。

你怎么能实现呢？

提示：什么简单的Java数据结构从（零到长度-1）映射到其他东西？

Answer 2

您可以让NORTH，SOUTH，WEST和EAST成为方向或标题，如下所示：

航向：

public static final int NORTH = 0;
public static final int SOUTH = 180;
public static final int EAST = 90;
public static final int WEST = 270; // Or -90

方向：

public static final int NORTH = 90;
public static final int SOUTH = 270; // Or -90
public static final int EAST = 0;
public static final int WEST = 180;

Answer 3

我想我会做这样的事情：

private static final int AXES[][] = {
    {NORTH,SOUTH},
    {EAST,WEST}
};

...

private int directionOne;
private int directionTwo;
private int count;

...

public SeaLion(){
    super(SEALION);
    // establishes an initial direction
    nextCycle();
}

...

public int getMove() {
    int direction;
    if (count < DIRECTION_ONE_LENGTH) {
        direction = directionOne;
    } else {
        direction = directionTwo;
    }
    ++count;
    if (count == CYCLE_LENGTH) {
        nextCycle();
    }
    return direction;
}

...

private void nextCycle() {
    int axis1 = random.nextInt(2);
    int axis2 = 1 - axis1;
    directionOne = AXES[axis1][random.nextInt(2)];
    directionTwo = AXES[axis2][random.nextInt(2)];
    count = 0;        
}

与继承相关的家庭作业

3 个答案: