Klassen und Objektinstanzen in Kotlin

In den Codelabs in diesem Lernpfad entwickeln Sie eine Android-App zum Würfeln. Wenn der Nutzer „würfelt“, wird ein zufälliges Ergebnis generiert. Bei dem Ergebnis wird die Anzahl der Seiten des Würfels berücksichtigt. Mit einem sechsseitigen Würfel können beispielsweise nur Werte von 1 bis 6 gewürfelt werden.

So sieht die endgültige App aus.

Damit Sie sich auf die neuen Programmierkonzepte für diese App konzentrieren können, verwenden Sie das browserbasierte Kotlin-Programmiertool, um die Kernfunktionen der App zu erstellen. Das Programm gibt die Ergebnisse in der Konsole aus. Später implementieren Sie die Benutzeroberfläche in Android Studio.

In diesem ersten Codelab erstellen Sie ein Kotlin-Programm, das das Würfeln simuliert und eine zufällige Zahl ausgibt, genau wie ein Würfel.

Vorbereitung

• Code in https://try.kotlinlang.org/ öffnen, bearbeiten und ausführen
• Erstellen und ausführen Sie ein Kotlin-Programm, das Variablen und Funktionen verwendet und ein Ergebnis in der Konsole ausgibt.
• Zahlen im Text mit einer Stringvorlage mit der ${variable}-Notation formatieren

Lerninhalte

• Programmgesteuertes Generieren von Zufallszahlen zur Simulation von Würfelwürfen.
• So strukturieren Sie Ihren Code, indem Sie eine Dice-Klasse mit einer Variablen und einer Methode erstellen.
• Wie Sie eine Objektinstanz einer Klasse erstellen, ihre Variablen ändern und ihre Methoden aufrufen.

Aufgaben

• Ein Kotlin-Programm im browserbasierten Kotlin-Programmiertool, das einen zufälligen Würfelwurf ausführen kann.

Voraussetzungen

• Einen Computer mit Internetverbindung

Spiele haben oft ein Zufallselement. Sie konnten einen zufälligen Preis gewinnen oder eine zufällige Anzahl von Schritten auf dem Spielbrett vorrücken. Im Alltag können Sie zufällige Zahlen und Buchstaben verwenden, um sicherere Passwörter zu generieren.

Anstatt echte Würfel zu verwenden, können Sie ein Programm schreiben, das das Würfeln für Sie simuliert. Bei jedem Würfelwurf kann das Ergebnis eine beliebige Zahl innerhalb des Bereichs der möglichen Werte sein. Glücklicherweise müssen Sie für ein solches Programm keinen eigenen Zufallszahlengenerator erstellen. Die meisten Programmiersprachen, einschließlich Kotlin, bieten 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. Löschen Sie den gesamten vorhandenen Code im Code-Editor und ersetzen Sie ihn durch den folgenden Code. Das ist die Funktion main(), mit der Sie in früheren Codelabs gearbeitet haben (siehe Codelab Erstes Kotlin-Programm schreiben).

fun main() {

}

Zufallsfunktion verwenden

Um einen Würfel zu werfen, benötigen Sie eine Möglichkeit, alle gültigen Würfelwerte darzustellen. Bei einem regulären sechsseitigen Würfel sind die zulässigen Würfelergebnisse 1, 2, 3, 4, 5 und 6.

Sie haben bereits gelernt, dass es Datentypen wie Int für Ganzzahlen und String für Text gibt. IntRange ist ein weiterer Datentyp, der einen Bereich von Ganzzahlen von einem Start- bis zu einem Endpunkt darstellt. IntRange ist ein geeigneter Datentyp für die Darstellung der möglichen Werte, die bei einem Würfelwurf erzielt werden können.

1. Definieren Sie in der Funktion main() eine Variable als val mit dem Namen diceRange. Weisen Sie sie einem IntRange von 1 bis 6 zu, der den Bereich der Ganzzahlen darstellt, die mit einem sechsseitigen Würfel gewürfelt werden können.

val diceRange = 1..6

1..6 ist ein Kotlin-Bereich, da er eine Startnummer, zwei Punkte und eine Endnummer enthält (ohne Leerzeichen dazwischen). 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 in dieser Definition nicht IntRange steht. Genauso mussten Sie beim Erstellen einer Variablen für eine Ganzzahl oder einen String Int oder String nicht angeben. In den meisten Fällen kann das System erkennen, welchen Datentyp Sie verwenden möchten.

Das System interpretiert beispielsweise Folgendes:

val diceRange = 1..6

so:

val diceRange: IntRange = 1..6

Ähnlich wie beim Aufrufen von println(), wodurch das System den angegebenen Text ausgibt, können Sie mit der Funktion random() eine Zufallszahl für einen bestimmten Bereich generieren und zurückgeben lassen. Wie zuvor können Sie das Ergebnis in einer Variablen speichern.

2. Definieren Sie in main() eine Variable als val mit dem Namen randomNumber.
3. Weisen Sie randomNumber den Wert des Ergebnisses des Aufrufs von random() für den Bereich diceRange zu, wie unten dargestellt.

 val randomNumber = diceRange.random()

Beachten Sie, dass Sie random() für diceRange aufrufen, indem Sie einen Punkt zwischen der Variablen und dem Funktionsaufruf verwenden. Das kann als „Zufallszahl aus diceRange generieren“ gelesen werden. Das Ergebnis wird dann in der Variablen randomNumber gespeichert.

4. Um die zufällig generierte Zahl zu sehen, verwenden Sie die String-Formatierungsnotation (auch „String-Vorlage“ genannt) ${randomNumber}, um sie auszugeben, wie unten gezeigt.

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 den Code mehrmals aus. Jedes Mal sollte eine Ausgabe wie unten zu sehen sein, nur mit anderen Zufallszahlen.

Random number: 4

Tipps zu Bereichen:

• Bereiche können zwischen beliebigen Ganzzahlen liegen. Gültige Bereiche: 3..46, 0..270, -6..+6, -10..-4.
• Sie können Funktionen direkt für einen Bereich aufrufen, z. B. (1..6).random().

Wenn Sie würfeln, sind die Würfel echte Objekte in Ihren Händen. Der Code, den Sie gerade geschrieben haben, funktioniert zwar einwandfrei, aber es ist schwer vorstellbar, dass es sich um echte Würfel handelt. Wenn ein Programm so organisiert ist, dass es den Dingen, die es repräsentiert, ähnelt, ist es leichter zu verstehen. Es wäre also cool, wenn es programmatische Würfel gäbe, die man würfeln kann.

Alle Würfel funktionieren im Wesentlichen gleich. Sie haben dieselben Eigenschaften, z. B. Seiten, und dasselbe Verhalten, z. B. dass sie gerollt werden können. In Kotlin können Sie einen programmatischen Bauplan für einen Würfel erstellen, der besagt, dass Würfel Seiten haben und eine zufällige Zahl würfeln können. Diese Vorlage wird als Klasse bezeichnet.

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

Tipp:Eine Klasse ist vergleichbar mit den Bauplänen eines Architekten. Sie sind nicht das Haus selbst, sondern die Anleitung zum Bau des Hauses. Das Haus ist das tatsächliche Ding oder die Objektinstanz, die gemäß dem Bauplan erstellt wurde.

Hinweis:Das Organisieren aller Informationen zu Würfeln in einer Klasse wird als Kapselung bezeichnet. Kapselung ist ein großes, ausgefallenes Wort, aber es bedeutet nur, dass Sie Funktionen, die logisch zusammengehören, an einem einzigen Ort zusammenfassen können.

Dice-Klasse definieren

In den folgenden Schritten definieren Sie eine neue Klasse namens Dice, die einen würfelbaren Würfel darstellt.

1. Um neu zu beginnen, löschen Sie den Code in der Funktion main(), sodass Sie den unten gezeigten Code erhalten.

fun main() {

}

2. Fügen Sie unter dieser main()-Funktion eine leere Zeile und dann Code zum Erstellen der Dice-Klasse ein. Wie unten gezeigt, beginnen Sie mit dem Schlüsselwort class, gefolgt vom Namen der Klasse und dann einer öffnenden und schließenden geschweiften Klammer. Lassen Sie zwischen den geschweiften Klammern Platz für den Code für die Klasse.

class Dice {

}

Hinweis:

• Ähnlich wie beim Erstellen einer neuen Funktion mit dem Keyword fun in Kotlin verwenden Sie das Keyword class, um eine neue Klasse zu erstellen.
• Sie können einen beliebigen Namen für eine class auswählen. Es ist jedoch hilfreich, wenn der Name angibt, wofür die Klasse steht. Der Klassenname wird üblicherweise in Camel-Case-Schreibweise angegeben. Beispiele: Car, ParkingMeter und CustomerRecord sind alle gültige Klassennamen und Sie können erraten, wofür sie stehen.

Innerhalb einer Klassendefinition können Sie mit Variablen ein oder mehrere Attribute für die Klasse angeben. Echte Würfel können eine bestimmte Anzahl von Seiten, eine Farbe oder ein Gewicht haben. In dieser Aufgabe konzentrieren Sie sich auf die Eigenschaft „Anzahl der Seiten des Würfels“.

3. Fügen Sie in der Klasse Dice eine var mit dem Namen sides für die Anzahl der Seiten des Würfels hinzu. Setzen Sie sides auf 6.

class Dice {
    var sides = 6
}

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

Instanz der Klasse „Dice“ erstellen

Mit dieser Dice-Klasse haben Sie einen Bauplan für einen Würfel. Damit Sie einen tatsächlichen Würfel in Ihrem Programm haben, müssen Sie eine Dice-Objektinstanz erstellen. Wenn Sie drei Würfel benötigen, erstellen Sie drei Objektinstanzen.

1. Um eine Objektinstanz von Dice zu erstellen, erstellen Sie in der Funktion main() ein val mit dem Namen myFirstDice und initialisieren Sie es als Instanz der Klasse Dice. Beachten Sie die Klammern nach dem Klassennamen. Sie geben an, dass Sie eine neue Objektinstanz aus der Klasse erstellen.

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

Nachdem Sie ein myFirstDice-Objekt, also ein aus dem Blueprint erstelltes Objekt, haben, können Sie auf seine Eigenschaften zugreifen. Die einzige Property von Dice ist sides. Sie greifen mit der Punktnotation auf eine Property zu. Um also auf das Attribut sides von myFirstDice zuzugreifen, rufen Sie myFirstDice.sides auf, was als „myFirstDice Punkt sides“ ausgesprochen wird.

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

println(myFirstDice.sides)

Hinweis:Sie haben die Punktnotation bereits beim Aufrufen von diceRange.random() verwendet. Allgemein lässt sich die Punktnotation so zusammenfassen: „auf etwas-Punkt-führe eine Aktion aus“. Beispiel: myFirstDice.sides, „rufe für diese Instanz das Attribut sides ab“.

Ihr Code sollte so aussehen.

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

class Dice {
    var sides = 6
}

3. Führen Sie Ihr Programm aus. Es sollte die Anzahl der sides ausgeben, die in der Klasse Dice definiert sind.

6

Sie haben jetzt eine Dice-Klasse und einen echten Würfel myFirstDice mit 6 sides.

Lass uns die Würfel rollen!

Lass die Würfel rollen

Sie haben zuvor eine Funktion verwendet, um Kuchenschichten zu drucken. Das Würfeln kann auch als Funktion implementiert werden. Da alle Würfel geworfen werden können, können Sie eine Funktion dafür in der Klasse Dice hinzufügen. Eine Funktion, die in einer Klasse definiert ist, wird auch als Methode bezeichnet.

1. Fügen Sie in der Klasse Dice unter der Variablen sides eine leere Zeile ein und erstellen Sie dann eine neue Funktion zum Würfeln. Beginnen Sie mit dem Kotlin-Keyword fun, gefolgt vom Namen der Methode, gefolgt von runden Klammern (), gefolgt von geschweiften Klammern {}. Sie können zwischen den geschweiften Klammern eine leere Zeile einfügen, um Platz für weiteren Code zu schaffen, wie unten gezeigt. Ihre Klasse sollte so aussehen.

class Dice {
    var sides = 6

    fun roll() {

    }
}

Hinweis:Sie können diese Methode beliebig benennen. Es ist jedoch hilfreich, ihr einen Namen zu geben, der angibt, welche Aktion sie ausführt. Funktionen und Methoden sollten mit einem Kleinbuchstaben beginnen, CamelCase verwenden und möglichst mit einem Tätigkeitsverb beginnen.

Wenn Sie einen sechsseitigen Würfel werfen, erhalten Sie eine Zufallszahl zwischen 1 und 6.

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

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

3. Geben Sie die zufällige Zahl nach dem Generieren in der Konsole aus. Ihre fertige roll()-Methode sollte so aussehen:

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

4. Um myFirstDice tatsächlich in main() zu rendern, rufen Sie die Methode roll() für myFirstDice auf. Sie rufen eine Methode mit der Punktnotation auf. Wenn Sie also die Methode roll() von myFirstDice aufrufen möchten, geben Sie myFirstDice.roll() ein. Das wird als „myFirstDice Punkt roll()“ ausgesprochen.

myFirstDice.roll()

Ihr fertiger 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 den Code aus. Unter der Anzahl der Seiten sollte das Ergebnis eines zufälligen Würfelwurfs angezeigt werden. Führen Sie den Code mehrmals aus. Die Anzahl der Seiten bleibt gleich, der Wert des Würfelwurfs ändert sich.

6
4

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

Derzeit geben Sie den Wert von randomNumber in Ihrer Funktion roll() aus. Das funktioniert einwandfrei. Manchmal ist es jedoch sinnvoller, das Ergebnis einer Funktion an den Aufrufer zurückzugeben. Sie könnten beispielsweise das Ergebnis der roll()-Methode einer Variablen zuweisen und dann einen Spieler um diesen Betrag bewegen. Sehen wir uns an, wie das funktioniert.

1. Ändern Sie in main() die Zeile myFirstDice.roll(). Erstellen Sie einen val mit dem Namen diceRoll. Legen Sie sie auf den Wert fest, der von der Methode roll() zurückgegeben wird.

val diceRoll = myFirstDice.roll()

Das hat noch keine Auswirkungen, 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 für Eingabeargumente für Funktionen angeben müssen. Ebenso müssen Sie einen Datentyp für Daten angeben, die von einer Funktion zurückgegeben werden.

2. Ändern Sie die Funktion roll(), um festzulegen, welcher Datentyp zurückgegeben werden soll. In diesem Fall ist die Zufallszahl eine Int, daher ist der Rückgabetyp Int. Die Syntax zum Angeben des Rückgabetyps lautet: Fügen Sie nach dem Namen der Funktion und nach den Klammern einen Doppelpunkt, ein Leerzeichen und dann das Schlüsselwort Int für den Rückgabetyp der Funktion ein. Die Funktionsdefinition sollte so aussehen:

fun roll(): Int {

3. Führen Sie diesen Code aus. In der Ansicht „Probleme“ wird ein Fehler angezeigt. Dort steht:

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 meldet, dass

Der Code gibt nicht wirklich ein Int zurück. „Blockkörper“ oder „Funktionskörper“ bezieht sich auf den Code zwischen den geschweiften Klammern einer Funktion. Sie können diesen Fehler beheben, indem Sie mit einer return-Anweisung am Ende des Funktionsrumpfs einen Wert aus einer Funktion zurückgeben.

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

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

5. Entfernen Sie in main() die print-Anweisung für die Seiten des Würfels.
6. Fügen Sie eine Anweisung hinzu, um den Wert von sides und diceRoll in einem informativen Satz auszugeben. Ihre fertige main()-Funktion sollte in etwa so aussehen:

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

7. Führen Sie den Code aus. Die Ausgabe sollte so aussehen:

Your 6 sided dice rolled 4!

Hier ist der gesamte Code, den du bisher eingegeben hast.

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. Es gibt Würfel in allen Formen und Größen: mit 4, 8 oder sogar 120 Seiten.

1. Ändern Sie in Ihrer Dice-Klasse in der Methode roll() den hartcodierten Wert 1..6 in sides, damit der Bereich und damit die zufällige Zahl, die gewürfelt wird, immer der Anzahl der Seiten entspricht.

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

2. Ändere in der Funktion main() unter und nach dem Drucken des Würfelwurfs sides von myFirstDice auf 20.

myFirstDice.sides = 20

3. Kopieren Sie die vorhandene print-Anweisung unten und fügen Sie sie nach der Stelle ein, an der Sie die Anzahl der Seiten geändert haben.
4. Ersetzen Sie das Drucken von diceRoll durch das Drucken des Ergebnisses des Aufrufs der Methode roll() für myFirstDice.

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

Ihr Programm sollte so 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. Führen Sie das Programm aus. Es sollte eine Meldung für den sechsseitigen Würfel und eine zweite Meldung für den zwanzigseitigen Würfel angezeigt werden.

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

Die Idee einer Klasse besteht darin, ein Ding darzustellen, oft etwas Physisches in der realen Welt. In diesem Fall stellt die Klasse Dice einen physischen Würfel dar. Im echten Leben kann sich die Anzahl der Seiten eines Würfels nicht ändern. Wenn Sie eine andere Anzahl von Seiten wünschen, benötigen Sie einen anderen Würfel. Programmatisch bedeutet das, dass Sie anstelle der Änderung der „sides“-Property einer vorhandenen Dice-Objektinstanz eine neue Würfelobjektinstanz mit der gewünschten Anzahl von Seiten erstellen sollten.

In dieser Aufgabe ändern Sie die Klasse Dice so, dass Sie die Anzahl der Seiten angeben können, wenn Sie eine neue Instanz erstellen. Ändern Sie die Klassendefinition Dice, damit ein Argument für die Anzahl der Seiten akzeptiert wird. Das ist ähnlich wie bei einer Funktion, die Argumente für die Eingabe akzeptieren kann.

1. Ändern Sie die Klassendefinition Dice, um ein Ganzzahlargument namens numSides zu akzeptieren. Der Code in Ihrer Klasse ändert sich nicht.

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

2. Löschen Sie in der Klasse Dice die Variable sides, da Sie jetzt numSides verwenden können.
3. Legen Sie außerdem den Bereich auf numSides fest.

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 viele Fehler angezeigt, da Sie main() an die Änderungen an der Klasse Dice anpassen müssen.

4. Um in main() ein myFirstDice mit 6 Seiten zu erstellen, müssen Sie die Anzahl der Seiten jetzt als Argument an die Klasse Dice übergeben, wie unten dargestellt.

    val myFirstDice = Dice(6)

5. Ändern Sie in der Print-Anweisung sides in numSides.
6. Löschen Sie darunter den Code, der sides in 20 ändert, da diese Variable nicht mehr vorhanden ist.
7. Löschen Sie auch die Anweisung println darunter.

Ihre main()-Funktion sollte so aussehen wie im Code unten. 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ügen Sie nach dem Drucken des ersten Würfelwurfs Code hinzu, um ein zweites Dice-Objekt mit 20 Seiten namens mySecondDice zu erstellen und zu drucken.

    val mySecondDice = Dice(20)

9. Fügen Sie eine Print-Anweisung hinzu, die den zurückgegebenen Wert ausgibt.

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 fertige Programm aus. Die Ausgabe sollte so aussehen.

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

Beim Schreiben von Code ist es besser, sich kurz zu fassen. Sie können die Variable randomNumber entfernen und die Zufallszahl direkt zurückgeben.

1. Ändern Sie die return-Anweisung so, dass die Zufallszahl direkt zurückgegeben wird.

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

In der zweiten Print-Anweisung fügen Sie den Aufruf zum Abrufen der Zufallszahl in die Stringvorlage ein. Sie können die Variable diceRoll entfernen, indem Sie dasselbe in der ersten Print-Anweisung tun.

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. Führen Sie den Code aus. Die Ausgabe sollte sich nicht unterscheiden.

Hinweis:Das Ändern von Code, um ihn kürzer, effizienter oder leichter lesbar und verständlich zu machen, wird als Refactoring bezeichnet. Es ist wie beim Schreiben eines Dokuments: Sie erstellen einen ersten Entwurf mit allen Informationen und bearbeiten und verfeinern dann Ihre Formulierungen.

Das ist Ihr endgültiger Code nach dem Refactoring .

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 ein IntRange auf, um eine Zufallszahl zu generieren: (1..6).random()
• Klassen sind wie ein Bauplan für ein Objekt. Sie können Eigenschaften und Verhaltensweisen haben, die als Variablen und Funktionen implementiert werden.
• Eine Instanz einer Klasse stellt ein Objekt dar, häufig ein physisches Objekt wie einen Würfel. Sie können die Aktionen für das Objekt aufrufen und seine Attribute ändern.
• Sie können einer Klasse Eingaben übergeben, wenn Sie eine Instanz erstellen, indem Sie ein Argument für die Klassendefinition angeben. Beispiel: class Dice(val numSides: Int) und dann eine Instanz mit Dice(6) erstellen.
• 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 Funktionsrumpf, um etwas zurückzugeben. Beispiel: fun example(): Int { return 5 }

• Generierung von Zufallszahlen (Wikipedia)
• Die unglaubliche Herausforderung, 120-seitige Würfel zu entwerfen
• Klassen in Kotlin
• Funktionsdeklarationen in Kotlin
• Rückgabe eines Werts aus einer Funktion

Hinweis : Übungen sind optional. Sie bieten Ihnen die Möglichkeit, das in diesem Codelab Gelernte zu üben.

Gehen Sie so vor:

• Geben Sie der Klasse Dice ein weiteres Attribut für die Farbe und erstellen Sie mehrere Instanzen von Würfeln mit unterschiedlicher Anzahl von Seiten und Farben.
• Erstelle eine Coin-Klasse, gib ihr die Möglichkeit, Münzen zu werfen, erstelle eine Instanz der Klasse und wirf einige Münzen! Wie würden Sie die Funktion „random()“ mit einem Bereich verwenden, um den Münzwurf zu simulieren?