Klassen und Objektinstanzen in Kotlin

Für die Codelabs auf diesem Weg erstellen Sie eine Android-App mit Würfelrolle. Wenn der Nutzer diese Würfel ausführt, wird ein zufälliges Ergebnis generiert. Das Ergebnis berücksichtigt die Anzahl der Seiten mit Würfeln. So können beispielsweise nur Werte von 1 bis 6 von einem sechsseitigen Würfel gerollt werden.

So wird die endgültige App aussehen.

Damit Sie sich auf die neuen Konzepte der App konzentrieren können, verwenden Sie das browserbasierte Kotlin-Programmiertool, um die Hauptfunktionen Ihrer App zu erstellen. Das Programm gibt Ihre Ergebnisse an die Konsole aus. Später implementieren Sie die Benutzeroberfläche in Android Studio.

In diesem ersten Codelab erstellst du ein Kotlin-Programm, das rollierende Würfel simuliert und eine Zufallszahl wie eine Würfel ausgibt.

Vorbereitung

• Informationen zum Öffnen, Bearbeiten und Ausführen von Code auf https://try.kotlinlang.org/
• Sie können ein Kotlin-Programm erstellen und ausführen, das Variablen und Funktionen verwendet und ein Ergebnis an die Konsole ausgibt.
• Formatieren Sie Zahlen in Texten mit einer Stringvorlage und der Notation ${variable}.

Lerninhalte

• So werden programmatisch zufällige Zahlen generiert, um Würfelrollen zu simulieren.
• Code-Struktur mithilfe einer Dice-Klasse mit einer Variable und einer Methode.
• So erstellen Sie eine Objektinstanz einer Klasse, ändern ihre Variablen und rufen ihre Methoden auf.

Aufgaben

• Ein Kotlin-Programm im browserbasierten Kotlin-Programmiertool, mit dem eine zufällige Auswahl durchgeführt werden kann.

Voraussetzungen

• Einen Computer mit einer Internetverbindung

Spiele haben oft ein zufälliges Element. Sie können eine zufällige Prämie erhalten oder eine zufällige Anzahl von Schritten auf dem Spielfeld erwerben. In Ihrem Alltag können Sie Zufallszahlen und Buchstaben verwenden, um sichere Passwörter zu generieren!

Anstelle des tatsächlichen Würfels kannst du ein Programm schreiben, das rollierende Würfel simuliert. Bei jedem Würfeln kann das Ergebnis eine beliebige Zahl im Bereich der möglichen Werte sein. Glücklicherweise brauchen Sie für so ein Programm keinen eigenen Zufallszahlengenerator zu erstellen. Die meisten Programmiersprachen, einschließlich Kotlin, haben eine integrierte Möglichkeit zum Generieren von Zufallszahlen. In dieser Aufgabe verwenden Sie den Kotlin-Code, um eine Zufallszahl zu generieren.

Startcode einrichten

1. Öffnen Sie in Ihrem Browser die Website https://try.kotlinlang.org/.
2. Den gesamten Code im Code-Editor löschen und durch den folgenden Code ersetzen Dies ist die main()-Funktion, mit der Sie in früheren Codelabs gearbeitet haben. Weitere Informationen finden Sie unter Ihr erstes Kotlin-Programm schreiben.

fun main() {

}

Zufallsfunktion verwenden

Um einen Würfel zu würfeln, brauchst du eine Möglichkeit, alle gültigen Würfelwerte darzustellen. Für reguläre 6-seitige Würfel sind folgende Würfel zulässig: 1, 2, 3, 4, 5 und 6.

Bisher haben Sie gelernt, dass es Datentypen wie Int für Ganzzahlen und String für Text gibt. IntRange ist ein anderer Datentyp und stellt einen Bereich von Ganzzahlen von einem Startpunkt zu einem Endpunkt dar. IntRange ist ein geeigneter Datentyp zur Darstellung möglicher Werte, die mit einem Würfel produziert werden können.

1. Definieren Sie in der main()-Funktion eine Variable als val mit dem Namen diceRange. Du kannst ihn einem IntRange zwischen 1 und 6 zuweisen, der den Bereich der Ganzzahlen darstellt, die durch sechsseitige Würfel gerundet werden können.

val diceRange = 1..6

1..6 ist ein Kotlin-Bereich, weil er eine Startnummer, zwei Punkte gefolgt von einer Endzahl (keine Leerzeichen dazwischen) enthält. Weitere Beispiele für Ganzzahlbereiche sind 2..5 für die Zahlen 2 bis 5 und 100..200 für die Zahlen 100 bis 200.

Tipp:Beachten Sie, dass IntRange in dieser Definition nicht so angegeben ist, wie Sie beim Erstellen einer Variablen für eine Ganzzahl oder einen String Int oder String nicht angegeben haben müssen. In den meisten Fällen kann das System automatisch ermitteln, welchen Datentyp Sie verwenden möchten.

Das System interpretiert beispielsweise Folgendes:

val diceRange = 1..6

wie folgt:

val diceRange: IntRange = 1..6

Ähnlich wie beim Aufrufen von println() durch das System in Bezug auf das Drucken des angegebenen Textes können Sie mit der Funktion random() eine Zufallszahl für einen bestimmten Bereich generieren und zurückgeben. Sie können das Ergebnis wie bisher in einer Variablen speichern.

2. Definieren Sie in main() eine Variable als val namens randomNumber.
3. Setzen Sie randomNumber auf den Wert des Ergebnisses von random() im Bereich diceRange, wie unten dargestellt.

 val randomNumber = diceRange.random()

Beachten Sie, dass random() in diceRange mit einem Punkt oder Punkt zwischen der Variablen und dem Funktionsaufruf aufgerufen wird. Dies lässt sich als „" generieren, dass eine Zufallszahl aus „diceRange“ generiert wird. Das Ergebnis wird dann in der Variable randomNumber gespeichert.

4. Wenn Sie die zufällig generierte Zahl sehen möchten, verwenden Sie die Stringformatierung (auch als „Stringvorlage&“ bezeichnet) ${randomNumber}, um sie zu drucken (siehe unten).

println("Random number: ${randomNumber}")

Der fertige Code sollte so aussehen.

fun main() {
    val diceRange = 1..6
    val randomNumber = diceRange.random()
    println("Random number: ${randomNumber}")
}

5. Führen Sie Ihren Code mehrmals aus. Jedes Mal, wenn Sie verschiedene Ausgaben haben, sollte eine Ausgabe angezeigt werden, die unterschiedliche Zufallszahlen umfasst.

Random number: 4

Tipps zu Bereichen:

• Bereiche können zwischen beliebigen Ganzzahlen liegen. Folgende Bereiche sind gültig: 3..46, 0..270, -6..+6, -10..-4.
• Sie können Funktionen direkt in einem Bereich aufrufen, z. B. (1..6).random().

Wenn du würfelst, sind sie echte Objekte in deinen Händen. Der Code, den Sie gerade geschrieben haben, funktioniert zwar bestens, man kann sich jedoch kaum vorstellen, dass es um einen Würfel geht. Ein Programm lässt sich besser organisieren, wenn es besser mit den vorhandenen Werten zusammenhängt. Es wäre also toll, wenn du programmatische Würfel hast!

Die Würfelfunktion ist im Wesentlichen gleich. Sie haben dieselben Eigenschaften, wie z. B. Seiten, und ein Verhalten wie das Verschieben. In Kotlin können Sie einen programmatischen Entwurf eines Würfels erstellen, der angibt, dass Würfel Seiten haben und eine Zufallszahl würfeln können. Dieser Entwurf wird als Klasse bezeichnet.

Aus dieser Klasse können Sie dann tatsächliche Würfelobjekte erstellen, die als Objektinstanzen bezeichnet werden. So können Sie z. B. einen 12-seitigen Würfel oder einen vierseitigen Würfel erstellen.

Tipp: Eine Klasse ähnelt dem Bauplan eines Architekten, der nicht das Haus ist. Er ist eine Anleitung für den Bau eines Hauses. Das Haus ist dann die eigentliche Sache (Objektinstanz), die gemäß dem Entwurf erstellt wurde.

Hinweis:Wenn Sie alles über Würfel in eine Klasse einteilen, wird die Funktion „Kapselung“ genannt. Die Kapselung ist ein fantasievolles Wort, aber es bedeutet, dass Sie Funktionalitäten zusammenfassen können, die sich logisch auf einen Ort beziehen.

Würfelklasse definieren

In den folgenden Schritten definierst du eine neue Klasse namens Dice, die einen rollbaren Würfel darstellt.

1. Löschen Sie den Code aus der Funktion main(), um den Code wie gewünscht zu entfernen.

fun main() {

}

2. Fügen Sie unter dieser main()-Funktion eine leere Zeile ein und fügen Sie dann Code ein, um die Klasse Dice zu erstellen. Wie unten gezeigt, beginnen Sie mit dem Keyword class, gefolgt vom Namen der Klasse, gefolgt von einer öffnenden und schließenden geschweiften Klammer. Lassen Sie den Abstand zwischen den geschweiften Klammern stehen, um den Code für den Kurs einzufügen.

class Dice {

}

Hinweis:

• Ähnlich wie beim Keyword fun in Kotlin können Sie mit dem Keyword class eine neue Funktion erstellen.
• Sie können einen beliebigen Namen für class auswählen. Es ist aber hilfreich, wenn der Name angibt, was die Klasse darstellt. Der Konvention zufolge ist der Name der Klasse in CamelCase-Schreibweise zu sehen. Beispiele: Car, ParkingMeter und CustomerRecord sind gültige Kursnamen.

Innerhalb einer Klassendefinition können Sie mithilfe von Variablen eine oder mehrere Eigenschaften für die Klasse angeben. Echte Würfel können aus einer Reihe von Seiten, einer Farbe oder einer Gewichtung bestehen. Bei dieser Aufgabe konzentrieren Sie sich auf die Anzahl der Seiten Würfel.

3. Füge in der Klasse Dice einen var mit dem Namen sides für die Anzahl der Seiten hinzu, die dein Würfel haben wird. Legen Sie sides auf 6 fest.

class Dice {
    var sides = 6
}

Das war's. Du hast jetzt eine sehr einfache Klasse, die Würfel darstellt.

Eine Instanz der Würfelklasse erstellen

Mit dieser Dice-Klasse haben Sie einen Plan, was ein Würfel ist. Um einen echten Würfel in Ihrem Programm zu haben, müssen Sie eine Dice-Objektinstanz erstellen. (Wenn Sie drei Würfel hätten, würden Sie drei Objektinstanzen erstellen.)

1. Um eine Objektinstanz von Dice zu erstellen, erstellen Sie in der main()-Funktion einen val mit dem Namen myFirstDice und initialisieren Sie ihn als Instanz der Klasse Dice. Die Klammern nach dem Klassennamen weisen darauf hin, dass Sie eine neue Objektinstanz aus der Klasse erstellen.

fun main() {
    val myFirstDice = Dice()
}

Nachdem Sie nun ein myFirstDice-Objekt haben, das aus dem Entwurf erstellt wurde, können Sie auf die zugehörigen Properties zugreifen. Die einzige Property von Dice ist sides. Der Zugriff auf eine Property erfolgt über die Notation &dots. Wenn du also auf die sides-Property von myFirstDice zugreifen möchtest, rufe myFirstDice.sides auf, was ausgesprochen wird:myFirstDice Punkt sides"

2. Fügen Sie unter der Deklaration von myFirstDice eine println()-Anweisung hinzu, um die Anzahl von sides von myFirstDice. auszugeben

println(myFirstDice.sides)

Hinweis: Sie haben beim Aufrufen von diceRange.random() zuvor die Punktschreibweise verwendet. Als Verallgemeinerung lässt sich die Notation mit etwas auf einem Punkt darstellen. Beispiel: Mit myFirstDice.sides wird auf dieser Instanz die Property sides abgerufen.

Der Code sollte so aussehen:

fun main() {
    val myFirstDice = Dice()
    println(myFirstDice.sides)
}

class Dice {
    var sides = 6
}

3. Führe dein Programm aus. Es sollte die Anzahl von sides ausgeben, die in der Dice-Klasse definiert ist.

6

Du hast jetzt eine Dice-Klasse und einen tatsächlichen Würfel myFirstDice mit sechs sides.

Gemeinsam würfeln!

Würfelspiele

Sie haben zuvor eine Funktion verwendet, um die Kuchenebenen zu drucken. Das Rolling von Würfeln kann ebenfalls als Funktion implementiert werden. Da alle Würfel gewürfelt werden können, haben Sie die Möglichkeit, in der Dice-Klasse eine entsprechende Funktion hinzuzufügen. Eine Funktion, die in einer Klasse definiert ist, wird auch als Methode bezeichnet.

1. Fügen Sie in der Klasse Dice unter der Variable sides eine leere Zeile ein und erstellen Sie dann eine neue Funktion, um die Würfel zu rollen. Beginnen Sie mit dem Kotlin-Keyword fun, gefolgt vom Namen der Methode, gefolgt von den Klammern () und öffnenden und schließenden geschweiften Klammern {}. Sie können eine leere Zeile zwischen den geschweiften Klammern lassen, um Platz für mehr Code zu schaffen, wie unten dargestellt. Ihr Kurs sollte so aussehen.

class Dice {
    var sides = 6

    fun roll() {

    }
}

Hinweis: Sie können dieser Methode einen beliebigen Namen geben. Es ist jedoch hilfreich, ihr einen Namen zu geben, der zeigt, welche Aktion ausgeführt wird. Die Namenskonvention für Funktionen und Methoden beginnt, mit einem Kleinbuchstaben zu beginnen, einen Kamelbuchstab zu verwenden und nach Möglichkeit mit einem Aktionsverb zu beginnen.

Wenn du einen sechsseitigen Würfel würfelst, erhältst du eine Zufallszahl zwischen 1 und 6.

2. Erstelle in der roll()-Methode ein val randomNumber. Weisen Sie ihr eine zufällige Zahl im Bereich 1..6 zu. Verwenden Sie die Punktschreibweise, um random() für den Bereich aufzurufen.

val randomNumber = (1..6).random()

3. Geben Sie die zufällige Zahl in der Konsole aus. Ihre fertige roll()-Methode sollte dem folgenden Code entsprechen.

fun roll() {
     val randomNumber = (1..6).random()
     println(randomNumber)
}

4. Um myFirstDice zu rollen, main() rufst du die Methode roll() auf myFirstDice auf. Sie rufen eine Methode mit der &Punkt-Notation" auf. Um die roll()-Methode von myFirstDice aufzurufen, geben Sie also myFirstDice.roll() ein. Der Text ist so ausgesprochen: myFirstDicePunkt roll()&quot.

myFirstDice.roll()

Der fertige Code sollte so aussehen.

fun main() {
    val myFirstDice = Dice()
    println(myFirstDice.sides)
    myFirstDice.roll()
}

class Dice {
    var sides = 6

    fun roll() {
        val randomNumber = (1..6).random()
        println(randomNumber)
    }
}

5. Führen Sie Ihren Code aus. Das Ergebnis einer zufälligen würfelnden Rolle sollte unter der Anzahl der Seiten zu sehen sein. Führen Sie Ihren Code mehrmals aus und beachten Sie, dass die Anzahl der Seiten gleich bleibt und sich der Würfelwert ändert.

6
4

Glückwunsch! Sie haben eine Dice-Klasse mit einer sides-Variable und einer roll()-Funktion definiert. Sie haben in der main()-Funktion eine neue Dice-Objektinstanz erstellt und dann die Methode roll() aufgerufen, um eine Zufallszahl zu generieren.

Sie drucken derzeit den Wert von randomNumber in der Funktion roll() aus. Das ist hervorragend. Manchmal ist es jedoch nützlicher, das Ergebnis einer Funktion an eine beliebige Methode zurückzugeben. So kannst du beispielsweise das Ergebnis der Methode roll() einer Variablen zuweisen und dann einen Spieler um diesen Wert verschieben. Lass uns wissen, wie das funktioniert.

1. Ändern Sie in main() die Zeile „myFirstDice.roll()“. Erstellen Sie eine val namens diceRoll. Legen Sie sie auf den Wert fest, der von der Methode roll() zurückgegeben wird.

val diceRoll = myFirstDice.roll()

Damit wird noch nichts unternommen, da roll() noch nichts zurückgibt. Damit dieser Code wie vorgesehen funktioniert, muss roll() etwas zurückgeben.

In früheren Codelabs haben Sie gelernt, dass Sie einen Datentyp angeben müssen, um Argumente für Funktionen einzugeben. Ebenso müssen Sie einen Datentyp angeben, der die Funktion zurückgibt.

2. Ändern Sie die Funktion roll(), um festzulegen, welche Art von Daten zurückgegeben werden soll. In diesem Fall ist die Zufallszahl Int. Der Rückgabetyp ist also Int. Die Syntax zum Angeben des Rückgabetyps lautet: Geben Sie nach dem Namen der Funktion einen Doppelpunkt, ein Leerzeichen und dann das Keyword Int für den Rückgabetyp der Funktion ein. Die Funktionsdefinition sollte folgendermaßen aussehen:

fun roll(): Int {

3. Führen Sie diesen Code aus. In der Problemansicht wird eine Fehlermeldung angezeigt. Sie lautet:

A ‘return'  expression is required in a function with a block body. 

Sie haben die Funktionsdefinition so geändert, dass ein Int zurückgegeben wird, aber das System beschwert sich, dass der

Code gibt kein Int zurück. Mit „Blocktext“ oder „Funktionstext“ wird der Code zwischen den geschweiften Klammern einer Funktion angegeben. Sie können diesen Fehler beheben, indem Sie mit einer return-Anweisung am Ende des Funktionstexts einen Wert von einer Funktion zurückgeben.

4. Entfernen Sie in roll() die println()-Anweisung und ersetzen Sie sie durch eine return-Anweisung für randomNumber. Die Funktion roll() sollte so aussehen:

fun roll(): Int {
     val randomNumber = (1..6).random()
     return randomNumber
}

5. Entferne in main() die Druckanweisung für die Würfel.
6. Fügen Sie eine Anweisung hinzu, um den Wert von sides und diceRoll in einem informativen Satz auszudrucken. Die fertige main()-Funktion sollte ungefähr dem unten stehenden Code entsprechen.

fun main() {
    val myFirstDice = Dice()
    val diceRoll = myFirstDice.roll()
    println("Your ${myFirstDice.sides} sided dice rolled ${diceRoll}!")
}

7. Führen Sie Ihren Code aus und die Ausgabe sollte in etwa so aussehen.

Your 6 sided dice rolled 4!

Hier ist Ihr gesamter Code.

fun main() {
    val myFirstDice = Dice()
    val diceRoll = myFirstDice.roll()
    println("Your ${myFirstDice.sides} sided dice rolled ${diceRoll}!")
}


class Dice {
    var sides = 6

    fun roll(): Int {
        val randomNumber = (1..6).random()
        return randomNumber
    }
}

Nicht alle Würfel haben 6 Seiten. Würfel ist in allen Formen und Größen verfügbar: 4 Seiten, 8 Seiten, bis zu 120 Seiten!

1. Ändern Sie in Ihrer Dice-Klasse in der Methode roll() den hartcodierten 1..6 so, dass stattdessen sides verwendet wird, sodass der Bereich und damit die zufällig generierte Zahl immer für die Anzahl der Seiten richtig sind.

val randomNumber = (1..sides).random()

2. Ändern Sie in der Funktion main() unten und nach dem Drucken der Würfel den Wert sides von meinemFirstDice auf 20.

myFirstDice.sides = 20

3. Kopieren Sie die vorhandene Druckausgabe und fügen Sie sie unten ein, nachdem Sie die Anzahl der Seiten geändert haben.
4. Ersetze das Drucken von diceRoll durch das Drucken des Ergebnisses der Methode roll() in myFirstDice.

println("Your ${myFirstDice.sides} sided dice has rolled a ${myFirstDice.roll()}!")

Dein Programm sollte folgendermaßen aussehen.

fun main() {
   
    val myFirstDice = Dice()
    val diceRoll = myFirstDice.roll()
    println("Your ${myFirstDice.sides} sided dice rolled ${diceRoll}!")

    myFirstDice.sides = 20
    println("Your ${myFirstDice.sides} sided dice rolled ${myFirstDice.roll()}!")
}

class Dice {
    var sides = 6

    fun roll(): Int {
        val randomNumber = (1..sides).random()
        return randomNumber
    }
}

5. Wenn du dein Programm durchführst, solltest du eine Nachricht für den sechsseitigen Würfel und eine zweite für den 20-seitigen Würfel sehen.

Your 6 sided dice rolled 3!
Your 20 sided dice rolled 15!

Die Idee, einen Kurs zu vermitteln, besteht darin, eine Sache zu repräsentieren – oft im realen Leben. In diesem Fall stellt die Klasse Dice einen physischen Würfel dar. In der Praxis kann die Zahl der Seiten nicht verändert werden. Wenn du eine unterschiedliche Anzahl von Seiten möchtest, musst du einen anderen Würfel erhalten. Programmgesteuert bedeutet dies, dass Sie keine neue Würfelobjektinstanz mit der Anzahl der benötigten Seiten erstellen müssen, anstatt die seitliche Eigenschaft einer vorhandenen DiceObjektinstanz zu ändern.

In dieser Aufgabe ändern Sie die Klasse Dice, sodass Sie beim Erstellen einer neuen Instanz die Anzahl der Seiten angeben. Ändern Sie die Klassendefinition Dice, um ein Argument für die Anzahl der Seiten zu akzeptieren. So ähnlich kann eine Funktion Argumente für die Eingabe annehmen.

1. Ändern Sie die Dice-Klassendefinition so, dass ein Ganzzahlargument mit dem Namen numSides akzeptiert wird. Der Code in Ihrem Kurs ändert sich nicht.

class Dice(val numSides: Int) {
   // Code inside does not change.
}

2. Löschen Sie innerhalb der Klasse Dice die Variable sides, da Sie jetzt numSides verwenden können.
3. Korrigieren Sie außerdem den Bereich, um numSides zu verwenden.

Ihre Dice-Klasse sollte so aussehen.

class Dice (val numSides: Int) {

    fun roll(): Int {
        val randomNumber = (1..numSides).random()
        return randomNumber
    }
}

Wenn Sie diesen Code ausführen, werden Ihnen viele Fehler angezeigt, weil Sie main() aktualisieren müssen, um die Änderungen an der Klasse Dice verwenden zu können.

4. In main() musst du die Anzahl der Seiten als Argument an die Dice-Klasse übergeben, um myFirstDice mit sechs Seiten zu erstellen.

    val myFirstDice = Dice(6)

5. Ändern Sie in der Druckausgabe die Option sides in numSides.
6. Darunter löschen Sie den Code, der sides in 20 ändert, weil die Variable nicht mehr existiert.
7. Löschen Sie auch die Anweisung println darunter.

Die main()-Funktion sollte wie unten beschrieben aussehen. Wenn Sie sie ausführen, sollten keine Fehler auftreten.

fun main() {
    val myFirstDice = Dice(6)
    val diceRoll = myFirstDice.roll()
    println("Your ${myFirstDice.numSides} sided dice rolled ${diceRoll}!")
}

8. Füge nach dem Drucken der ersten Würfel Code hinzu, um ein zweites Dice-Objekt namens mySecondDice mit 20 Seiten zu erstellen und zu drucken.

    val mySecondDice = Dice(20)

9. Fügen Sie eine Druckanweisung hinzu, die den zurückgegebenen Wert dreht und druckt.

println("Your ${mySecondDice.numSides} sided dice rolled  ${mySecondDice.roll()}!")

10. Die fertige main()-Funktion sollte so aussehen.

fun main() {
    val myFirstDice = Dice(6)
    val diceRoll = myFirstDice.roll()
    println("Your ${myFirstDice.numSides} sided dice rolled ${diceRoll}!")
    
    val mySecondDice = Dice(20)
    println("Your ${mySecondDice.numSides} sided dice rolled ${mySecondDice.roll()}!")
}

class Dice (val numSides: Int) {

    fun roll(): Int {
        val randomNumber = (1..numSides).random()
        return randomNumber
    }
}

11. Führen Sie das abgeschlossene Programm aus. Die Ausgabe sollte in etwa so aussehen.

Your 6 sided dice rolled 5!
Your 20 sided dice rolled 7!

Eine gute Formulierung ist besser. Sie können die Variable randomNumber entfernen und die Zufallszahl direkt zurückgeben.

1. Ändern Sie die return-Anweisung, um die Zufallszahl direkt zurückzugeben.

    fun roll(): Int {
        return (1..numSides).random()
    }

In der zweiten Druckanweisung setzen Sie den Aufruf zum Abrufen der Zufallszahl in die String-Vorlage. Sie können die Variable diceRoll entfernen, indem Sie diesen Schritt in der ersten Druckanweisung ausführen.

2. Rufen Sie myFirstDice.roll() in der Stringvorlage auf und löschen Sie die Variable diceRoll. Die ersten beiden Zeilen Ihres „main()“-Codes sehen jetzt so aus.

    val myFirstDice = Dice(6)
    println("Your ${myFirstDice.numSides} sided dice rolled ${myFirstDice.roll()}!")

3. Wenn Sie den Code ausführen, sollten Sie keinen Unterschied machen.

Hinweis:Wenn Sie den Code ändern, damit er kürzer, effizienter oder einfacher zu lesen oder verständlich ist, wird dies als Refaktorierung bezeichnet. Es ist wie beim Schreiben eines Dokuments, bei dem Sie einen ersten Entwurf schreiben, der alle Informationen enthält. Anschließend können Sie die Wörter bearbeiten und verfeinern.

Das ist der letzte Code nach der Refaktorierung .

fun main() {
    val myFirstDice = Dice(6)
    println("Your ${myFirstDice.numSides} sided dice rolled ${myFirstDice.roll()}!")
    
    val mySecondDice = Dice(20)
    println("Your ${mySecondDice.numSides} sided dice rolled ${mySecondDice.roll()}!")
}

class Dice (val numSides: Int) {

    fun roll(): Int {
        return (1..numSides).random()
    }
}

fun main() {
    val myFirstDice = Dice(6)
    val diceRoll = myFirstDice.roll()
    println("Your ${myFirstDice.numSides} sided dice rolled ${diceRoll}!")
    
    val mySecondDice = Dice(20)
    println("Your ${mySecondDice.numSides} sided dice rolled ${mySecondDice.roll()}!")
}

class Dice (val numSides: Int) {

    fun roll(): Int {
        return (1..numSides).random()
    }
}

• Rufen Sie die Funktion random() für IntRange auf, um eine Zufallszahl zu generieren: (1..6).random()
• Klassen sind wie ein Entwurf eines Objekts. Sie können Eigenschaften und Verhaltensweisen definieren und als Variablen und Funktionen implementiert werden.
• Eine Instanz einer Klasse stellt ein Objekt dar, häufig ein physisches Objekt, beispielsweise einen Würfel. Sie können die Aktionen für das Objekt aufrufen und seine Attribute ändern.
• Sie können beim Erstellen einer Instanz die Eingabe an eine Klasse übergeben, indem Sie ein Argument für die Klassendefinition angeben. Beispiel: class Dice(val numSides: Int) und erstellen Sie dann eine Instanz mit Dice(6).
• Funktionen können etwas zurückgeben. Geben Sie den Datentyp an, der in der Funktionsdefinition zurückgegeben werden soll, und verwenden Sie eine return-Anweisung im Funktionstext, um etwas zurückzugeben. Beispiel: fun example(): Int { return 5 }

• Generierung von zufälligen Zahlen (Wikipedia)
• Der Mind-Boggling-Wettkampf der Entwicklung von 120-seitigen Würfeln
• Kurse in Kotlin
• Funktionsdeklarationen in Kotlin
• Wert von einer Funktion zurückgeben

Hinweis: Übungen sind optional. Sie können dort üben, was Sie in diesem Codelab gelernt haben.

Gehen Sie so vor:

• Gib der Dice-Klasse ein weiteres Farbattribut und erstelle mehrere Würfel mit unterschiedlicher Anzahl von Seiten und Farben.
• Erstellen Sie eine Coin-Klasse, damit Sie sie umdrehen können, eine Instanz der Klasse erstellen und ein paar Münzen werfen. Wie würden Sie die Zufallszahl()-Funktion mit einem Bereich verwenden, um die Münze zu werfen?