Object-Oriented Parking Lot System Design: Core Architecture Analysis Based on Inheritance and Composition Patterns

Application of Inheritance and Polymorphism

Through inheritance mechanisms, different types of parking spaces and parkers can share base class attributes and methods while implementing specific behaviors. For example, HandicappedParkingSpace inherits from ParkingSpace and can add additional accessibility features; similarly, HandicappedParker and CompactParker as subclasses of Parker can override parking rules to accommodate special needs. This design enhances code reusability and extensibility, allowing easy addition of new parking space or parker types.

State Management and Interaction Flow

The status updates of the parking lot rely on collaboration among components. When Parker calls ParkingSpace.Take() or Vacate(), the parking space notifies ParkingLot of changes in occupancy. ParkingLot then checks the occupancy status and, if a change occurs (e.g., from not full to full), calls the corresponding method of ParkingLotSign to update the display. This event-driven design ensures state consistency and reduces coupling.

Code Implementation Example

The following is a simplified Java code example demonstrating the implementation of core classes. Note that the code is refactored based on an understanding of design concepts, not directly copied.

public class ParkingLot {
    private List<ParkingSpace> allSpaces;
    private List<ParkingSpace> vacantSpaces;
    private ParkingLotSign sign;

    public ParkingLot(List<ParkingSpace> spaces) {
        this.allSpaces = spaces;
        this.vacantSpaces = new ArrayList<>(spaces);
        this.sign = new ParkingLotSign();
        updateSign();
    }

    public ParkingSpace findNearestVacant(ParkingType type) {
        for (ParkingSpace space : vacantSpaces) {
            if (space.getType() == type) {
                return space;
            }
        }
        return null;
    }

    public void parkVehicle(Parker parker, ParkingType type) {
        ParkingSpace space = findNearestVacant(type);
        if (space != null) {
            space.take(parker);
            vacantSpaces.remove(space);
            updateSign();
        }
    }

    public void releaseVehicle(Parker parker) {
        for (ParkingSpace space : allSpaces) {
            if (space.isOccupiedBy(parker)) {
                space.vacate();
                vacantSpaces.add(space);
                updateSign();
                break;
            }
        }
    }

    private void updateSign() {
        if (vacantSpaces.isEmpty()) {
            sign.displayFull();
        } else if (vacantSpaces.size() == allSpaces.size()) {
            sign.displayEmpty();
        } else {
            sign.displayNormal();
        }
    }
}

public abstract class ParkingSpace {
    private ParkingType type;
    private int distanceFromEntrance;
    private Parker occupiedBy;

    public ParkingSpace(ParkingType type, int distance) {
        this.type = type;
        this.distanceFromEntrance = distance;
        this.occupiedBy = null;
    }

    public void take(Parker parker) {
        this.occupiedBy = parker;
    }

    public void vacate() {
        this.occupiedBy = null;
    }

    public boolean isOccupiedBy(Parker parker) {
        return this.occupiedBy != null && this.occupiedBy.equals(parker);
    }

    public ParkingType getType() { return type; }
}

public class HandicappedParkingSpace extends ParkingSpace {
    public HandicappedParkingSpace(int distance) {
        super(ParkingType.HANDICAPPED, distance);
    }
}

public enum ParkingType {
    REGULAR, HANDICAPPED, COMPACT
}

public class ParkingLotSign {
    public void displayFull() {
        System.out.println("Full");
    }

    public void displayEmpty() {
        System.out.println("Empty");
    }

    public void displayNormal() {
        System.out.println("Normal");
    }
}

public class Parker {
    private String id;

    public Parker(String id) {
        this.id = id;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Parker parker = (Parker) obj;
        return id.equals(parker.id);
    }
}

public class Valet extends Parker {
    public Valet(String id) {
        super(id);
    }

    public ParkingSpace findNearestSpace(ParkingLot lot, ParkingType type) {
        return lot.findNearestVacant(type);
    }
}

In this example, ParkingLot manages the list of spaces and status, ParkingSpace and its subclasses encapsulate space attributes, ParkingLotSign handles display logic, and Parker and Valet represent parkers. Through methods like findNearestVacant and updateSign, the system implements the required functionalities.

Design Considerations and Optimization Suggestions

In Answer 2, Vector and iterators are used to manage spaces, but in modern Java development, ArrayList and enhanced for-loops are recommended for better performance. Additionally, renaming Parker to Vehicle might align better with domain language, but clarity in class responsibilities should be ensured. To support concurrent access, synchronization mechanisms or thread-safe collections could be considered. Status updates could be further decoupled using the observer pattern, allowing ParkingLotSign to automatically respond to space changes.

Conclusion

The design of an object-oriented parking lot system demonstrates how to decompose complex requirements into manageable classes, utilizing inheritance, composition, and event-driven approaches to achieve modularity. Through the interaction of core classes, the system efficiently handles space allocation, status display, and special services like valet parking. In practical applications, developers should adjust the design based on specific scenarios, such as adding billing, reservation features, or integrating sensor data to build smarter parking solutions.