Pregunta de la entrevista de Amazon: Diseñe un estacionamiento OO [cerrado]

Diseñe un estacionamiento OO. Qué clases y funciones tendrá. Debería decir, lleno, vacío y también poder encontrar un lugar para el servicio de aparcacoches. El lote cuenta con 3 tipos diferentes de estacionamiento: regular, minusválidos y compacto.

¡Gracias!

Aquí hay un comienzo rápido para hacer girar los engranajes ...

ParkingLot es una clase.

ParkingSpace es una clase.

ParkingSpace tiene una entrada.

La entrada tiene una ubicación o, más específicamente, la distancia desde la entrada.

ParkingLotSign es una clase.

ParkingLot tiene un ParkingLotSign.

ParkingLot tiene un número finito de ParkingSpaces.

HandicappedParkingSpace es una subclase de ParkingSpace.

RegularParkingSpace es una subclase de ParkingSpace.

CompactParkingSpace es una subclase de ParkingSpace.

ParkingLot mantiene una variedad de ParkingSpaces y una serie separada de ParkingSpaces vacantes en orden de distancia desde su Entrada.

Se puede indicar a ParkingLotSign que muestre "lleno", "vacío" o "en blanco / normal / parcialmente ocupado" llamando a .Full (), .Empty () o .Normal ()

Parker es una clase.

Parker puede aparcar ().

Parker puede desaparcar ().

Valet es una subclase de Parker que puede llamar a ParkingLot.FindVacantSpaceNearestEntrance (), que devuelve un ParkingSpace.

Parker tiene un ParkingSpace.

Parker puede llamar a ParkingSpace.Take () y ParkingSpace.Vacate ().

Parker llama Entrance.Entering () y Entrance.Exiting () y ParkingSpace notifica a ParkingLot cuando está ocupado o desocupado para que ParkingLot pueda determinar si está lleno o no. Si está lleno o vacío recientemente o no está lleno o vacío, debe cambiar ParkingLotSign.Full () o ParkingLotSign.Empty () o ParkingLotSign.Normal ().

HandicappedParker podría ser una subclase de Parker y CompactParker una subclase de Parker y RegularParker una subclase de Parker. (podría ser exagerado, en realidad).

En esta solución, es posible que se cambie el nombre de Parker a Automóvil.

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

Los modelos no existen de forma aislada. Las estructuras que definiría para una simulación de automóviles que ingresan a un estacionamiento, un sistema integrado que lo guía a un espacio libre, un sistema de facturación de estacionamiento de automóviles o para las puertas automáticas / máquinas expendedoras de boletos habituales en los estacionamientos son todas diferentes.

En un estacionamiento Orientado a Objetos, no habrá necesidad de asistentes porque los autos "sabrán estacionar".

Será difícil encontrar un automóvil utilizable en el lote; los modelos más comunes tendrán todas sus partes móviles expuestas como variables de miembros públicos, o serán autos "completamente encapsulados" sin ventanas ni puertas.

Los espacios de estacionamiento en nuestro estacionamiento OO no coincidirán con el tamaño y la forma de los autos (una "falta de coincidencia de impedancia" entre los espacios y los autos)

Las etiquetas de licencia de nuestro lote tendrán un punto entre cada letra y dígito. El estacionamiento para discapacitados solo estará disponible para licencias que comiencen con "_", y las licencias que comiencen con "m_" serán remolcadas.

necesitaría un estacionamiento, que contenga una matriz multidimensional (especificada en el constructor) de un tipo "espacio". El estacionamiento puede realizar un seguimiento de cuántos espacios se toman a través de llamadas a funciones que llenan y vacían espacios. El espacio puede contener un tipo enumerado que indica qué tipo de espacio es. El espacio también tiene un método tomado (). para el servicio de aparcacoches, busque el primer espacio que esté abierto y coloque el coche allí. También necesitará un objeto de automóvil para colocar en el espacio, ya sea un vehículo para discapacitados, compacto o 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;
}