Developing a Java-Based Car Park Control Interface
Explore our comprehensive guide on creating a Java GUI for car park management. This step-by-step guide will help you master GUI development while providing practical solutions to streamline car park management. Whether you're a student looking to help your Java assignment or an organization seeking efficient car park control, this resource offers valuable insights and hands-on experience. Discover how to design an intuitive interface, manage parking slots, and enhance your Java programming skills to create a user-friendly car park system.
Block 1: Car Class
```java
public class Car {
// Fields for car information
private String carNumber;
private String owner;
private boolean isStaff;
// Constructor to initialize car information
public Car(String carNumber, String owner, boolean isStaff) {
this.carNumber = carNumber;
this.owner = owner;
this.isStaff = isStaff;
}
// Getter methods to access car information
public String getCarNumber() {
return this.carNumber;
}
public String getOwner() {
return this.owner;
}
public boolean isStaff() {
return this.isStaff;
}
}
```
This block defines the Car class, representing a car in the car park. It includes fields for car number, owner, and whether it belongs to the staff. The class provides a constructor to initialize car information and getter methods to access that information. The Car class serves as a fundamental building block for the car park management system, encapsulating key car-related details. By representing cars in the system, it enables the tracking of ownership, unique identifiers, and staff distinctions, facilitating efficient car park management.
Block 2: CarPark Class
```java
import java.util.*;
public class CarPark {
// Fields for car park information
private static int staffSlots;
private static int visitorSlots;
private Map staffParkingslots = new TreeMap();
private Map visitorParkingslots = new TreeMap();
private List slotInformation = new ArrayList();
// Constructors
public CarPark() { }
public CarPark(int staffSlots, int visitorSlots) { ... }
// Methods for managing parking slots, cars, and more
public Map getAllStaffSlots() { ... }
public Map getAllVisitorSlots() { ... }
public boolean addSlot(String type) { ... }
public void setSlots(int staffSlots, int visitorSlots) { ... }
public void deleteUnoccupiedSlots() { ... }
public void getAllSlots() { ... }
public String getParkingSlotForCar(String carNumber) { ... }
public void deleteSlot(String slotID) { ... }
public String getAvailableStaffSlot() { ... }
public String getAvailableVisitorSlot() { ... }
public boolean addCar(Car car) { ... }
public boolean removeCar(String carNumber) { ... }
}
```
This block defines the CarPark class, which represents the car park itself. It includes fields to store information about staff and visitor parking slots. The class has constructors for creating a car park with a specific number of slots and various methods for managing slots and cars. The CarPark class acts as the core of the car park management system. It handles slot allocation, car parking, and slot availability. With methods for adding, removing, and listing parking slots, it forms the backbone of efficient car park control.
Block 3: CarParkGUI Class
```java
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class CarParkGUI extends JFrame {
private JButton listSlotsButton;
private JButton parkCarButton;
private JButton findCarButton;
private CarPark carPark;
public CarParkGUI() {
setTitle("Car Park Application");
setSize(400, 300);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLayout(new FlowLayout());
carPark = new CarPark(); // Initialize the car park
// Create and configure buttons
listSlotsButton = new JButton("List All Slots");
listSlotsButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
// Add code to display parking slots here
}
});
parkCarButton = new JButton("Park Car");
parkCarButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
// Add code to park a car here
}
});
findCarButton = new JButton("Find Car");
findCarButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
// Add code to find a car here
}
});
// Add buttons to the frame
add(listSlotsButton);
add(parkCarButton);
add(findCarButton);
}
public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
CarParkGUI carParkGUI = new CarParkGUI();
carParkGUI.setVisible(true);
}
});
}
}
```
This block defines the CarParkGUI class, which is the main GUI class for the car park management system. It creates a graphical user interface with buttons and event handlers to interact with the car park. The CarParkGUI class brings the system to life with a user-friendly interface. It offers buttons for listing slots, parking cars, and finding cars. Through event handlers, it enables user interactions, making the car park management system accessible and practical for both staff and visitors. This class plays a vital role in bridging the functionality of the CarPark and Car classes with a visually intuitive interface, facilitating efficient car park management.
Block 4: ParkingSlot Class
```java
public class ParkingSlot {
private String slotID;
private String slotType;
private String slotStatus;
public ParkingSlot(String slotID, String slotType, String slotStatus) {
this.slotID = slotID;
this.slotType = slotType;
this.slotStatus = slotStatus;
}
public String getSlotID() {
return slotID;
}
public String getSlotType() {
return slotType;
}
public String getSlotStatus() {
return slotStatus;
}
public void setSlotStatus(String slotStatus) {
this.slotStatus = slotStatus;
}
// You can add more methods and functionality as needed
}
```
This block defines the ParkingSlot class, which represents a parking slot in the car park. It includes fields for slot ID, type, and status. The ParkingSlot class serves as a critical component of the car park management system, providing a structured way to represent individual parking slots. It encapsulates essential information about each slot, such as its unique identifier, type (staff or visitor), and current status (occupied or not occupied). This class plays a pivotal role in tracking and managing slot details, contributing to efficient car park operations and user-friendly slot availability displays.
Block 5: SlotPopup Class
```java
import java.awt.*;
import java.util.*;
import javax.swing.*;
public class SlotPopup extends JDialog {
public SlotPopup(Frame parent, Map staffSlots, Map visitorSlots) {
super(parent, "All Slots", true);
setSize(400, 300);
setLocationRelativeTo(parent);
JPanel panel = new JPanel(new GridLayout(0, 1));
JButton staffHeaderButton = new JButton("Staff Slots");
staffHeaderButton.setBackground(Color.RED);
panel.add(staffHeaderButton);
for (Map.Entry entry : staffSlots.entrySet()) {
String slotID = entry.getKey();
String car = entry.getValue();
String status = car.equals("not occupied") ? "Not Occupied" : "Occupied with Car: " + car;
String slotInfo = "Slot ID: " + slotID + ", Status: " + status;
JButton button = new JButton(slotInfo);
// Set the background color based on the slot status
if (car.equals("not occupied")) {
button.setBackground(Color.GREEN);
} else {
button.setBackground(Color.YELLOW);
}
panel.add(button);
}
JButton visitorHeaderButton = new JButton("Visitor Slots");
visitorHeaderButton.setBackground(Color.RED);
panel.add(visitorHeaderButton);
for (Map.Entry entry : visitorSlots.entrySet()) {
String slotID = entry.getKey();
String car = entry.getValue();
String status = car.equals("not occupied") ? "Not Occupied" : "Occupied with Car: " + car;
String slotInfo = "Slot ID: " + slotID + ", Status: " + status;
JButton button = new JButton(slotInfo);
// Set the background color based on the slot status
if (car.equals("not occupied")) {
button.setBackground(Color.GREEN);
} else {
button.setBackground(Color.YELLOW);
}
panel.add(button);
}
JScrollPane scrollPane = new JScrollPane(panel);
scrollPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
getContentPane().add(scrollPane, BorderLayout.CENTER);
}
}
```
This block defines the SlotPopup class, which is a popup window that displays information about parking slots in the car park. It includes buttons for staff and visitor slots and their respective statuses. The SlotPopup class enhances the user experience by offering a visual representation of parking slot information. It allows users to view the status of both staff and visitor slots conveniently. The inclusion of buttons for different slot types streamlines the user's ability to access relevant information. This class plays a crucial role in presenting car park slot data in an accessible and organized manner, improving overall car park management efficiency.
Conclusion
In conclusion, this guide has provided a comprehensive exploration of creating a Java-based graphical user interface (GUI) for effective car park management. By combining Java programming with user-friendly design, you've learned how to add and remove cars, list parking slots, find cars by their numbers, and more. Whether you're a Java enthusiast looking to enhance your coding skills or an organization seeking a practical car park management solution, this guide equips you with valuable insights and the tools to implement a functional and user-friendly car park system. Happy coding!