Oop 亚马逊采访问题：设计一个面向对象的停车场

设计一个面向对象的停车场。它将具有哪些类和函数。它应该说是满的，空的，还可以找到代客泊车的地方。停车场有三种不同类型的停车场：普通停车场、残疾人停车场和小型停车场

---

谢谢

这里有一个快速开始，让齿轮转动

停车场是一个班级

停车场是一个班级

停车场有一个入口

入口有一个位置，或者更具体地说，距离入口的距离

ParkingLotSign是一个类

停车场有停车标志

停车场有有限的停车空间

ParkingSpace是ParkingSpace的一个子类

RegularParkingSpace是ParkingSpace的一个子类

CompactParkingSpace是ParkingSpace的一个子类

停车场保留了一排停车空间，以及一排单独的空置停车空间，按距离入口的顺序排列

通过调用.full（）、.empty（）或.normal（）可以告诉ParkingLotSign显示“满”、“空”或“空白/正常/部分占用”

帕克是一个班

帕克可以停车

帕克可以说：（）

Valet是Parker的一个子类，可以调用ParkingLot.FindVacantSpaceNearestEntrance（），它返回ParkingSpace

帕克有一个停车场

Parker可以调用ParkingSpace.Take（）和ParkingSpace.vacue（）

Parker调用entry.Entering（）和entry.exit（），ParkingSpace会在停车场被占用或腾空时通知停车场，以便停车场可以确定停车场是否已满。如果新满或新空或新不满或新不空，则应更改ParkingLotSign.full（）或ParkingLotSign.empty（）或ParkingLotSign.Normal（）

Parker可以是Parker的子类，CompactParker可以是Parker的子类，RegularParker可以是Parker的子类。（实际上，这可能有点过头了。）

---

在这个解决方案中，帕克可能被重命名为汽车。

在面向对象的停车场中，将不需要服务员，因为汽车将“知道如何停车”

在停车场上找到一辆可用的汽车将是困难的；最常见的车型要么将其所有运动部件作为公共成员变量公开，要么将其“完全封装”为没有门窗的汽车

我们OO停车场的停车位与汽车的大小和形状不匹配（停车位和汽车之间的“阻抗不匹配”）

---

我们地块上的许可证标签将在每个字母和数字之间有一个点。残疾人停车场仅适用于以“u”开头的许可证，以“m_u”开头的许可证将被拖走。

您需要一个停车场，该停车场容纳一个“空间”类型的多维数组（在构造器中指定）。停车场可以通过调用填充和清空空间的函数来跟踪占用了多少空间。空间可以容纳一个枚举类型，告诉它是什么类型的空间。空格还有一个take（）方法。对于代客泊车，只需找到第一个空位，然后把车停在那里。您还需要在空间中放置一个汽车对象，以容纳残疾人、小型车或普通车

class ParkingLot
{
    Space[][] spaces;

    ParkingLot(wide, long); // constructor

    FindOpenSpace(TypeOfCar); // find first open space where type matches
}

enum TypeOfSpace = {compact, handicapped, regular };
enum TypeOfCar = {compact, handicapped, regular };

class Space
{
    TypeOfSpace type;
    bool empty;
    // gets and sets here
    // make sure car type
}

class car
{
    TypeOfCar type;
}

---

模型不是孤立存在的。您为模拟进入停车场的汽车、引导您进入空闲空间的嵌入式系统、停车计费系统或停车场常用的自动门/售票机定义的结构都是不同的

公共级停车场
public class ParkingLot 
{
    Vector<ParkingSpace> vacantParkingSpaces = null;
    Vector<ParkingSpace> fullParkingSpaces = null;

    int parkingSpaceCount = 0;

    boolean isFull;
    boolean isEmpty;

    ParkingSpace findNearestVacant(ParkingType type)
    {
        Iterator<ParkingSpace> itr = vacantParkingSpaces.iterator();

        while(itr.hasNext())
        {
            ParkingSpace parkingSpace = itr.next();

            if(parkingSpace.parkingType == type)
            {
                return parkingSpace;
            }
        }
        return null;
    }

    void parkVehicle(ParkingType type, Vehicle vehicle)
    {
        if(!isFull())
        {
            ParkingSpace parkingSpace = findNearestVacant(type);

            if(parkingSpace != null)
            {
                parkingSpace.vehicle = vehicle;
                parkingSpace.isVacant = false;

                vacantParkingSpaces.remove(parkingSpace);
                fullParkingSpaces.add(parkingSpace);

                if(fullParkingSpaces.size() == parkingSpaceCount)
                    isFull = true;

                isEmpty = false;
            }
        }
    }

    void releaseVehicle(Vehicle vehicle)
    {
        if(!isEmpty())
        {
            Iterator<ParkingSpace> itr = fullParkingSpaces.iterator();

            while(itr.hasNext())
            {
                ParkingSpace parkingSpace = itr.next();

                if(parkingSpace.vehicle.equals(vehicle))
                {
                    fullParkingSpaces.remove(parkingSpace);
                    vacantParkingSpaces.add(parkingSpace);

                    parkingSpace.isVacant = true;
                    parkingSpace.vehicle = null;

                    if(vacantParkingSpaces.size() == parkingSpaceCount)
                        isEmpty = true;

                    isFull = false;
                }
            }
        }
    }

    boolean isFull()
    {
        return isFull;
    }

    boolean isEmpty()
    {
        return isEmpty;
    }
}

public class ParkingSpace 
{
    boolean isVacant;
    Vehicle vehicle;
    ParkingType parkingType;
    int distance;
}

public class Vehicle 
{
    int num;
}

public enum ParkingType
{
    REGULAR,
    HANDICAPPED,
    COMPACT,
    MAX_PARKING_TYPE,
}

{
向量vacantparkingspace=null；
向量fullparkingspace=null；
int parkingSpaceCount=0；
布尔是满的；
布尔等空；
ParkingSpace FindNearestSpank（ParkingType类型）
{
迭代器itr=vacantparkingspace.Iterator（）；
while（itr.hasNext（））
{
ParkingSpace ParkingSpace=itr.next（）；
if（parkingSpace.parkingType==类型）
{
返回停车空间；
}
}
返回null；
}
无效驻车（驻车类型，车辆）
{
如果（！isFull（））
{
ParkingSpace ParkingSpace=FindNearestSpank（类型）；
如果（驻车空间！=null）
{
parkingSpace.vehicle=车辆；
parkingSpace.ispensible=false；
真空停车空间。移除（停车空间）；
fullparkingspace.add（parkingSpace）；
if（fullParkingSpaces.size（）==ParkingSpacesCount）
isFull=true；
isEmpty=false；
}
}
}
无效释放车辆（车辆）
{
如果（！isEmpty（））
{
迭代器itr=fullparkingspace.Iterator（）；
while（itr.hasNext（））
{
ParkingSpace ParkingSpace=itr.next（）；
if（驻车空间车辆等于（车辆））
{
完全驻车空间。删除（驻车空间）；
vacantparkingspace.add（parkingSpace）；
parkingSpace.ispensible=true；
parkingSpace.vehicle=null；
if（vacantParkingSpaces.size（）==parkingSpaceCount）
isEmpty=true；
isFull=false；
}
}
}
}
布尔isFull（）
{
返回已满；
}
布尔isEmpty（）
{
返回是空的；
}
}
公共停车场
{
布尔值是空的；
车辆；
ParkingType ParkingType；
整数距离；
}
公车
{
int-num；
}
公共枚举ParkingType
{
有规律的
残疾人,，
契约
最大停车位类型，
}

请不要忘记汽车。为什么停车场必须是一个班级？我认为没有必要为它创建对象？任何时候，任何停车位都必须是残疾人、普通或紧凑型停车位。停车空间应该是一个界面，而不是