Decidere il modo migliore di modellare un periodo di applicazione o un periodo di tempo per un programma

Sto facendo uno schedulatore di eventi sportivi per calcolare i possibili calendari dei dati e delle configurazioni iniziali. Ci sono tre domini principali: giocatori, tribunali e timeslot. La mia domanda riguarda quest'ultimo.

L'idea iniziale era che una finestra temporale sarebbe stata solo una rappresentazione astratta di un periodo di tempo, e dare più senso sarebbe stata la responsabilità di chiunque avesse definito il dominio del tempo. Pertanto, ad esempio, potresti decidere che il "periodo di applicazione 1" viene mappato su un intervallo di tempo compreso tra le 10:00 e le 12:00 o che viene mappato su una data specifica, ad esempio il 10/04/2016.

Tuttavia ho finito per implementare una classe Timeslot con un po 'più di informazioni. Ma non mi piace e voglio davvero cambiarlo. Ha un limite inferiore e uno superiore che contiene un intervallo di tempo. L'unità in cui sono memorizzati questi valori sono in millisecondi. Quindi memorizzo anche TimeUnit solo per abbellire leggermente l'output della stringa.

Ora, voglio ridefinire l'intera classe per essere sia flessibile che astratta (nel senso di rappresentazione astratta di un periodo di tempo, non della parola chiave Java).

Con flessibilità intendo che un periodo di tempo potrebbe potenzialmente essere uno dei seguenti:

• Un giorno anonimo, settimana, ecc. Ad esempio: giorno 1, giorno 2, giorno 3 ... o settimana 1, settimana 2, settimana 3.
• Un intervallo anonimo: dal giorno 1 al giorno 3, dal giorno 3 al giorno 4, dal giorno 4 al giorno 10, dall'ora 1 all'ora 2, dall'ora 2 all'ora 3 ...
• Una data specifica: 10/04/2016, 11/04/2016 ...
• Un intervallo di tempo specifico in una data anonima: 10: 00-11: 00 giorno 1, 11: 00-12: 00 giorno 1, 10: 00-11: 00 giorno 2 ...

E così via, e via dicendo, lo chiami. Inoltre, tutto questo per qualsiasi unità di tempo, puoi avere ore, giorni, settimane, anni ... anche secondi, e perché non millisecondi, anche se un caso estremo, ma possibile.

Quindi quale potrebbe essere l'approccio migliore per affrontare questo problema?

Ecco la classe che ho finora (ma come ho detto, voglio cambiare completamente il modo in cui è pensata):

package models.tournaments.events.entities;

public class Timeslot extends Entity implements Comparable<Timeslot> {
    private int lowerBound;

    private int upperBound;

    public enum TimeUnit { MILLISECONDS, SECONDS, MINUTES, HOURS, DAYS, YEARS };

    private TimeUnit timeUnit = TimeUnit.HOURS;

    public Timeslot(String name, int lb, int ub) {
        super(name);
        lowerBound = lb;
        upperBound = ub;
    }

    public Timeslot(int lb, int ub) {
        this("Timeslot", lb, ub);
    }

    public Timeslot(int lb, int ub, TimeUnit timeUnit) {
        this(lb, ub);
        this.timeUnit = timeUnit;
    }

    public int getLowerBound() {
        return lowerBound;
    }

    public int getUpperBound() {
        return upperBound;
    }

    public TimeUnit getTimeUnit() {
        return timeUnit;
    }

    public String getLowerBoundStr() {
        return formatStringWithTimeUnit(lowerBound);
    }

    public String getUpperBoundStr() {
        return formatStringWithTimeUnit(upperBound);
    }

    public String toString() {
        return getLowerBoundStr() + " - " + getUpperBoundStr();
    }

    private String formatStringWithTimeUnit(int value) {
        switch (timeUnit) {
            case MILLISECONDS:
                break;
            case SECONDS:
                value /= 1000;
                break;
            case MINUTES:
                value /= 1000 * 60;
                break;
            case HOURS:
                value /= 1000 * 60 * 60;
                break;
            case DAYS:
                value /= 1000 * 60 * 60 * 24;
                break;
            case YEARS:
                value /= 1000 * 60 * 60 * 24 * 365;
                break;
            default:
                break;
        }
        return Integer.toString(value);
    }

    public int compareTo(Timeslot timeslot) {
        if (getLowerBound() < timeslot.getLowerBound())
            return -1;
        else if (timeslot.getLowerBound() < getLowerBound())
            return 1;
        else if (getUpperBound() < timeslot.getUpperBound())
            return -1;
        else if (timeslot.getUpperBound() < getUpperBound())
            return 1;
        return 0;
    }
}

Spero che la domanda abbia un senso e che non sia troppo ampia.