如何为健身房设计可扩展多类型套餐管理系统？求面向对象解决方案

Hey Daniel, great call planning for flexibility upfront—nothing kills a small system faster than having to rewrite everything when the business grows! Here's an object-oriented approach that keeps your current implementation minimal but makes future extensions straightforward:

Start by defining an abstract class (or interface, depending on your language) that captures the shared behavior of all gym packages. This way, every new package type you add later will adhere to a common contract, making your system easy to maintain.

For example, in Java:

public abstract class GymPackage {
    protected String name;
    protected double price;
    protected int totalSessions;
    protected int remainingSessions;

    public GymPackage(String name, double price, int totalSessions) {
        this.name = name;
        this.price = price;
        this.totalSessions = totalSessions;
        this.remainingSessions = totalSessions;
    }

    // Every package needs to handle session usage differently
    public abstract boolean useSession();

    // Shared method to get package details
    public String getPackageDetails() {
        return String.format("%s - $%.2f | Total Sessions: %d, Remaining: %d",
            name, price, totalSessions, remainingSessions);
    }

    // Add other shared logic here (like renewals, if needed)
}

Right now, you only need the 30-session single training package. Create a concrete class that extends the abstract GymPackage and implements the specific logic for this package:

public class SingleSessionPackage extends GymPackage {
    // Default constructor for the 30-session package
    public SingleSessionPackage() {
        super("30次单人训练套餐", 299.99, 30);
    }

    @Override
    public boolean useSession() {
        if (remainingSessions > 0) {
            remainingSessions--;
            return true;
        }
        System.out.println("套餐次数已用完，请续费！");
        return false;
    }
}

When your friend expands to group training or scheduled courses, you just add new classes that extend GymPackage—no need to touch existing code. Here are quick examples:

Group Training Package #

public class GroupTrainingPackage extends GymPackage {
    private int maxParticipantsPerSession;

    public GroupTrainingPackage(String name, double price, int totalSessions, int maxParticipants) {
        super(name, price, totalSessions);
        this.maxParticipantsPerSession = maxParticipants;
    }

    @Override
    public boolean useSession() {
        // Add group-specific logic here (e.g., check if enough participants are registered)
        if (remainingSessions > 0) {
            remainingSessions--;
            System.out.println("团体训练已使用，剩余次数：" + remainingSessions);
            return true;
        }
        System.out.println("团体套餐次数已用完！");
        return false;
    }

    // Group-specific method
    public int getMaxParticipants() {
        return maxParticipantsPerSession;
    }
}

Scheduled Course Package #

import java.time.LocalDate;

public class ScheduledCoursePackage extends GymPackage {
    private LocalDate expirationDate;

    public ScheduledCoursePackage(String name, double price, int totalSessions, LocalDate expirationDate) {
        super(name, price, totalSessions);
        this.expirationDate = expirationDate;
    }

    @Override
    public boolean useSession() {
        // First check if the package is expired
        if (LocalDate.now().isAfter(expirationDate)) {
            System.out.println("课程套餐已过期，请重新购买！");
            return false;
        }
        if (remainingSessions > 0) {
            remainingSessions--;
            return true;
        }
        System.out.println("课程次数已用完！");
        return false;
    }

    // Course-specific method
    public boolean isExpired() {
        return LocalDate.now().isAfter(expirationDate);
    }
}

Use the abstract GymPackage type in your main management system to handle all package types uniformly. This follows the open/closed principle—you can add new packages without modifying existing system code:

import java.util.ArrayList;
import java.util.List;

public class GymManagementSystem {
    private List<GymPackage> customerPackages = new ArrayList<>();

    public void addPackage(GymPackage packageToAdd) {
        customerPackages.add(packageToAdd);
    }

    public void useSession(int packageIndex) {
        if (packageIndex >= 0 && packageIndex < customerPackages.size()) {
            GymPackage pkg = customerPackages.get(packageIndex);
            pkg.useSession();
            System.out.println("当前套餐状态：" + pkg.getPackageDetails());
        } else {
            System.out.println("无效的套餐编号！");
        }
    }

    public void displayAllPackages() {
        for (int i = 0; i < customerPackages.size(); i++) {
            System.out.println(String.format("套餐 %d: %s", i+1, customerPackages.get(i).getPackageDetails()));
        }
    }
}

• Minimal now: You only write the abstract class and the single session package to start—no over-engineering.
• Flexible later: New packages fit right in without breaking existing code.
• Maintainable: Each package has a single responsibility, so debugging or updating logic is isolated to one class.

This setup gives you the best of both worlds: a simple system today that can grow seamlessly with your friend's gym.

内容的提问来源于stack exchange，提问作者DanielM