Pergunta para entrevista da Amazon: Projete um estacionamento OO [fechado]

Projete um estacionamento OO. Que classes e funções terá. Deve dizer, cheio, vazio e também ser capaz de encontrar vaga para estacionamento com manobrista. O lote possui 3 tipos de estacionamento: regular, para deficientes e compacto.

Obrigado!

Aqui está um começo rápido para fazer as engrenagens girarem ...

ParkingLot é uma classe.

ParkingSpace é uma classe.

ParkingSpace tem uma entrada.

A entrada tem uma localização ou mais especificamente, a distância da entrada.

ParkingLotSign é uma classe.

ParkingLot tem um ParkingLotSign.

ParkingLot tem um número finito de ParkingSpaces.

HandicappedParkingSpace é uma subclasse de ParkingSpace.

RegularParkingSpace é uma subclasse de ParkingSpace.

CompactParkingSpace é uma subclasse de ParkingSpace.

ParkingLot mantém um conjunto de ParkingSpaces e um conjunto separado de ParkingSpaces vagos em ordem de distância de sua Entrada.

O ParkingLotSign pode ser instruído a exibir "cheio", "vazio" ou "em branco / normal / parcialmente ocupado" chamando .Full (), .Empty () ou .Normal ()

Parker é uma classe.

Parker pode estacionar ().

Parker pode desestacionar ().

Valet é uma subclasse de Parker que pode chamar ParkingLot.FindVacantSpaceNearestEntrance (), que retorna um ParkingSpace.

Parker tem um ParkingSpace.

Parker pode chamar ParkingSpace.Take () e ParkingSpace.Vacate ().

Parker chama Entrance.Entering () e Entrance.Exiting () e ParkingSpace notifica ParkingLot quando está ocupado ou desocupado para que ParkingLot possa determinar se está cheio ou não. Se estiver cheio ou vazio recentemente ou não estiver cheio ou vazio, deve alterar o ParkingLotSign.Full () ou ParkingLotSign.Empty () ou ParkingLotSign.Normal ().

HandicappedParker poderia ser uma subclasse de Parker e CompactParker uma subclasse de Parker e RegularParker uma subclasse de Parker. (pode ser um exagero, na verdade.)

Nesta solução, é possível que Parker seja renomeado para Car.

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,
}

Os modelos não existem isoladamente. As estruturas que você definiria para uma simulação de entrada de carros em um estacionamento, um sistema embutido que o orienta para uma vaga livre, um sistema de faturamento de estacionamento ou para os portões / máquinas de bilhetes automáticos usuais em estacionamentos são todos diferentes.

Em um estacionamento Orientado a Objetos, não haverá necessidade de atendentes, pois os carros "saberão estacionar".

Encontrar um carro utilizável no estacionamento será difícil; os modelos mais comuns terão todas as partes móveis expostas como variáveis ​​de membro público ou serão carros "totalmente encapsulados" sem janelas ou portas.

As vagas de estacionamento em nosso estacionamento OO não corresponderão ao tamanho e formato dos carros (uma "incompatibilidade de impedância" entre as vagas e os carros)

As etiquetas de licença em nosso lote terão um ponto entre cada letra e dígito. O estacionamento para deficientes só estará disponível para licenças começando com "_", e as licenças começando com "m_" serão rebocadas.

você precisaria de um estacionamento, que contivesse uma matriz multidimensional (especificada no construtor) de um tipo "espaço". O estacionamento pode controlar quantas vagas são ocupadas por meio de chamadas a funções que preenchem e esvaziam as vagas. O espaço pode conter um tipo enumerado que indica que tipo de espaço ele é. O espaço também tem um método taken (). para o estacionamento com manobrista, basta encontrar a primeira vaga que estiver aberta e colocar o carro lá. Você também precisará de um objeto Carro para colocar no espaço, que acomoda se é um veículo para deficientes físicos, compacto ou regular.

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;
}