Diese Schweifklammer hier ist die Schweifklammer der Klasse, zu Klassen erzähle ich gleich mehr. In die Klasse schreibe ich das rein. Es könnte auch anders stehen, aber am Ersten vielleicht mal hier. Wie soll diese Aufzählung heißen? Ich möchte vielleicht Zustände unterscheiden, dann nenne ich das also State.

Und dann kommt in Schweifklammern eine Liste an Namen. Und es kommt sogar auch ein Semikolon dahinter. Das ist eins zu eins das, was wir in C hatten, was wir uns ersparen können. Das haben wir schon bei den Klassen gesehen, man braucht jetzt keinen Type-Def. Das ist wie in C++, kein Type-Def. In C bräuchte man einen Type-Def, um damit überall umgehen zu können, ohne ständig das Enum davor zu schreiben.

In die Schweifklammern jetzt die verschiedenen Zustände, zum Beispiel Full Power, Half Power, wenn der Fall nicht im Weg ist. Was habe ich hier? Error und Off habe ich meine vier Zustände benannt.

Irgendwie ist mir hinten etwas verloren gegangen. Ok, Schweifklammer zu, Semikolon. Das steht nur für Namen für Zahlen. Also nachher wird einfach Full Power ein anderer Name für die Zahl 0 sein. Half Power ein anderer Name für die Zahl 1.

Error für die Zahl 2, Off für die Zahl 3. Das ganze aber wieder eine Nummer intelligenter als in C. Sie können insbesondere nach diesen Namen fragen. In C kennt der Compiler diese Namen und wenn er das kompiliert hat, ist es nur noch 0, 1, 2, 3.

Hier kann ich nachzeitig noch nach diesen Namen fragen. Oder Namen in die entsprechenden Zahlen umwandeln. Das höre ich nochmal vor. Hier oben in die, wo schreibe ich das hier mal rein. Das ist dann auch noch für die Nummer 11, wenn ich das jetzt verwende.

Einen Zustand möchte ich speichern. Das sieht noch aus wie in C, J, K, L, M weiter. State M. In C hätten Sie jetzt direkt einen Namen hier schreiben können. In C hätten Sie direkt schreiben können. State M ist gleich Full Power.

Das will er nicht. Es darf alles immer nur von einem Objekt oder einer Klasse abhängen. Ich muss hier vor noch State schreiben. State Punkt Full Power. Dann kann ich sogar hier einfach auswählen aus der Liste.

So sieht es dann aus. Man muss tatsächlich hier den Namen der Enumeration dann noch davor haben. So habe ich eine Variable M. Intern wird deren Wert einfach 0 sein. Aber so netter zu lesen.

Die übliche Anwendung wird dann sein, einfach so eine Verzweigung zu machen mit Switch und Case. Das hatten wir auch in C gesehen. Abhängig von dem, was dieses M jetzt ist. Vielleicht ist M nicht direkt vorher gesetzt, sondern M aus einer anderen Funktion geholt.

Wo ist die Taste? Da ist sie doch. Jetzt kann ich sie eben wieder vergleichen wie in C. Immer aber mit dem Namen der Enumeration davor. Wenn dieses M Fehler war, tue dieses oder jenes, schreibe ich da rein.

Wenn dieses M Full Power war, tue das, was da steht. Wenn dieses M irgendwas anders war, tue das, was da steht.

Das sollte sehr dicht an dem dran sein, was wir in C hatten. Ich setze hier mal einen Breakpunkt.

Und gehe in ein paar Schritten weiter. Sie sehen, wo ich lande, bei Full Power. M ist Full Power. Das war der Zustand, den ich in M habe und ich lande hier in Full Power. Das wäre die typische Art, Aufzählungen zu verwenden.

Eine endliche Menge an Zuständen. Und sie nutzen die statt Zahlen. Sie nennen nicht 0123 die Zustände, sondern sie nennen die mit Namen. Und das Nette ist, das habe ich eben schon gesagt, man kann nun nach den Namen fragen.

Für den Look-And-Text Nr. 12 kann ich rauskriegen, welche Namen das sind jeweils waren. Nehmen wir hier mal M.

S ist gleich M to String. Wenn Sie das aufrufen, diese allgemeine Verwandlung der Zeichenkette-Funktion, kriegen Sie einfach Full Power zurück als Zeichenkette. Oh, welche Variable hatten wir noch nicht? N.

Wenn Sie diesen Zustand M ganz dreist in eine ganze Zahl wandeln, kriegen Sie einfach die entsprechende Nummer zurück. Es ist etwas schwieriger, wenn ich die Zahl habe und dann aus der Zahl den Namen haben will.

Ich weiß die Zahl 2, 012, und hätte gerne Error wirklich als Zeichenkette, dann wäre es ein bisschen heftiger. Da muss man auch wieder nur wissen, dass das garantiert geht und den Rest findet Google. Ich muss selbst ein bisschen spicken, weil das ist echt hart. Okay, es gibt die Mutterklasse aller Aufzählungen, die heißt Enum.

Was haben wir eben schon gesehen mit der Mutterklasse aller Arrays da oben? Also wenn ich irgendwo auf der Suche bin nach einer Spezialfunktion für Arrays, suche ich bei Array. Wenn ich auf der Suche bin nach einer Spezialfunktion für Aufzählungen Enumerations,

suche ich bei Enum in der Klasse. Und die hat dann GetName. Jetzt will er den Typ der Aufzählung. Das sieht dann so aus, typeOf, da ist er schon, typeOf. Und die Aufzählung hieß state.

Und als nächstes will er den Wert haben. Ich möchte zum Beispiel wissen, was zur Zahl 2 gehört. So sieht das aus. Ich fühle es bis dahin dann doch mal vor, dass wir nicht den Anschluss verlieren.

Das hatten wir schon. Da will ich hin. So, erstmal gerade hier gucken. M war eigentlich die Zahl intern Null, Full Power.

Was man jetzt eigentlich da immer noch sehen sollte. Ja, was man da immer noch sieht. Mit ToString kriege ich eine Zeichenkette, was definitiv was anderes ist als die Zahl Null. Hier haben Sie jetzt wirklich die Zeichenkette. Sie können zum Beispiel die Zeichenkette dann nach dem dritten Buchstaben fragen. Das ist ein L. Sie können nicht die Zahl Null nach dem dritten Buchstaben fragen.

Hier caste ich von der Enumeration in eine ganze Zahl und es wird Null, wie sich das gehört. So und jetzt ist das hier unten. Das ist echt heftig. Das weiß ich auch nicht auswendig. Keine Chance. Man kann sich daran erinnern. Es hat wohl etwas mit der Mutterklasse Enumeration zu tun.

Und dann geht man auf die Suche bei der Mutterklasse Enumeration. Hier sollte jetzt in der Zeichenkette stehen, welcher Name zu der Zahl 2 gehört. Also Null, eins, zwei. Er war sollte in der Zeichenkette stehen.

Hier steht Error in der Zeichenkette. Er sucht also raus, was zur Zahl 2 gehört. Das ginge in C nicht. Der Compiler würde vergessen, wie die einzelnen Bestandteile der Enumeration heißen. Der hier vergisst es nicht. Und die letzte Variante ist umgekehrt.

Gegeben zu einem Namen möchte ich herausfinden, was denn die Zahl ist, die dazugehört. Das Ganze soll also, nicht was die Zahl ist, ich möchte herausfinden, welcher Zustand dazugehört.

Also das soll rauskommen, State. Er ist die U von mir aus. Der State soll rauskommen. Dann geht man wieder auf die Suche bei Enumeration, der Mutterklasse. Das haben Sie im Praktikum gesehen. Pars wandelt eine Eingabe um, versucht den angegebenen String umzuwandeln.

EnumPars macht insofern Sinn. Jetzt muss ich trotzdem wieder angeben. Okay, was denn? Diese Enumeration, Type of State.

Und das war die Zeichenkette, die ich übersetzen will. Welche Enumeration, welche Zeichenkette, Klammer zu. Wir sehen ganz glückliches noch nicht. Das haben wir ähnlich auch im Praktikum. Wenn man die Listbox fragt nach einem Eintrag, kriegt man ein allgemeines Object.

Hier dasselbe, wenn Sie gucken was da ganz links steht. Ich kann jetzt nicht mit der Maus dahin. Object, bei Enum dasselbe. Er liefert allgemein ein Object zurück, weil er nicht genau weiß, was er zurückliefern soll. Ich weiß aber, wenn ich Halfpower in dieser Enum suche, dann ist das was rauskommt, auf jeden Fall vom Typ State.

So muss man es dann schreiben. Das ist so eine kleine technische Umweg. Das heißt, wenn ich das jetzt hier mache, müsste ich die Zahl eins rauskriegen. Das ist ein sehr unbequemer Weg, die Zahl eins zu finden.

Natürlich nicht die Zahl eins zu finden. Was erzähle ich denn? Den Zustand zu finden, der zur Halfpower gehört. Ich kriege ja einen Zustand raus und keine Zahl. Wenn ich die Zahl haben wollen würde, wäre eine ganz dumme Möglichkeit, dass das was hier rauskommt,

einfach eine ganze Zahl verwandelt. Dann hätte ich die Zahl. Hier habe ich jetzt erst einmal den echten Zustand. Diesen Zustand, der hier rauskommt, den könnte ich zum Beispiel in so einem Switchcase verwenden und dann mit diesen verschiedenen Einzelzuständen vergleichen.

Das wäre eine spannende Frage. Was passiert, wenn ich hier in einen Int caste? Ich weiß es nicht. Die habe ich nie ausprobiert. Sollte man eigentlich auch nicht ausprobieren, sollte man in der Doku nachgucken. Aber der kürzeste Weg ist natürlich einfach mal auszuprobieren.

Was passiert, wenn ich das in einen Int verwandele? Interessant, interessant. UV, so weit nimmt das noch. Cool.

Also es geht auch dann direkt in den Int casten. Was nicht ganz unlogisch ist, wenn ich den State hier, nachdem ich ihn habe, in einen Int casten kann, muss das auch auf einen Schlag gehen, dass ich hier sofort in den Int caste. Stimmt denn eins überhaupt, Halfpower? Ja, Halfpower ist eins. Okay, also Sie sehen, dass die Arrays und die Enumerations ähnlich funktionieren wie in C.

In Java ist es übrigens auch ähnlich. Nur eben in den beiden moderneren Sprachen deutlich intelligenter. Man kann viel mehr damit anfangen. Und, jetzt sagen wir nochmal, es lohnt sich nicht, das auswendig zu lernen.

Man hat zum Schluss eine Idee, was denn diese Systeme können und sucht in der Doku. Sonst müssen wirklich zwei Telefonbücher auswendig lernen. Das ergibt keinen Sinn. So geht man nicht vor. Das ist doch das Nette. Ich weiß, es muss irgendwo bei Enumeration stehen, dann tippe ich den Punkt und irgendwo werde ich es da schon finden. Und wenn ich es da nicht finde, gehe ich in die Hilfe.