System Design - Parking Lot Design Interview Question
System Design questions are now regular part of the interview process at various organizations. They test the individuals ability to design, visualize, simulate real world scenarios, use correct data structures, apply design patterns. These questions are generally open ended. Usually the interviewer asks candidates to design system using white board. It may even be kind of pair programming where the interviewer also gives his inputs. The depth of the design solution needed depends on the interviewer. Some interviewer might be satisfied if only classes involved and the design overview is explained. While some may go into implementation details a lot.
In previous tutorial we had designed and implemented an Elevator System. In this tutorial we will be designing a parking lot and also implementing the actual solution.
For this tutorial we will be making use of the following design patterns -
- Singleton Design Pattern
- Strategy Design Pattern
- Discuss how we will be simulating the elevator design
- Identify the classes involved
- Parking Design Code - Iteration-1
- Parking Design Code - Iteration-2
Simulate the Parking Lot design
We will be simulating the scenario- A vehicle to be parked can be either a two wheeler or a for wheeler.
When the vehicle is to be parked, the owner will be provided a ticket. If there are no parking slots available, then a parking full exception will be thrown. When the vehicle is to be unparked, the owner must provide the ticket.
The parking charges will depend on -
- If it is a weekend or a weekday
- If the vehicle is a two wheeler or a four wheeler
Identify the classes involved
The Parking Lot implementation will have the following domain classes --
Enum VehicleSize - This enum will have two values TWOWHEELER and FOURWHEELER.
-
Class Vehicle - The vehicle to be parked. It has the vehicle number and the type of vehicle i.e. two wheeler or four wheeler.
-
Class Slot - This class represents the space in the parking lot which will be used to park the vehicle.
The parking lot will have two types of slots -
- Two Wheeler Parking Slots
- Four Wheeler Parking Slots
-
Class Ticket - Once the vehicle has been parked, the owner will be provided with the Ticket. It will have the slotNumber, vehicle number, time at which the
vehicle has been parked and the vehicle size.
- FourWheelerWeekDayChargeStrategy
- FourWheelerWeekendChargeStrategy
- TwoWheelerWeekDayChargeStrategy
- TourWheelerWeekDayChargeStrategy
- InvalidSlotNumberException
- InvalidVehicleNumberException
- ParkingFullException
ParkingLot Design Code - Iteration-1
In the first iteration we will implementing the code to park the vehicle. In the second iteration we will be implementing the code to unpark the vehicle and calculate the charges.We will be first be creating the required domain and exception classes we discussed before. Create the enum VehicleSize
package model;
public enum VehicleSize{
TWOWHEELER, FOURWHEELER;
}
Create the domain Vehicle class
package model;
public class Vehicle {
private String vehicleNumber;
private VehicleSize vehicleSize;
public Vehicle(String vehicleNumber, VehicleSize vehicleSize) {
this.vehicleNumber = vehicleNumber;
this.vehicleSize = vehicleSize;
}
public VehicleSize getVehicleSize() {
return vehicleSize;
}
public void setVehicleSize(VehicleSize vehicleSize) {
this.vehicleSize = vehicleSize;
}
public String getVehicleNumber() {
return vehicleNumber;
}
public void setVehicleNumber(String vehicleNumber) {
this.vehicleNumber = vehicleNumber;
}
}
Create the domain Slot class
package model;
public class Slot {
private Integer number;
private boolean isEmpty;
private Vehicle parkVehicle;
public Slot(Integer number) {
this.number = number;
}
public Vehicle getParkVehicle() {
return parkVehicle;
}
public void setParkVehicle(Vehicle parkVehicle) {
this.parkVehicle = parkVehicle;
}
public void vacateSlot() {
parkVehicle = null;
this.isEmpty = true;
}
public void occupySlot(Vehicle parkVehicle) {
this.parkVehicle = parkVehicle;
this.isEmpty = false;
}
public Integer getSlotNumber() {
return number;
}
public void setNumber(Integer number) {
this.number = number;
}
public boolean isEmpty() {
return isEmpty;
}
public void setEmpty(boolean empty) {
isEmpty = empty;
}
}
Create the domain Ticket class
package model;
import java.util.Date;
public class Ticket {
private int slotNumber;
private String vehicleNumber;
private Date date;
private VehicleSize vehicleSize;
public Ticket(int slotNumber, String vehicleNumber, VehicleSize vehicleSize, Date date) {
super();
this.slotNumber = slotNumber;
this.vehicleNumber = vehicleNumber;
this.date = date;
this.setVehicleSize(vehicleSize);
}
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
public int getSlotNumber() {
return slotNumber;
}
public void setSlotNumber(int slotNumber) {
this.slotNumber = slotNumber;
}
public String getVehicleNumber() {
return vehicleNumber;
}
public void setVehicleNumber(String vehicleNumber) {
this.vehicleNumber = vehicleNumber;
}
public VehicleSize getVehicleSize() {
return vehicleSize;
}
public void setVehicleSize(VehicleSize vehicleSize) {
this.vehicleSize = vehicleSize;
}
@Override
public String toString() {
return "Ticket [slotNumber=" + slotNumber + ", vehicleNumber=" + vehicleNumber + ", date=" + date
+ ", vehicleSize=" + vehicleSize + "]";
}
}
Next we will be creating the exception class to be thrown if no parking space is available.
package exception;
public class ParkingFullException extends Exception {
public ParkingFullException(String message) {
super(message);
}
}
Create an interface named Parking which will have two methods - park and unpark.
package service;
import exception.InvalidVehicleNumberException;
import exception.ParkingFullException;
import model.Ticket;
import model.Vehicle;
import strategy.ParkingChargeStrategy;
public interface Parking {
public Ticket park(Vehicle vehicle) throws ParkingFullException;
}
Next we will be implementing the above interface to write the logic for parking the vehicle and returning the ticket.
package service;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import exception.InvalidVehicleNumberException;
import exception.ParkingFullException;
import model.Slot;
import model.Ticket;
import model.Vehicle;
import model.VehicleSize;
import strategy.ParkingChargeStrategy;
public class ParkingLot implements Parking {
private static ParkingLot parkingLot;
private final List<Slot> twoWheelerSlots;
private final List<Slot> fourWheelerSlots;
private ParkingLot() {
this.twoWheelerSlots = new ArrayList<>();
this.fourWheelerSlots = new ArrayList<>();
}
public static ParkingLot getParkingLot() {
if (parkingLot == null)
parkingLot = new ParkingLot();
return parkingLot;
}
public static void clearAll() {
parkingLot = null;
}
public boolean initializeParkingSlots(int numberOfTwoWheelerParkingSlots, int numberOfFourWheelerParkingSlots) {
for (int i = 1; i <= numberOfTwoWheelerParkingSlots; i++) {
twoWheelerSlots.add(new Slot(i));
}
System.out.printf("Created a two wheeler parking lot with %s slots %n", numberOfTwoWheelerParkingSlots);
for (int i = 1; i <= numberOfFourWheelerParkingSlots; i++) {
fourWheelerSlots.add(new Slot(i));
}
System.out.printf("Created a four wheeler parking lot with %s slots %n", numberOfFourWheelerParkingSlots);
return true;
}
public Ticket park(Vehicle vehicle) throws ParkingFullException {
Slot nextAvailableSlot;
if (vehicle.getVehicleSize().equals(VehicleSize.FOURWHEELER)) {
nextAvailableSlot = getNextAvailableFourWheelerSlot();
} else {
nextAvailableSlot = getNextAvailableTwoWheelerSlot();
}
nextAvailableSlot.occupySlot(vehicle);
System.out.printf("Allocated slot number: %d \n", nextAvailableSlot.getSlotNumber());
Ticket ticket = new Ticket(nextAvailableSlot.getSlotNumber(), vehicle.getVehicleNumber(),
vehicle.getVehicleSize(), new Date());
return ticket;
}
private Slot getNextAvailableFourWheelerSlot() throws ParkingFullException {
for (Slot slot : fourWheelerSlots) {
if (slot.isEmpty()) {
return slot;
}
}
throw new ParkingFullException("No Empty Slot available");
}
private Slot getNextAvailableTwoWheelerSlot() throws ParkingFullException {
for (Slot slot : twoWheelerSlots) {
if (slot.isEmpty()) {
return slot;
}
}
throw new ParkingFullException("No Empty Slot available");
}
public int unPark(Ticket ticket, ParkingChargeStrategy parkingCostStrategy) throws InvalidVehicleNumberException {
int costByHours = 0;
Slot slot;
try {
if (ticket.getVehicleSize().equals(VehicleSize.FOURWHEELER)) {
slot = getFourWheelerSlotByVehicleNumber(ticket.getVehicleNumber());
} else {
slot = getTwoWheelerSlotByVehicleNumber(ticket.getVehicleNumber());
}
slot.vacateSlot();
int hours = getHoursParked(ticket.getDate(), new Date());
costByHours = getCostByHours(hours, parkingCostStrategy);
System.out.println(
"Vehicle with registration " + ticket.getVehicleNumber() + " at slot number " + slot.getSlotNumber()
+ " was parked for " + hours + " hours and the total charge is " + costByHours);
} catch (InvalidVehicleNumberException invalidVehicleNumber) {
System.out.println(invalidVehicleNumber.getMessage());
throw invalidVehicleNumber;
}
return costByHours;
}
private int getHoursParked(Date startDate, Date endDate) {
long secs = (endDate.getTime() - startDate.getTime()) / 1000;
int hours = (int) (secs / 3600);
return hours;
}
private int getCostByHours(int parkHours, ParkingChargeStrategy parkingCostStrategy) {
return parkingCostStrategy.getCharge(parkHours);
}
private Slot getFourWheelerSlotByVehicleNumber(String vehicleNumber) throws InvalidVehicleNumberException {
for (Slot slot : fourWheelerSlots) {
Vehicle vehicle = slot.getParkVehicle();
if (vehicle != null && vehicle.getVehicleNumber().equals(vehicleNumber)) {
return slot;
}
}
throw new InvalidVehicleNumberException(
"Four wheeler with registration number " + vehicleNumber + " not found");
}
private Slot getTwoWheelerSlotByVehicleNumber(String vehicleNumber) throws InvalidVehicleNumberException {
for (Slot slot : twoWheelerSlots) {
Vehicle vehicle = slot.getParkVehicle();
if (vehicle != null && vehicle.getVehicleNumber().equals(vehicleNumber)) {
return slot;
}
}
throw new InvalidVehicleNumberException("Two wheeler with registration number " + vehicleNumber + " not found");
}
}
Elevator Design Code - Iteration-2
In the second iteration we will be adding the logic to start the elevator and process any job if available
package com.javastructures;
import java.util.TreeSet;
class Elevator {
private Direction currentDirection = Direction.UP;
private State currentState = State.IDLE;
private int currentFloor = 0;
/**
* jobs which are being processed
*/
private TreeSet<Request> currentJobs = new TreeSet<>();
/**
* up jobs which cannot be processed now so put in pending queue
*/
private TreeSet<Request> upPendingJobs = new TreeSet<>();
/**
* down jobs which cannot be processed now so put in pending queue
*/
private TreeSet<Request> downPendingJobs = new TreeSet<>();
public void startElevator() {
while (true) {
if (checkIfJob()) {
if (currentDirection == Direction.UP) {
Request request = currentJobs.pollFirst();
processUpRequest(request);
if (currentJobs.isEmpty()) {
addPendingDownJobsToCurrentJobs();
}
}
if (currentDirection == Direction.DOWN) {
Request request = currentJobs.pollLast();
processDownRequest(request);
if (currentJobs.isEmpty()) {
addPendingUpJobsToCurrentJobs();
}
}
}
}
}
public boolean checkIfJob() {
if (currentJobs.isEmpty()) {
return false;
}
return true;
}
private void processUpRequest(Request request) {
// The elevator is not on the floor where the person has requested it i.e. source floor. So first bring it there.
int startFloor = currentFloor;
if (startFloor < request.getExternalRequest().getSourceFloor()) {
for (int i = startFloor; i <= request.getExternalRequest().getSourceFloor(); i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("We have reached floor -- " + i);
currentFloor = i;
}
}
// The elevator is now on the floor where the person has requested it i.e. source floor. User can enter and go to the destination floor.
System.out.println("Reached Source Floor--opening door");
startFloor = currentFloor;
for (int i = startFloor; i <= request.getInternalRequest().getDestinationFloor(); i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("We have reached floor -- " + i);
currentFloor = i;
if (checkIfNewJobCanBeProcessed(request)) {
break;
}
}
}
private void processDownRequest(Request request) {
int startFloor = currentFloor;
if (startFloor < request.getExternalRequest().getSourceFloor()) {
for (int i = startFloor; i <= request.getExternalRequest().getSourceFloor(); i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("We have reached floor -- " + i);
currentFloor = i;
}
}
System.out.println("Reached Source Floor--opening door");
startFloor = currentFloor;
for (int i = startFloor; i >= request.getInternalRequest().getDestinationFloor(); i--) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("We have reached floor -- " + i);
currentFloor = i;
if (checkIfNewJobCanBeProcessed(request)) {
break;
}
}
}
private boolean checkIfNewJobCanBeProcessed(Request currentRequest) {
if (checkIfJob()) {
if (currentDirection == Direction.UP) {
Request request = currentJobs.pollFirst();
if (request.getInternalRequest().getDestinationFloor() < currentRequest.getInternalRequest()
.getDestinationFloor()) {
currentJobs.add(request);
currentJobs.add(currentRequest);
return true;
}
currentJobs.add(request);
}
if (currentDirection == Direction.DOWN) {
Request request = currentJobs.pollLast();
if (request.getInternalRequest().getDestinationFloor() > currentRequest.getInternalRequest()
.getDestinationFloor()) {
currentJobs.add(request);
currentJobs.add(currentRequest);
return true;
}
currentJobs.add(request);
}
}
return false;
}
private void addPendingDownJobsToCurrentJobs() {
if (!downPendingJobs.isEmpty()) {
currentJobs = downPendingJobs;
currentDirection = Direction.DOWN;
} else {
currentState = State.IDLE;
}
}
private void addPendingUpJobsToCurrentJobs() {
if (!upPendingJobs.isEmpty()) {
currentJobs = upPendingJobs;
currentDirection = Direction.UP;
} else {
currentState = State.IDLE;
}
}
}
class ProcessJobWorker implements Runnable {
private Elevator elevator;
ProcessJobWorker(Elevator elevator) {
this.elevator = elevator;
}
@Override
public void run() {
/**
* start the elevator
*/
elevator.startElevator();
}
}
enum State {
MOVING, STOPPED, IDLE
}
enum Direction {
UP, DOWN
}
class Request implements Comparable<Request> {
private InternalRequest internalRequest;
private ExternalRequest externalRequest;
public Request(InternalRequest internalRequest, ExternalRequest externalRequest) {
this.internalRequest = internalRequest;
this.externalRequest = externalRequest;
}
public InternalRequest getInternalRequest() {
return internalRequest;
}
public void setInternalRequest(InternalRequest internalRequest) {
this.internalRequest = internalRequest;
}
public ExternalRequest getExternalRequest() {
return externalRequest;
}
public void setExternalRequest(ExternalRequest externalRequest) {
this.externalRequest = externalRequest;
}
@Override
public int compareTo(Request req) {
if (this.getInternalRequest().getDestinationFloor() == req.getInternalRequest().getDestinationFloor())
return 0;
else if (this.getInternalRequest().getDestinationFloor() > req.getInternalRequest().getDestinationFloor())
return 1;
else
return -1;
}
}
class ExternalRequest {
private Direction directionToGo;
private int sourceFloor;
public ExternalRequest(Direction directionToGo, int sourceFloor) {
this.directionToGo = directionToGo;
this.sourceFloor = sourceFloor;
}
public Direction getDirectionToGo() {
return directionToGo;
}
public void setDirectionToGo(Direction directionToGo) {
this.directionToGo = directionToGo;
}
public int getSourceFloor() {
return sourceFloor;
}
public void setSourceFloor(int sourceFloor) {
this.sourceFloor = sourceFloor;
}
}
class InternalRequest {
private int destinationFloor;
public InternalRequest(int destinationFloor) {
this.destinationFloor = destinationFloor;
}
public int getDestinationFloor() {
return destinationFloor;
}
public void setDestinationFloor(int destinationFloor) {
this.destinationFloor = destinationFloor;
}
}
public class TestElevator {
public static void main(String args[]) {
Elevator elevator = new Elevator();
/**
* Thread for starting the elevator
*/
ProcessJobWorker processJobWorker = new ProcessJobWorker(elevator);
Thread t2 = new Thread(processJobWorker);
t2.start();
try {
Thread.sleep(300);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
ExternalRequest er = new ExternalRequest(Direction.DOWN, 5);
InternalRequest ir = new InternalRequest(0);
Request request1 = new Request(ir, er);
}
}
Elevator Design Code - Iteration-3
In the third iteration we will be adding the logic to add jobs to the elevator
package com.javastructures;
import java.util.TreeSet;
class Elevator {
private Direction currentDirection = Direction.UP;
private State currentState = State.IDLE;
private int currentFloor = 0;
/**
* jobs which are being processed
*/
private TreeSet<Request> currentJobs = new TreeSet<>();
/**
* up jobs which cannot be processed now so put in pending queue
*/
private TreeSet<Request> upPendingJobs = new TreeSet<>();
/**
* down jobs which cannot be processed now so put in pending queue
*/
private TreeSet<Request> downPendingJobs = new TreeSet<>();
public void startElevator() {
System.out.println("The Elevator has started functioning");
while (true) {
if (checkIfJob()) {
if (currentDirection == Direction.UP) {
Request request = currentJobs.pollFirst();
processUpRequest(request);
if (currentJobs.isEmpty()) {
addPendingDownJobsToCurrentJobs();
}
}
if (currentDirection == Direction.DOWN) {
Request request = currentJobs.pollLast();
processDownRequest(request);
if (currentJobs.isEmpty()) {
addPendingUpJobsToCurrentJobs();
}
}
}
}
}
public boolean checkIfJob() {
if (currentJobs.isEmpty()) {
return false;
}
return true;
}
private void processUpRequest(Request request) {
int startFloor = currentFloor;
// The elevator is not on the floor where the person has requested it i.e. source floor. So first bring it there.
if (startFloor < request.getExternalRequest().getSourceFloor()) {
for (int i = startFloor; i <= request.getExternalRequest().getSourceFloor(); i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("We have reached floor -- " + i);
currentFloor = i;
}
}
// The elevator is now on the floor where the person has requested it i.e. source floor. User can enter and go to the destination floor.
System.out.println("Reached Source Floor--opening door");
startFloor = currentFloor;
for (int i = startFloor + 1; i <= request.getInternalRequest().getDestinationFloor(); i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("We have reached floor -- " + i);
currentFloor = i;
if (checkIfNewJobCanBeProcessed(request)) {
break;
}
}
}
private void processDownRequest(Request request) {
int startFloor = currentFloor;
if (startFloor < request.getExternalRequest().getSourceFloor()) {
for (int i = startFloor; i <= request.getExternalRequest().getSourceFloor(); i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("We have reached floor -- " + i);
currentFloor = i;
}
}
System.out.println("Reached Source Floor--opening door");
startFloor = currentFloor;
for (int i = startFloor - 1; i >= request.getInternalRequest().getDestinationFloor(); i--) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("We have reached floor -- " + i);
currentFloor = i;
if (checkIfNewJobCanBeProcessed(request)) {
break;
}
}
}
private boolean checkIfNewJobCanBeProcessed(Request currentRequest) {
if (checkIfJob()) {
if (currentDirection == Direction.UP) {
Request request = currentJobs.pollLast();
if (request.getInternalRequest().getDestinationFloor() < currentRequest.getInternalRequest()
.getDestinationFloor()) {
currentJobs.add(request);
currentJobs.add(currentRequest);
return true;
}
currentJobs.add(request);
}
if (currentDirection == Direction.DOWN) {
Request request = currentJobs.pollFirst();
if (request.getInternalRequest().getDestinationFloor() > currentRequest.getInternalRequest()
.getDestinationFloor()) {
currentJobs.add(request);
currentJobs.add(currentRequest);
return true;
}
currentJobs.add(request);
}
}
return false;
}
private void addPendingDownJobsToCurrentJobs() {
if (!downPendingJobs.isEmpty()) {
System.out.println("Pick a pending down job and execute it by putting in current job");
currentJobs = downPendingJobs;
currentDirection = Direction.DOWN;
} else {
currentState = State.IDLE;
System.out.println("The elevator is in Idle state");
}
}
private void addPendingUpJobsToCurrentJobs() {
if (!upPendingJobs.isEmpty()) {
System.out.println("Pick a pending up job and execute it by putting in current job");
currentJobs = upPendingJobs;
currentDirection = Direction.UP;
} else {
currentState = State.IDLE;
System.out.println("The elevator is in Idle state");
}
}
public void addJob(Request request) {
if (currentState == State.IDLE) {
currentState = State.MOVING;
currentDirection = request.getExternalRequest().getDirectionToGo();
currentJobs.add(request);
} else if (currentState == State.MOVING) {
if (request.getExternalRequest().getDirectionToGo() != currentDirection) {
addtoPendingJobs(request);
} else if (request.getExternalRequest().getDirectionToGo() == currentDirection) {
if (currentDirection == Direction.UP
&& request.getInternalRequest().getDestinationFloor() < currentFloor) {
addtoPendingJobs(request);
} else if (currentDirection == Direction.DOWN
&& request.getInternalRequest().getDestinationFloor() > currentFloor) {
addtoPendingJobs(request);
} else {
currentJobs.add(request);
}
}
}
}
public void addtoPendingJobs(Request request) {
if (request.getExternalRequest().getDirectionToGo() == Direction.UP) {
System.out.println("Add to pending up jobs");
upPendingJobs.add(request);
} else {
System.out.println("Add to pending down jobs");
downPendingJobs.add(request);
}
}
}
enum State {
MOVING, STOPPED, IDLE
}
enum Direction {
UP, DOWN
}
class Request implements Comparable<Request> {
private InternalRequest internalRequest;
private ExternalRequest externalRequest;
public Request(InternalRequest internalRequest, ExternalRequest externalRequest) {
this.internalRequest = internalRequest;
this.externalRequest = externalRequest;
}
public InternalRequest getInternalRequest() {
return internalRequest;
}
public void setInternalRequest(InternalRequest internalRequest) {
this.internalRequest = internalRequest;
}
public ExternalRequest getExternalRequest() {
return externalRequest;
}
public void setExternalRequest(ExternalRequest externalRequest) {
this.externalRequest = externalRequest;
}
@Override
public int compareTo(Request req) {
if (this.getInternalRequest().getDestinationFloor() == req.getInternalRequest().getDestinationFloor())
return 0;
else if (this.getInternalRequest().getDestinationFloor() > req.getInternalRequest().getDestinationFloor())
return 1;
else
return -1;
}
}
class ProcessJobWorker implements Runnable {
private Elevator elevator;
ProcessJobWorker(Elevator elevator) {
this.elevator = elevator;
}
@Override
public void run() {
/**
* start the elevator
*/
elevator.startElevator();
}
}
class AddJobWorker implements Runnable {
private Elevator elevator;
private Request request;
AddJobWorker(Elevator elevator, Request request) {
this.elevator = elevator;
this.request = request;
}
@Override
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
elevator.addJob(request);
}
}
class ExternalRequest {
private Direction directionToGo;
private int sourceFloor;
public ExternalRequest(Direction directionToGo, int sourceFloor) {
this.directionToGo = directionToGo;
this.sourceFloor = sourceFloor;
}
public Direction getDirectionToGo() {
return directionToGo;
}
public void setDirectionToGo(Direction directionToGo) {
this.directionToGo = directionToGo;
}
public int getSourceFloor() {
return sourceFloor;
}
public void setSourceFloor(int sourceFloor) {
this.sourceFloor = sourceFloor;
}
@Override
public String toString() {
return " The Elevator has been requested on floor - " + sourceFloor + " and the person wants go in the - "
+ directionToGo;
}
}
class InternalRequest {
private int destinationFloor;
public InternalRequest(int destinationFloor) {
this.destinationFloor = destinationFloor;
}
public int getDestinationFloor() {
return destinationFloor;
}
public void setDestinationFloor(int destinationFloor) {
this.destinationFloor = destinationFloor;
}
@Override
public String toString() {
return "The destinationFloor is - " + destinationFloor;
}
}
public class TestElevator {
public static void main(String args[]) {
Elevator elevator = new Elevator();
/**
* Thread for starting the elevator
*/
ProcessJobWorker processJobWorker = new ProcessJobWorker(elevator);
Thread t2 = new Thread(processJobWorker);
t2.start();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
ExternalRequest er = new ExternalRequest(Direction.UP, 0);
InternalRequest ir = new InternalRequest(5);
Request request1 = new Request(ir, er);
/**
* Pass job to the elevator
*/
new Thread(new AddJobWorker(elevator, request1)).start();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
Run the program as a Java Application -
We now process a request such that the elevator is on the Ground i.e. 0th floor and a person on 5th floor wants to go to the ground floor i.e. Oth floor
public class TestElevator {
public static void main(String args[]) {
Elevator elevator = new Elevator();
/**
* Thread for starting the elevator
*/
ProcessJobWorker processJobWorker = new ProcessJobWorker(elevator);
Thread t2 = new Thread(processJobWorker);
t2.start();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
ExternalRequest er = new ExternalRequest(Direction.DOWN, 5);
InternalRequest ir = new InternalRequest(0);
Request request1 = new Request(ir, er);
/**
* Pass job to the elevator
*/
new Thread(new AddJobWorker(elevator, request1)).start();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
Download Source Code
Download it -Elevator Design Code