如何配置连接到几个更具体的类的这个 Java 方法？

Question

All of the program's templates。这是过去的任务，但在这一点上，我只是想了解发生了什么。

在 Apartment 类下，我很困惑如何正确返回一个单元、所有单元的窗口订单数组，然后是 ThreeBedroom 下的 @Override 方法。

仅供参考我到目前为止所做的事情（可能并不完全正确）：

public class Window {
    private final int width, height;

    public Window(int width, int height) {
        this.width = width;
        this.height = height;
    }

    // print text like: 4 X 6 window
    public String toString() {
        String s = "";
        s = width + " x " + height + " window";
        return s;
    }

    // compare window objects by their dimensions
    public boolean equals(Object that) {
        if (that instanceof Window) {
            Window w = (Window) that;
            return this.width == w.width && this.height == w.height;
        }

        else { return false; }
    }
}

class WindowOrder {
    final Window window; // window description (its width and height)
    int num;             // number of windows for this order

    WindowOrder(Window window, int num) {
        this.window = window;
        this.num = num;
    }

    // add the num field of the parameter to the num field of this object
    //
    // BUT
    //
    //   do the merging only of two windows have the same size
    //   do nothing if the size does not match
    // 
    // return the current object
    WindowOrder add(WindowOrder order) {
        if (order.equals(window)) {
            this.num -= num;
            return order;
        }

        else {
            return order;
        }
    }

    // update the num field of this object by multiplying it with the parameter
    // and then return the current object
    WindowOrder times(int number) {
        WindowOrder window = new WindowOrder(this.window, this.num);
        this.num *= number;

        return window;
    }

    // print text like: 20 4 X 6 window
    @Override
    public String toString() {
        String s = "";
        s = num + " " + window.toString();
        return s;
    }

    // Two orders are equal if they contain the same number of windows of the same size.
    @Override
    public boolean equals(Object that) {
        if (that instanceof WindowOrder) {
            WindowOrder order = (WindowOrder) that;
            return this.num == order.num && this.window == order.window;
        }

        else { return false; }
    }
}

public class Room { 
    Window window;
    int numOfWindows;

    Room(Window window, int numOfWindows) { 
        this.window = window;
        this.numOfWindows = numOfWindows;
    }

    WindowOrder order() {
        return new WindowOrder(window, numOfWindows);
    }

    // Print text like: 5 (6 X 8 window)
    @Override
    public String toString() {
        String s = "";
        s = numOfWindows + " (" + window.toString() + ")"; 
        return s;
    }

    // Two rooms are equal if they contain the same number of windows of the same size
    @Override
    public boolean equals(Object that) {
        if (that instanceof Room) {
            Room room = (Room) that;
            return this.window == room.window && this.numOfWindows == room.numOfWindows;
        }
        else { return false; }
    }
}

class MasterBedroom extends Room {
    MasterBedroom() {
        super(new Window(4, 6), 3);
    }

    // Call parent's toString method
    //
    // return text like: Master bedroom: 3 (4 X 6 window)
    @Override
    public String toString() {
        String s = "";
        s = "Master bedroom: " + numOfWindows + " " + window.toString();
        return s;
    }
}

class GuestRoom extends Room {
    GuestRoom() {
        super(new Window(5, 6), 2);
    }

    // Call parent's toString method
    //
    // return text like: Guest room: 2 (5 X 6 window)
    @Override
    public String toString() {
        String s = "";
        s = "Guest room: " + numOfWindows + " " + window.toString();
        return s;
    }
}

class LivingRoom extends Room {
    LivingRoom() {
        super(new Window(6, 8), 5);
    }

    // Call parent's toString method
    //
    // return text like: Living room: 5 (6 X 8 window)
    @Override
    public String toString() {
        String s = "";
        s = "Living room: " + numOfWindows + " " + window.toString();
        return s;
    }
}

对于 Apartment 的 orderForOneUnit() 方法，我写了这个，但它似乎过于简单，我觉得我应该使用 for 循环..

WindowOrder[] orderForOneUnit() {
    WindowOrder[] order = new WindowOrder[rooms.length];
    return order;
}

我是否接近正确理解这一点？ Apartment 方法下应该是什么？

Answer 1

没有查看模板，但从您提供的内容来看，您已经很接近了。到目前为止，您所做的只是创建了一个 WindowOrder[] 长度房间数组。您需要在return order; 之前将new WindowOrder(desc, num) 添加到这些数组中

/**
 * All apartment rooms have the same number of windows, with the
 * same size window for each of those.
 */
public class Apartment
{
    private int numRooms_;
    private int windowsPerRoom_;
    private Window window_;

    /**
     * Constructor
     */
    public Apartment(numRooms, windowsPerRoom, desiredWindowHeight, desiredWindowLength)
    {
        numRooms_ = numRooms;
        windowsPerRoom_ = windowsPerRoom;
        window_ = new Window(desiredWindowHeight, desiredWindowLenght);
    }

    /** 
     * Orders for one room in apartment
     */
    public WindowOrder orderForOneUnit() 
    {
        WindowOrder order = new WindowOrder(window_, 1);

        return order;
    }

    /** 
     * Orders for all rooms in apartment
     */
    public List<WindowOrder> orderForAllUnits() 
    {
        List<WindowOrder> orders = new ArrayList<WindowOrder>();

        WindowOrder order;
        for(i=0; i<numRooms_; i++)
        {
            orders.add(new WindowOrder(window_, windowsPerRoom_);
        }
        return orders;
    }
}

现在，当您在代码中并且准备好使用 new Apartment(x, x, x, x) 时，您可以执行以下操作（我假设您只是在 main() 中）

public class ApartmentComplex
{
    public static void main(String[] args)
    {
        int numWindowsPerRoom = 3;
        int desiredWindowHeight = 10;
        int desiredWindowWidth = 10;

        int numRooms = 5;
        Apartment aptWithFiveRooms = new Apartment(numRooms, numWindowsPerRoom, desiredWindowHeight, desiredWindowWidth);

        WindowOrder singleSingleOrder = apt.orderForOneUnit();
        List<WindowOrder> allRoomsOrder = apt.orderForAllUnits();

        numRooms = 3;
        Apartment aptWithThreeRooms = new Apartment(numRooms, numWindowsPerRoom, desiredWindowHeight, desiredWindowWidth);
        List<WindowOrder> threeRoomsOrder = apt.orderForAllUnits();
    }
}

Answer 2

你确实需要一个 for 循环。目前，您正在返回一个数组，其中数组中的每个条目都为空。

下面是一个填充数组的例子：

for (int i = 0; i < array.length; i++) { // iterate over an array
    array[i] = getValueFor(i); // put value in the array
}