>To say that another way: this idiom allows a superclass
>(such as an Abstract Factory) to define methods whose
>argument types and return types are in terms of the
>subclass type, not the superclass type.

More generically speaking: The idiom makes a available a type parameter to the superclass “containing” the type of the subclass.

this constructor

public DFA (Map> delta) {
    transitionFunction = new EnumMap>(delta);
    for (S state : delta.keySet()) {
        transitionFunction.put(state, new EnumMap(delta.get(state)));
    }
}

cannot be used like this

EnumMap> delta;
DFA automata;
[...]
automata = new DFA(delta);

I need to create this constructor :

public DFA (EnumMap> delta) {
    transitionFunction = new EnumMap>(delta);
    for (S state : delta.keySet()) {
        transitionFunction.put(state, new EnumMap(delta.get(state)));
    }
 }

So I conclude that EnumMap> do not inherit from Map>.

I’ve tried
public DFA (EnumMap>> delta)
but it didn’t work either, because ? is not allow in constructor.

This is not more than annoying… but now I’d like to write something like

public NFA (EnumMap>> delta) {/* etc */ }

and nor

    transitionFunction = new EnumMap>>(delta);
    for (S state : delta.keySet()) {
        transitionFunction.put(state, new EnumMap>(delta.get(state)));
    }

neither

    transitionFunction = new EnumMap>>(delta);
    for (S state : delta.keySet()) {
        transitionFunction.put(state, new EnumMap>(delta.get(state)));
    }

works as body -_-

The first tells me that there is not constructor in EnumMap that matchs.
The second tells me that there is incompatible types.

Do you have an idea ?


enum SpecialService {
CUSTOMS("ABW",1),
ALLOWANCE("ACA",2),
FEE("ACN",3),
FREIGHT("FC",4),
QUANTITYDISCOUNT("QD",5),
PENALTY("SC",6),
SPECIALHANDLING("SH",7);

private SpecialService(String name, int ordinal) {
super(name, ordinal);
}
}

I tried the following, but the compiler says "valueOf(java.lang.String) is already defined in se.exder.logic.types.SpecialService"


enum SpecialService {
CUSTOMS("ABW"),
ALLOWANCE("ACA"),
FEE("ACN"),
FREIGHT("FC"),
QUANTITYDISCOUNT("QD"),
PENALTY("SC"),
SPECIALHANDLING("SH");

private String code;

private SpecialService(String c) {
this.code = c;
}

public String toString() {
return code;
}

public static SpecialService valueOf(String name) {
for(SpecialService ss : values()) {
if(ss.code.equals(name))
return ss;
}

throw new IllegalArgumentException(name);

}
}

public class EnumTest2 {
enum E {
red, green, blue;
public static E valueOf(int i) {
for(E e : values()) {
if (e.ordinal() == i) {
return e;
}
}
throw new IllegalArgumentException("wtf is " + i);
}

}

public static void main(String[] args) {
    E e = E.red;
    System.out.println(e.name() + " " + e.ordinal());
    System.out.println(E.valueOf(1));
}

}

public static void main(String[] args) {
    E e = E.red;
    System.out.println(e.name());
    System.out.println(E.valueOf("green"));
}

}

If you really want to treat externalize as ints, maybe do something like this:
public class EnumTest2 {
enum E {
red(1), green(2), blue(3);
public final int i;

    E(int i) {
        this.i = i;
    }

    public static E valueOf(int i) {
        for(E e : values()) {
            if (e.i == i) {
                return e;
            }
        }
        throw new IllegalArgumentException("wtf is " + i);
    }
}

public static void main(String[] args) {
    E e = E.red;
    System.out.println(e.name() + " " + e.i);
    System.out.println(E.valueOf(2));
}

}