如何配置連接到幾個都變得更具體的幾個類的Java方法？

Question

該程序的所有模板 。 這是過去的任務，但在這一點上，我只是想了解發生了什么。

在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) return order;

/**
 * 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循環。 目前，您正在返回一個Array，其中數組中的每個條目均為null。

這是填充數組的示例：

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