Design pattern per la struttura dati che contiene al massimo un articolo di ciascun tipo

Ho una superinterfaccia che implementa diverse classi astratte: Coverage .

Questo è per il rating assicurativo. Esistono diversi tipi di copertura diversa e tali coperture possono variare a seconda dello stato. Il "tipo" di copertura è una classe astratta, quindi le implementazioni concrete dipendono dallo stato in cui si trova chi lo acquista (diversi stati generalmente condividono uno di questi implementatori concreti).

Fondamentalmente, abbiamo

public interface Coverage {/*...*/}
public abstract class Pip implements Coverage {/*...*/}
public final class FLPip extends Pip {/*...*/}

e quindi abbiamo:

public class quote {
    final List<Coverage> coverages;
    // ...
}

Penso che sarebbe bello averlo in modo che l'aggiunta di duplicati di uno qualsiasi degli implementatori diretti di Coverage provocherebbe un errore.

Voglio dire, potrei fare qualcosa del genere:

abstract class Coverage {/*...*/}

abstract class Pip extends Coverage {/*...*/}

final class FLPip extends Pip {/*...*/}

class Quote {

    // ...

    private final PriorityQueue<Coverage> coverages;
    private final HashSet<Class> coverageTypes;

    // ...

    public void addCoverage(Coverage coverage) {
        Class c = coverage.getClass();
        while(c.getSuperclass() != Coverage.class)
            c = c.getSuperclass();
        if (coverageTypes.contains(c))
            throw new IllegalArgumentException();
        coverageTypes.add(c);
        coverages.add(coverage);
    }

    public void removeCoverage(Coverage coverage) {
        Class c = coverage.getClass();
        while(c.getSuperclass() != Coverage.class)
            c = c.getSuperclass();
        coverageTypes.remove(c);
        coverages.remove(coverage);
    }

    // ...

}

ma questo sembra molto "hacky" e soggetto a problemi di errore / estensibilità, e come se mi mancasse qualcosa qui. Qualche idea su un modello migliore da usare?