Common class field in enumeration

Question

public enum Dictionaries {
    FIRST_DICTIONARY(FirstDictionary.class),
    SECOND_DICTIONARY(SecondDictionary.class);

    private Class<? extends DictionaryModel> clazz;

    private Dictionary(Class<? extends DictionaryModel> clazz) {
        this.clazz = clazz;
    }

    public Class<? extends DictionaryModel> clazz() {
        return this.clazz;
    }
}

I have this listing. FirstDictionaryand SecondDictionaryimplements DictionaryModel, this is a marker interface for using this solution.

Right now I would like to do this:

Class<FirstDictionary> clazz = Dictionaries.FIRST_DICTIONARY.clazz();

This is obviously not possible with this design, and I cannot figure out how to do this. Is there any way to do this? I have access to all the code, so I can change everything, including the interface (or even delete it).

I simplified all this, I want to say that every dictionary is a database table, and I have one common DAO for them (instead of a DAO for each dictionary), and now I have to give the result of every reading that I would like to avoid. I know that a general DAO is not a good idea (or a DAO at all).

Optional<DictionaryModel> entity = dao.getByValue(Dictionaries.FIRST_DICTIONARY, value);

DAO clazz(). , - .

, .

Answer 1

, enum .

, -

Class<FirstDictionary> clazz = Dictionaries.FIRST_DICTIONARY.clazz();

public interface Dictionaries<T extends DictionaryModel> {
    Dictionaries<FirstDictionary>  FIRST_DICTIONARY  = () -> FirstDictionary.class;
    Dictionaries<SecondDictionary> SECOND_DICTIONARY = () -> SecondDictionary.class;

    Class<T> clazz();
}

, getByValue enum , Class<T extends DictionaryModel> .

Answer 2

. , , JEP 301:

enum Argument<X> { // declares generic enum
   STRING<String>(String.class), 
   INTEGER<Integer>(Integer.class), ... ;

   Class<X> clazz;

   Argument(Class<X> clazz) { this.clazz = clazz; }

   Class<X> getClazz() { return clazz; }
}

Class<String> cs = Argument.STRING.getClazz(); //uses sharper typing of enum constant

, :

interface DictionaryModel {}
class FirstDictionary implements DictionaryModel {}
class SecondDictionary implements DictionaryModel {}

// Following a model similar to how enums are implemented, but with sharper typing:
abstract class Dictionaries<T extends DictionaryModel> {
    public static final Dictionaries<FirstDictionary> FIRST_DICTIONARY 
        = new Dictionaries<>(FirstDictionary.class) {};
    public static final Dictionaries<SecondDictionary> SECOND_DICTIONARY 
        = new Dictionaries<>(SecondDictionary.class) {};

    private final Class<T> clazz;

    private Dictionaries(Class<T> clazz) {
        this.clazz = clazz;
    }

    public Class<T> clazz() {
        return this.clazz;
    }
}

:

Class<FirstDictionary> clazz = Dictionaries.FIRST_DICTIONARY.clazz();