Probleme mit Enum

[Resi]

Hallo,
ich hab grad eine total peinliche anfänger Frage:

Ich komme von C++.
Dort gibt es

enum
{
	a,
	b 
};

So wird automatisch durch nummeriert.
Man kann aber auch explizit zuweisen:

enum
{
	a = 100,
	b = 300
};

So konnte man Werte festlegen, die intern wie ein int waren aber nach außenhin gut lesbar waren.

So ging z.B. ein switch über ein int:

int i = irgend was;
switch(i)
{
case a:
	...
break;
case b:
	...
break;
default
	...
}

Das habe ich nun bei Java probiert:

public enum testEnum
{
	a
}

...

int i = irgend was;
switch(i)
{
case testEnum.a:
	...
break;
case testEnum.b:
	...
break;
default
	...
}

Hier bekomme ich bei Eclipse folgende Fehlermeldung:
cannot convert from testEnum to int

Für was brauche ich das?
Es wird über ein netzwerk ein Dienst angesprochen. Um den Traffic möglichst klein zu halten sollen ints verschickt werden.
Aber um die Lesbarkeit zu behalten, sollen Namen genutzt werden können.
Deshalb wollte ich ein Enum definieren, das von beiden Seiten, Client und Server, verwendet wird.
Nach der Übertragung kommt ja erstmal nur eine Zahl an bei der man noch nicht weiß was es ist - ob es überhaupt eine Zahl des Enum-Typs ist oder ein Fehler.

Wie bekomme ich die Enums so hin, dass es für mich geeignet ist?


Zum zweiten Enum:
Ich habe feste Größen, die je nach Event hergenommen werden. Um dies aber besser lesbar zu machen wollte ich auch hier Enums hernehmen.
Deshalb hätte ich gerne die 2. Art des Enums oben hergenommen. Oder macht man hier in Java Konstanten?

Danke für eure Tipps

 

[faetzminator]

Ich würde beim Empfänger mit dem int den ensprechenden Enum-Eintrag holen und mit diesem weiterarbeiten.

 

[SlaterB]

Enums haben eine natürliche Nummerierung, ordinal(), Enum.getValues()[index],
oder können als Klasse beliebige eigene Attribute aufnehmen, darunter auch int-Werte, bei Definition z.B. als Konstruktorparameter, Syntax:
a(100),
b(300)
und ähnliches

direkt zwischen int und Enum kann Java in jedem Fall nicht umwandeln, richtig,
da muss man dann eine Code-Zeile dazuschreiben, falls es nötig ist:
Enum x = Enum.getForInt(y);
und dann das switch auf x oder was auch immer

 

[Resi]

Enums haben eine natürliche Nummerierung, ordinal(), Enum.getValues()[index],
oder können als Klasse beliebige eigene Attribute aufnehmen, darunter auch int-Werte, bei Definition z.B. als Konstruktorparameter, Syntax:
a(100),
b(300)
und ähnliches

direkt zwischen int und Enum kann Java in jedem Fall nicht umwandeln, richtig,
da muss man dann eine Code-Zeile dazuschreiben, falls es nötig ist:
Enum x = Enum.getForInt(y);
und dann das switch auf x oder was auch immer

also wenn ich

public enum testEnum
{
	a(100)
}

mache kommt: The constructor testEnum(int) is undefined

und testEnum.getForInt(y) gibt es nicht

 

[SlaterB]

> oder können als Klasse beliebige eigene Attribute aufnehmen, darunter auch int-Werte

dürfte ziemlich deutlich zeigen, dass ich schon auch die Defintion entsprechender Attribute, Konstruktoren usw. meinte,
alles genau wie bei normalen Klassen, wenn du
class C {
}
definierst, geht new C(100) auch nicht, aber mit viel Code wäre es irgendwann möglich,

getForInt(y) wäre genauso eine noch zu schreibende Methode, die nach verschiedenen Möglichkeiten vorgehen kann um das passende Enum zu finden

für den Standard ordinal()-Wert gibt es wie gesagt Enum.values(), welches ein Array liefert, und dann Array-Zugriff,
aber das sind eigentlich Grundlagen die nachzulesen sind..

 

[faetzminator]

Du musst natürlich die Methoden und den Konstruktor selbst implementieren, vielleicht etwa so:

public enum TestEnum {
    A(100);

    private final int value;

    private TestEnum(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public static TestEnum getForInt(int value) {
        for (TestEnum entry : TestEnum.values()) {
            if (entry.getValue() == value) {
                return entry;
            }
        }
        return null; // oder auch eine exception...
    }
}

Edit: zu spät...

 

[SlaterB]

zu sagen ist da noch, dass bei Java Enums auch keine Vererbung besteht, braucht man das mehrmals müsste man es mehr oder weniger komplett kopieren,
wenn in anderen Sprachen

enum
{
	a = 100,
	b = 300
};

geht, dann dürfte das nicht 1:1 so elegant in Java zu machen sein

 

[Resi]

danke für die Antworten.

bin bisschen stutzig, dass dies in Java so kompliziert ist.
aber das hat sicher gute gründe, die man auf den ersten blick nicht sieht.

 

[faetzminator]

aber das hat sicher gute gründe, die man auf den ersten blick nicht sieht.

Nunja, es ist nicht immer der Fall, dass man einen int dahinter hat. Vielleicht hast du an einer anderen Stelle einen anderen Datentypen, bei welchem die vordefinierten Methoden völliger Nonsense wären. Oder du benötigst gar keinen Wert...

 

[Andi_CH]

int i = irgend was;
switch(i)
{
case testEnum.a:

warum soll das überhaupt gehen?
Java ist ein sprache mit Typenkonzept (Im Gegensatz zu C(++) )

du vergleichst einen int mit einem enum also Äpfel mit Backsteinen

Zum Wert kommt man schon, das ist kein Problem, aber einen Wert vorgeben kann man man IMO nicht. Es kommt draufan was du willst - man könnte z.B. eine Tabelle (HashMap?) hinterlegen ...

public class Test {

	public enum Alphabet {
		a, b, c
	}

	public static void main(String[] args) {
		Alphabet buchstaben = Alphabet.a;
		System.out.println(buchstaben.ordinal());
		buchstaben = Alphabet.b;
		System.out.println(buchstaben.ordinal());
		switch (buchstaben) {
		case a:
			break;
		case b:
			break;
		case c:
			break;
		}
	}
}

Warum das nicht geht verstehe ich allerdings nicht - Java sagt mir ja damit, dass eine Konstante (final) nicht konstant ist

public class Test {

	public enum Alphabet {
		a, b, c
	}

	private static final int a = Alphabet.a.ordinal();

	public static void main(String[] args) {
		int i = 1;
		switch (i) {
		case a: // case expressions must be constant expressions
			break;
		}
	}
}

 

[SlaterB]

das ist eben keine Anweisung wie ein if-Vergleich, die erst zur Laufzeit ausgeführt wird,
der Compiler muss bestimmt beim Kompilieren, bei Erstellung der .class-Datei wissen, welcher int-Wert dort drankommt,