Programmieren lernt man nicht, indem man endlos Theorie paukt. Man lernt es, indem etwas passiert. Etwas reagiert. Etwas entscheidet. Genau deshalb bauen wir heute kein trockenes Beispiel, sondern ein Spiel. Einen Klassiker sogar. Schere, Stein, Papier. Simpel genug, um nicht zu überfordern. Echt genug, um sich wie Software anzufühlen.
Wenn du am Ende dieses Dremcodes Tutorials angekommen bist, hast du nicht nur ein funktionierendes Kotlin Programm geschrieben. Du wirst verstanden haben, warum es funktioniert. Und noch wichtiger: wie du von hier aus weitermachen kannst.
Warum dieses Projekt ein perfekter Einstieg ist
Jede Software, egal ob Banking App oder Game-Engine, basiert auf drei Säulen. Keine Magie, kein Hexenwerk.
Erstens: Input. Irgendwer gibt etwas ein. Tastatur, Klick, Touch, volkommen egal.
Zweitens: Logik. Das Programm entscheidet, was diese Eingabe bedeutet.
Drittens: Output. Ein Ergebnis wird angezeigt. Text, Grafik, Sound.
Schere, Stein, Papier enthält genau das. Nicht mehr, nicht weniger. Und genau deshalb eignet es sich so gut als Startpunkt.
Kotlin ist dabei kein Zufall. Die Sprache ist modern, sehr lesbar und verzeiht viele Anfängerfehler, ohne dich zu bevormunden. Sie zwingt dich nicht zu komplizierten Konstrukten, lässt dir aber jederzeit Raum nach oben. Android Apps, Server Backends, Desktop Tools. Alles beginnt mit denselben Grundlagen, die du hier lernst.
Bevor wir loslegen: Was du brauchst
Ein kurzer Realitätscheck, ganz ohne Drama.
Du brauchst vollgendes:
- Einen Rechner / Laptop (Windows, macOS oder Linux, völlig egal)
- Eine IDE wie IntelliJ IDEA Community Edition
- Keine Vorkenntnisse in Kotlin (Einfach nur Spass und Bock drauf)
Nach der Installation erstellst du ein neues Kotlin Projekt. Konsolenanwendung. Kein Framework, kein Schnickschnack. Je leerer das Projekt, desto besser. Wir wollen verstehen, nicht kopieren.
Wie ein Kotlin-Programm überhaupt startet
Jedes Kotlin Programm hat einen Einstiegspunkt. Immer. Ohne Ausnahme.
fun main() {
// Hier beginnt alles
}Was das bedeutet? Sobald du das Programm startest, springt Kotlin genau hier hinein. Alles, was danach passiert, muss von dieser Funktion ausgehen. Denk an sie wie an den Einschaltknopf deiner Software.
Variablen: Das Gedächtnis deines Spiels
Ein Programm ohne Variablen ist wie ein Mensch ohne Erinnerungen. Es könnte reagieren, aber nichts behalten.
In Kotlin gibt es zwei Arten, sich Dinge zu merken:
val name = "RPS"
var punkte = 0val steht für Werte, die sich nicht ändern.var steht für Werte, die sich ändern dürfen.
In unserem Spiel ist das logisch: Der Name bleibt gleich. Der Punktestand nicht.
Im Code sieht das dann so aus:
var spielerPunkte = 0
var computerPunkte = 0
val verlauf = mutableListOf<String>()Hier passiert schon mehr, als es auf den ersten Blick wirkt. Wir speichern nicht nur Zahlen, sondern auch eine Liste. Ein kleines Logbuch, das jede Runde festhält. Das ist kein Muss, aber es macht das Spiel lebendiger. Und ehrlich gesagt: Es fühlt sich gut an, am Ende eine Statistik zu sehen. Es ermuntert zum weitermachen.
Ohne Schleife kein Spiel
Wenn du dein Programm einmal startest und es sofort wieder endet, hast du technisch nichts falsch gemacht. Aber spielbar ist das nicht.
Die Lösung ist eine Schleife. In unserem Fall eine, die theoretisch ewig läuft:
while (true) {
// Spiel läuft
}Das wirkt erstmal gefährlich. Endlosschleife? Ja. Aber nur solange wir keinen Ausstieg definieren. Und genau das tun wir.
Mit dem Nutzer sprechen: Input lesen
Jetzt holen den Menschen ins Spiel. Watt? Pass auf.
val eingabe = readln().lowercase()readln() wartet, bis der Nutzer etwas eingibt und Enter drückt.lowercase() sorgt dafür, dass Groß- und Kleinschreibung keine Rolle spielen.
Warum das wichtig ist? Weil Menschen unberechenbar tippen. Und Software das einkalkulieren muss.
Sauber abbrechen statt abstürzen
Wenn der Nutzer „beenden“ schreibt, soll Schluss sein. Keine Fehlermeldung. Kein Chaos.
if (eingabe == "beenden") breakbreak beendet die Schleife sofort. Danach springt das Programm automatisch zum Statistik Teil. Elegant. Klar. Verständlich.
Eingaben prüfen, bevor sie wehtun
Einer der häufigsten Anfängerfehler: Man vertraut dem Input. Das sollte man nie tun.
val spielerWahl = eingabe.toIntOrNull()
if (spielerWahl == null || spielerWahl !in 1..3) {
println("Ups! Bitte gib nur 1, 2 oder 3 ein.")
continue
}Hier passiert echte defensive Programmierung.
Wenn keine Zahl eingegeben wurde, geht es einfach weiter. Kein Absturz. Kein Stacktrace. Nur eine freundliche Ansage.
Zufall ist kein Chaos
Der Computer braucht eine eigene Wahl. Zufällig, aber kontrolliert.
val computerWahl = (1..3).random()Mehr braucht es nicht. Kotlin bringt alles Nötige bereits mit. Kein Extra-Import, kein Framework.
Logik, die man lesen kann
Jetzt kommt das Herzstück. Die Entscheidung.
val ergebnis = when {
spielerWahl == computerWahl -> "Unentschieden"
(spielerWahl == 1 && computerWahl == 3) ||
(spielerWahl == 2 && computerWahl == 1) ||
(spielerWahl == 3 && computerWahl == 2) -> {
spielerPunkte++
"Sieg!"
}
else -> {
computerPunkte++
"Niederlage"
}
}Das when Konstrukt liest sich fast wie normaler Text. Genau das ist seine Stärke. Du erkennst sofort, welche Regel greift. Und du siehst direkt, wo Punkte vergeben werden.
Spielverlauf speichern statt vergessen
Jede Runde wird protokolliert:
verlauf.add(
"Runde ${verlauf.size + 1}: ${namen[spielerWahl]} vs. ${namen[computerWahl]} -> $ergebnis"
)Das ist kein Spielzeug. Genau so funktionieren Logs in echten Anwendungen. Nur oft weniger hübsch.
Das Finale: Auswertung und Abschluss
Wenn die Schleife endet, ist das Spiel vorbei. Jetzt zeigen wir, was passiert ist.
println("Endstand: Du $spielerPunkte | Computer $computerPunkte")
verlauf.forEach { println(it) }Das ist der Moment, an dem dein Programm mehr ist als Code. Es erzählt eine Geschichte. Deine Geschichte.
Das vollständige Spiel, etwas erweitert wäre folgendes:
import kotlin.random.Random
fun main() {
var spielerPunkte = 0
var computerPunkte = 0
val verlauf = mutableListOf<String>()
println("========================================")
println(" Dreamcodes - Schere, Stein, Papier")
println("========================================")
println("Regeln:")
println("[1] Schere | [2] Stein | [3] Papier")
println("Tippe 'beenden', um das Spiel zu verlassen.")
while (true) {
println("\nDeine Wahl:")
val eingabe = readln().lowercase()
if (eingabe == "beenden") {
println("Spiel wird beendet...")
break
}
val spielerWahl = eingabe.toIntOrNull()
if (spielerWahl == null || spielerWahl !in 1..3) {
println("Ungültige Eingabe. Bitte 1, 2 oder 3 eingeben.")
continue
}
val computerWahl = Random.nextInt(1, 4)
val namen = mapOf(
1 to "Schere",
2 to "Stein",
3 to "Papier"
)
println("Du wählst: ${namen[spielerWahl]}")
println("Computer wählt: ${namen[computerWahl]}")
val ergebnis = when {
spielerWahl == computerWahl -> "Unentschieden"
(spielerWahl == 1 && computerWahl == 3) ||
(spielerWahl == 2 && computerWahl == 1) ||
(spielerWahl == 3 && computerWahl == 2) -> {
spielerPunkte++
"Sieg"
}
else -> {
computerPunkte++
"Niederlage"
}
}
println("Ergebnis dieser Runde: $ergebnis")
verlauf.add(
"Runde ${verlauf.size + 1}: " +
"${namen[spielerWahl]} vs. ${namen[computerWahl]} → $ergebnis"
)
}
println("\n========================================")
println(" SPIELSTATISTIK")
println("========================================")
println("Endstand:")
println("Du: $spielerPunkte Punkt(e)")
println("Computer: $computerPunkte Punkt(e)")
println("\nSpielverlauf:")
verlauf.forEach { println(it) }
println("\nDanke fürs Spielen.")
println("Weiterlernen. Weiterbauen. Weiterdenken.")
println("========================================")
}Das Verschicken deines Programms an Freunde ist der Moment, in dem aus bloßem Code ein echtes Produkt wird. In der Java/Kotlin-Welt ist das Standardformat dafür die JAR Datei. Hier ist die Anleitung, wie du dein Spiel „versandfertig“ machst:
1. Das Projekt vorbereiten
Bevor wir die Datei erstellen, müssen wir IntelliJ sagen, was der „Einstiegspunkt“ (Main-Class) deines Programms ist.
- Gehe oben im Menü auf File > Project Structure.
- Wähle links den Punkt Artifacts aus.
- Klicke auf das grüne + Symbol > JAR > From modules with dependencies….
- Wähle bei Main Class den Ordner-Button und suche deine
MainKtDatei (IntelliJ fügt das „Kt“ automatisch an den Dateinamen an). - Bestätige mit OK. Du siehst nun ein Layout, das zeigt, was in die JAR Datei gepackt wird. Klicke erneut auf OK.
2. Die JAR-Datei bauen (Build)
Jetzt erstellen wir die tatsächliche Datei:
- Gehe im oberen Menü auf Build > Build Artifacts….
- Es öffnet sich ein kleines Menü in der Mitte des Bildschirms. Wähle dein Projekt aus und klicke auf Build.
- IntelliJ arbeitet nun kurz.
Wo ist die Datei nun gespeichert? Suche in deinem Projekt-Ordner (links in der Seitenleiste) nach dem Ordner out/artifacts/. Dort liegt nun deine Datei, zum Beispiel SchereSteinPapier.jar.
3. Wie deine Freunde das Spiel starten
Deine Freunde benötigen keine Programmierumgebung wie IntelliJ, aber sie brauchen die Java Runtime Environment (JRE) (die meistens ohnehin installiert ist).
Starten über das Terminal
Da unser Spiel in der Konsole läuft, öffnet man es am besten so:
- Ordner öffnen, in dem die Datei liegt.
- Rechtsklick im Ordner > In Terminal öffnen (oder „Eingabeaufforderung“).
- Tippe den Befehl:
java -jar DeinDateiname.jar
