Define Class Members

public class Vehicle{
    private final int ID;
    private  float size;
    private String model;
    private String ownerName;
    public Vehicle(float size, String model, String ownerName){
        this.ID = new Random().nextInt(100000);
        this.size = size;
        this.model = model;
        this.ownerName = ownerName;
    }
    public int getID(){
        return this.ID;
    }
    public float getSize(){return this.size;}
    public String getModel(){
        return this.model;
    }
    public String getOwnerName() {
        return ownerName;
    }
    public void setModel(String model) {
        this.model = model;
    }
    public void setOwnerName(String ownerName) {
        this.ownerName = ownerName;
    }

    public void setSize(float size) {
        this.size = size;
    }
}

public interface ISpot {
     boolean checkSpotSize(float carSize);
     public int getID();
     public float getFeesPerHour();
     public int getFloorNumber();
     public float getSize();
     public void setSize(float size);
     public void setFeesPerHour(float feesPerHour);
     public void setFloorNumber(int floorNumber);
     public VehicleType getType();
}

public abstract class Spot implements ISpot {
    protected float feesPerHour;
    protected VehicleType type;
    protected int ID ;
    protected float size;
    protected int floorNumber;
    public boolean checkSpotSize(float carSize){
        return (this.getSize() >= carSize);
    }
    public int getID() {return ID;}
    public float getFeesPerHour() {return feesPerHour;}
    public int getFloorNumber() {
        return floorNumber;
    }
    public float getSize() {return size;}
    public VehicleType getType(){return type;}
    public void setSize(float size) {this.size = size;}
    public void setFeesPerHour(float fees) {feesPerHour = fees;}
    public void setFloorNumber(int floorNumber) {
        this.floorNumber = floorNumber;
    }
}


public class BikeSpot extends Spot{
    public BikeSpot(int ID, float size, int floorNumber){
        this.ID = ID;
        this.floorNumber = floorNumber;
        this.size = size;
        this.type = VehicleType.Bike;
        this.feesPerHour = 50;
    }
}

public class CarSpot extends Spot{
    public CarSpot(int ID, float size, int floorNumber){
        this.ID = ID;
        this.floorNumber = floorNumber;
        this.size = size;
        this.type = VehicleType.Car;
        this.feesPerHour = 100;
    }
}
public class SpotFactory {
    private static final AtomicInteger counter = new AtomicInteger();
    public static ISpot getInstance(VehicleType type, float size, int floorNumber){
        ISpot spot;
        int id = counter.incrementAndGet();
        if(type == VehicleType.Car)
            spot = new CarSpot(id, size, floorNumber);
        else if (type == VehicleType.Bike) {
            spot = new BikeSpot(id, size, floorNumber);
        }else{
            throw new IllegalArgumentException("The available spots type for now are Car and Bike");
        }
        return spot;
    }
}
public class SpotService {
    private static SpotService spotService;
    private final Map<Integer, ISpot> spots = new HashMap<>();

    public static synchronized  SpotService getInstance(){
        if(spotService == null)
            spotService = new SpotService();
        return spotService;
    }
    public void addNewSpot(ISpot spot){
        spots.put(spot.getID(), spot);
    }
    public void removeSpot(int spotId){
        spots.remove(spotId);
    }
    public Collection<ISpot> getAllSpots() {
        return spots.values();
    }
}
public enum VehicleType {
    Car,
    Bike
}
public class Booking {
    private final int ID;
    private final Vehicle car;
    private final ISpot spot;
    private final LocalTime startTime;
    private LocalTime endTime;
    private float totalFees;

    public Booking(Vehicle car, ISpot spot, LocalTime endTime){
        this.ID = new Random().nextInt(100000);
        this.car = car;
        this.spot = spot;
        this.startTime  = LocalTime.now();
        this.endTime = endTime;
    }
    public Booking(Vehicle car, ISpot spot, LocalTime startTime, LocalTime endTime){
        this.ID = new Random().nextInt(100000);
        this.car = car;
        this.spot = spot;
        this.startTime  = startTime;
        this.endTime = endTime;
    }
    public float getTotalFees(){
        return this.totalFees;
    }
    public void setTotalFees(float totalFees) {this.totalFees = totalFees;}
    public Vehicle getCar() {
        return car;
    }
    public ISpot getSpot() {
        return spot;
    }
    public LocalTime getStartTime() {
        return startTime;
    }
    public LocalTime getEndTime() {
        return endTime;
    }
    public int getID() {
        return ID;
    }
}

public class BookingService {
    private static BookingService bookingService;
    private final Map<Integer, Booking> bookings = new HashMap<>();

    public static synchronized BookingService getInstance() {
        if(bookingService == null)
            bookingService = new BookingService();
        return bookingService;
    }

    public boolean checkBookingAvailability(float size, ISpot spot, LocalTime startTime, LocalTime endTime){
        if(!spot.checkSpotSize(size)){
            throw new IllegalArgumentException("The car size is bigger than spot size");
        }
        bookings.forEach((key, value) -> {
            ISpot curSpot = value.getSpot();
            if(curSpot.getID() == spot.getID() && !(endTime.isBefore(value.getStartTime()) || startTime.isAfter(value.getEndTime()))){
                throw new UnsupportedOperationException("This spot is reserved during this time");
            }
        });
        return true;
    }

    public void addNewBooking(Booking booking){
        bookings.put(booking.getID(), booking);
    }

    public Booking getBooking(int bookingId){
        return bookings.get(bookingId);
    }

    public void releaseReservation(Booking bookingModel){
        Duration duration = Duration.between(bookingModel.getStartTime(), bookingModel.getEndTime());
        float hours = (float) duration.toMinutes() / 60;
        bookingModel.setTotalFees(hours * bookingModel.getSpot().getFeesPerHour());
    }
}
public class Parking {
    private static Parking parking;
    private static float totalProfit = 0;

    public static synchronized Parking getInstance(){
        if(parking == null){
            parking = new Parking();
        }
        return parking;
    }
    public void addNewInstantlyBooking(ISpot spot, Vehicle car, LocalTime endTime){
        LocalTime startTime = LocalTime.now();
        try{
            if(BookingService.getInstance().checkBookingAvailability(car.getSize(), spot, startTime, endTime)){
                Booking bookingSpot = new Booking(car, spot, endTime);
                BookingService.getInstance().addNewBooking(bookingSpot);
            }
        }catch (UnsupportedOperationException | IllegalArgumentException error){
            System.out.println(error.getMessage());
        }
    }
    public void addNewFutureBooking(ISpot spot, Vehicle car, LocalTime startTime, LocalTime endTime){
        try{
            if(BookingService.getInstance().checkBookingAvailability(car.getSize(), spot, startTime, endTime)){
                Booking bookingSpot = new Booking(car, spot, startTime, endTime);
                BookingService.getInstance().addNewBooking(bookingSpot);
            }
        }catch (UnsupportedOperationException | IllegalArgumentException error){
            System.out.println(error.getMessage());
        }
    }
    public void releaseBooking(int bookingId){
        Booking bookingSpot = BookingService.getInstance().getBooking(bookingId);
        BookingService.getInstance().releaseReservation(bookingSpot);
        totalProfit += bookingSpot.getTotalFees();
        System.out.println("Total fees is: " + bookingSpot.getTotalFees());
    }
    public static void getTotalOwnerProfit(){
        System.out.println("Total profits is: " + totalProfit);
    }

    public Collection<ISpot> getAllSpots() {
        return SpotService.getInstance().getAllSpots();
    }
}
Submissions

Displaying Solutions with Scores Ranging from 1 to 10
