Question d'entretien d'Amazon: Concevoir un parking OO [fermé]

Concevez un parking OO. Quelles classes et fonctions aura-t-il. Il faut dire, plein, vide et aussi pouvoir trouver une place pour le service de voiturier. Le terrain dispose de 3 types de stationnement différents: régulier, handicapé et compact.

Merci!

Voici un démarrage rapide pour faire tourner les vitesses ...

ParkingLot est une classe.

ParkingSpace est une classe.

ParkingSpace a une entrée.

L'entrée a un emplacement ou, plus précisément, la distance de l'entrée.

ParkingLotSign est une classe.

ParkingLot a un ParkingLotSign.

ParkingLot a un nombre fini de ParkingSpaces.

HandicappedParkingSpace est une sous-classe de ParkingSpace.

RegularParkingSpace est une sous-classe de ParkingSpace.

CompactParkingSpace est une sous-classe de ParkingSpace.

ParkingLot conserve un éventail de ParkingSpaces et un tableau séparé de ParkingSpaces vacants par ordre de distance de son entrée.

ParkingLotSign peut être invité à afficher «plein», «vide» ou «vide / normal / partiellement occupé» en appelant .Full (), .Empty () ou .Normal ()

Parker est une classe.

Parker peut se garer ().

Parker peut Unpark ().

Valet est une sous-classe de Parker qui peut appeler ParkingLot.FindVacantSpaceNearestEntrance (), qui renvoie un ParkingSpace.

Parker a un ParkingSpace.

Parker peut appeler ParkingSpace.Take () et ParkingSpace.Vacate ().

Parker appelle Entrance.Entering () et Entrance.Exiting () et ParkingSpace informe ParkingLot quand il est pris ou libéré afin que ParkingLot puisse déterminer s'il est plein ou non. S'il est nouvellement plein ou nouvellement vide ou nouvellement pas plein ou vide, il devrait changer le ParkingLotSign.Full () ou ParkingLotSign.Empty () ou ParkingLotSign.Normal ().

HandicappedParker pourrait être une sous-classe de Parker et CompactParker une sous-classe de Parker et RegularParker une sous-classe de Parker. (peut-être exagéré, en fait.)

Dans cette solution, il est possible que Parker soit renommé 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,
}

Les modèles n'existent pas isolément. Les structures que vous définiriez pour une simulation de voitures entrant dans un parking, un système embarqué qui vous guide vers une place libre, un système de facturation de parking ou pour les portails / distributeurs automatiques habituels dans les parkings sont toutes différentes.

Dans un parking orienté objet, il n'y aura pas besoin de préposés car les voitures «sauront se garer».

Trouver une voiture utilisable sur le terrain sera difficile; les modèles les plus courants auront soit toutes leurs pièces mobiles exposées en tant que variables publiques, soit des voitures «entièrement encapsulées» sans fenêtres ni portes.

Les places de parking de notre parking OO ne correspondront pas à la taille et à la forme des voitures (un "décalage d'impédance" entre les places et les voitures)

Les étiquettes de licence sur notre lot auront un point entre chaque lettre et chaque chiffre. Le stationnement pour handicapés ne sera disponible que pour les licences commençant par «_», et les licences commençant par «m_» seront remorquées.

vous auriez besoin d'un parking, qui contient un tableau multidimensionnel (spécifié dans le constructeur) d'un type "espace". Le parking peut suivre le nombre de places occupées via des appels à des fonctions qui remplissent et vident des espaces. L'espace peut contenir un type énuméré qui indique de quel type d'espace il s'agit. Space a également une méthode prise (). pour le service de voiturier, il suffit de trouver le premier espace ouvert et d'y mettre la voiture. Vous aurez également besoin d'un objet Car à placer dans l'espace, qu'il s'agisse d'un véhicule handicapé, compact ou ordinaire.

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