Kotlin'de sınıflar ve nesne örnekleri

Bu rotadaki codelab'lerde, bir zar atma Android uygulaması oluşturacaksınız. Kullanıcı "zarı attığında" rastgele bir sonuç oluşturulacak. Sonuç, zarın yüz sayısını dikkate alır. Örneğin, 6 yüzlü bir zarda yalnızca 1-6 arasındaki değerler atılabilir.

Nihai uygulama bu şekilde görünecek.

Bu uygulamanın yeni programlama kavramlarına odaklanmanıza yardımcı olmak için temel uygulama işlevlerini oluşturmak üzere tarayıcı tabanlı Kotlin programlama aracını kullanacaksınız. Program, sonuçlarınızı konsola verir. Daha sonra kullanıcı arayüzünü Android Studio'da uygulayacaksınız.

Bu ilk codelab'de, zar atma işlemini simüle eden ve zar gibi rastgele bir sayı çıkaran bir Kotlin programı oluşturacaksınız.

Ön koşullar

• https://try.kotlinlang.org/ adresinde kodu açma, düzenleme ve çalıştırma
• Değişkenler ve işlevler kullanan, konsola sonuç yazdıran bir Kotlin programı oluşturup çalıştırın.
• ${variable} gösterimini içeren bir dize şablonu kullanarak metin içindeki sayıları biçimlendirin.

Neler öğreneceksiniz?

• Zar atma simülasyonu için programatik olarak rastgele sayılar oluşturma
• Değişken ve yöntem içeren bir Dice sınıfı oluşturarak kodunuzu nasıl yapılandıracağınızı öğrenin.
• Bir sınıfın nesne örneğini oluşturma, değişkenlerini değiştirme ve yöntemlerini çağırma

Ne oluşturacaksınız?

• Tarayıcı tabanlı Kotlin programlama aracında, rastgele zar atma işlemi yapabilen bir Kotlin programı.

İhtiyacınız olanlar

• İnternet bağlantısı olan bir bilgisayar

Oyunlarda genellikle rastgele bir öğe bulunur. Rastgele bir ödül kazanabilir veya oyun tahtasında rastgele sayıda adım ilerleyebilirsiniz. Günlük hayatınızda daha güvenli şifreler oluşturmak için rastgele sayılar ve harfler kullanabilirsiniz.

Gerçek zar atmak yerine, sizin için zar atma işlemini simüle eden bir program yazabilirsiniz. Zar her atıldığında sonuç, olası değerler aralığındaki herhangi bir sayı olabilir. Neyse ki bu tür bir program için kendi rastgele sayı oluşturucunuzu oluşturmanız gerekmez. Kotlin de dahil olmak üzere çoğu programlama dilinde rastgele sayılar oluşturmak için yerleşik bir yöntem bulunur. Bu görevde, rastgele bir sayı oluşturmak için Kotlin kodunu kullanacaksınız.

Başlangıç kodunuzu ayarlama

1. Tarayıcınızda https://try.kotlinlang.org/ web sitesini açın.
2. Kod düzenleyicideki mevcut tüm kodu silip aşağıdaki kodla değiştirin. Bu, önceki codelab'lerde kullandığınız main() işlevidir (İlk Kotlin programınızı yazma codelab'ine bakın).

fun main() {

}

Rastgele işlevini kullanma

Bir zar atmak için geçerli tüm zar atma değerlerini temsil etmenin bir yolunu bulmanız gerekir. Normal 6 yüzlü bir zar için kabul edilebilir zar atışları şunlardır: 1, 2, 3, 4, 5 ve 6.

Daha önce, tam sayılar için Int ve metin için String gibi veri türleri olduğunu öğrenmiştiniz. IntRange başka bir veri türüdür ve bir başlangıç noktasından bir bitiş noktasına kadar olan tam sayı aralığını temsil eder. IntRange, zar atıldığında elde edilebilecek olası değerleri temsil etmek için uygun bir veri türüdür.

1. main() işlevinizin içinde, diceRange adlı bir val olarak değişken tanımlayın. 6 yüzlü bir zarın atıldığında gelebileceği tam sayı aralığını temsil eden 1 ile 6 arasındaki bir IntRange değerini atayın.

val diceRange = 1..6

1..6, başlangıç sayısı, iki nokta ve bitiş sayısı (arada boşluk yok) içerdiğinden Kotlin aralığı olduğunu anlayabilirsiniz. Tam sayı aralıklarına diğer örnekler: 2-5 arasındaki sayılar için 2..5, 100-200 arasındaki sayılar için 100..200.

İpucu: Bu tanımda IntRange ifadesinin yer almadığını fark edin. Tıpkı bir tam sayı veya dize için değişken oluştururken Int ya da String belirtmeniz gerekmediği gibi. Sistem, çoğu zaman hangi veri türünü kullanmak istediğinizi anlayabilir.

Örneğin, sistem şu ifadeyi şu şekilde yorumlar:

val diceRange = 1..6

örneğin:

val diceRange: IntRange = 1..6

println() işlevini çağırmak sisteme verilen metni yazdırmasını söylemeye benzer. Belirli bir aralıkta sizin için rastgele bir sayı oluşturup döndürmek üzere random() adlı bir işlevi kullanabilirsiniz. Sonucu daha önce olduğu gibi bir değişkende saklayabilirsiniz.

2. main() içinde, randomNumber adlı bir değişkeni val olarak tanımlayın.
3. Aşağıda gösterildiği gibi, randomNumber değişkeninin diceRange aralığında random() işlevi çağrıldığında elde edilen sonuç değerine sahip olmasını sağlayın.

 val randomNumber = diceRange.random()

Değişken ile işlev çağrısı arasında nokta kullanarak random() işlevini diceRange üzerinde çağırdığınızı unutmayın. Bu ifadeyi "diceRange değerinden rastgele bir sayı oluşturma" olarak okuyabilirsiniz. Sonuç daha sonra randomNumber değişkeninde saklanır.

4. Rastgele oluşturulan numaranızı görmek için aşağıdaki örnekte gösterildiği gibi, dize biçimlendirme notasyonunu (aynı zamanda "dize şablonu" olarak da adlandırılır) ${randomNumber} kullanarak yazdırın.

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

Tamamlanmış kodunuz aşağıdaki gibi görünmelidir.

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

5. Kodunuzu birkaç kez çalıştırın. Her seferinde, farklı rastgele sayılarla aşağıdaki gibi bir çıkış görmeniz gerekir.

Random number: 4

Aralıklarla ilgili ipuçları:

• Aralıklar herhangi bir tam sayı arasında olabilir. Geçerli aralıklar şunlardır: 3..46, 0..270, -6..+6, -10..-4.
• İşlevleri doğrudan bir aralıkta çağırabilirsiniz. Örneğin: (1..6).random().

Zar attığınızda, zarlar elinizdeki gerçek nesnelerdir. Yazdığınız kod mükemmel bir şekilde çalışsa da bunun gerçek zarla ilgili olduğunu düşünmek zor. Bir programı temsil ettiği şeylere daha çok benzeyecek şekilde düzenlemek, programın anlaşılmasını kolaylaştırır. Bu nedenle, programatik zar atabilmek çok güzel olurdu.

Tüm zarlar temelde aynı şekilde çalışır. Aynı özelliklere (ör. kenarlar) ve aynı davranışlara (ör. yuvarlanabilme) sahiptirler. Kotlin'de, zarların yüzleri olduğunu ve rastgele bir sayı atabileceğini belirten bir zar planı oluşturabilirsiniz. Bu plana sınıf denir.

Bu sınıftan nesne örnekleri adı verilen gerçek zar nesneleri oluşturabilirsiniz. Örneğin, 12 yüzlü veya 4 yüzlü bir zar oluşturabilirsiniz.

İpucu: Sınıf, bir mimarın planlarının ev olmaması gibi, evin nasıl inşa edileceğine dair talimatlardır. Ev, plan doğrultusunda oluşturulan gerçek şey veya nesne örneğidir.

Not: Zarla ilgili her şeyi bir sınıfta düzenlemeye kapsülleme denir. Kapsülleme, büyük ve süslü bir kelime olsa da mantıksal olarak ilişkili işlevleri tek bir yerde toplayabileceğiniz anlamına gelir.

Dice sınıfı tanımlama

Aşağıdaki adımlarda, yuvarlanabilir bir zarı temsil etmek için Dice adlı yeni bir sınıf tanımlayacaksınız.

1. Yeniden başlamak için main() işlevindeki kodu temizleyerek aşağıdaki gibi bir kod elde edin.

fun main() {

}

2. Bu main() işlevinin altına boş bir satır ekleyin ve ardından Dice sınıfını oluşturmak için kod ekleyin. Aşağıda gösterildiği gibi, class anahtar kelimesiyle başlayın, ardından sınıfın adını ve açma ve kapama küme parantezini ekleyin. Sınıf kodunuzu yerleştirmek için küme parantezleri arasında boşluk bırakın.

class Dice {

}

Not:

• Kotlin'de yeni bir işlev oluşturmak için fun anahtar kelimesini kullanmaya benzer şekilde, yeni bir sınıf oluşturmak için class anahtar kelimesini kullanın.
• class için istediğiniz adı seçebilirsiniz ancak sınıfın neyi temsil ettiğini belirten bir ad kullanmanız faydalı olur. Sınıf adı, kural olarak camel case (birleşik kelimelerde her kelimenin ilk harfinin büyük yazılması) biçimindedir. Örneğin: Car, ParkingMeter ve CustomerRecord geçerli sınıf adlarıdır ve neyi temsil ettiklerini tahmin edebilirsiniz.

Sınıf tanımı içinde, değişkenleri kullanarak sınıf için bir veya daha fazla özellik belirtebilirsiniz. Gerçek zarların yüz sayısı, rengi veya ağırlığı olabilir. Bu görevde, zarın yüz sayısı özelliğine odaklanacaksınız.

3. Dice sınıfının içine, zarınızın kaç yüzlü olacağını belirten sides adlı bir var ekleyin. sides değerini 6 olarak ayarlayın.

class Dice {
    var sides = 6
}

Bu kadar basit. Artık zarları temsil eden çok basit bir sınıfınız var.

Dice sınıfının bir örneğini oluşturun

Bu Dice sınıfıyla, zarın ne olduğuna dair bir planınız olur. Programınızda gerçek bir zar olması için Dice nesne örneği oluşturmanız gerekir. (Üç zara ihtiyacınız olsaydı üç nesne örneği oluştururdunuz.)

1. Dice sınıfının bir nesne örneğini oluşturmak için main() işlevinde myFirstDice adlı bir val oluşturun ve bunu Dice sınıfının bir örneği olarak başlatın. Sınıf adından sonraki parantezlere dikkat edin. Bu parantezler, sınıftan yeni bir nesne örneği oluşturduğunuzu gösterir.

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

Artık myFirstDice nesneniz olduğuna göre (plan kullanılarak oluşturulan bir şey) özelliklerine erişebilirsiniz. Dice'nın tek özelliği sides'dir. Bir özelliğe "nokta gösterimi" kullanarak erişirsiniz. Bu nedenle, myFirstDice öğesinin sides özelliğine erişmek için "myFirstDice nokta sides" olarak telaffuz edilen myFirstDice.sides'ı çağırırsınız.

2. myFirstDice beyanının altına, myFirstDice. öğesinin sides sayısını çıkaran bir println() ifadesi ekleyin.

println(myFirstDice.sides)

Not: diceRange.random() işlevini çağırırken daha önce nokta gösterimini kullandınız. Genel olarak nokta gösterimini "bir şey üzerinde-nokta-bir işlem yap" olarak düşünebilirsiniz. Örneğin, myFirstDice.sides ile "bu örnekte sides özelliğini al".

Kodunuz aşağıdaki gibi görünmelidir.

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

class Dice {
    var sides = 6
}

3. Programınızı çalıştırdığınızda Dice sınıfında tanımlanan sides sayısı çıkışı alınır.

6

Artık Dice sınıfınız ve 6 sides içeren gerçek bir zar myFirstDice var.

Haydi zarları atalım!

Zarı Atın

Daha önce pasta katlarını yazdırma işlemini gerçekleştirmek için bir işlev kullandınız. Zar atma da işlev olarak uygulanabilen bir eylemdir. Tüm zarlar atılabildiğinden Dice sınıfına bununla ilgili bir işlev ekleyebilirsiniz. Bir sınıfın içinde tanımlanan işlevlere yöntem de denir.

1. Dice sınıfında, sides değişkeninin altına boş bir satır ekleyin ve ardından zar atmak için yeni bir işlev oluşturun. fun Kotlin anahtar kelimesiyle başlayın, ardından yöntemin adını, parantezleri () ve açma ve kapatma küme parantezlerini {} ekleyin. Aşağıda gösterildiği gibi, daha fazla kod için yer açmak üzere küme parantezleri arasında boş bir satır bırakabilirsiniz. Sınıfınız aşağıdaki gibi görünmelidir.

class Dice {
    var sides = 6

    fun roll() {

    }
}

Not: Bu yönteme istediğiniz adı verebilirsiniz ancak hangi işlemi gerçekleştirdiğini belirten bir ad vermeniz faydalı olur. İşlevler ve yöntemler için adlandırma kuralı, küçük harfle başlamak, camel case kullanmak ve mümkünse bir fiille başlamaktır.

Altı yüzlü bir zar attığınızda 1 ile 6 arasında rastgele bir sayı elde edersiniz.

2. roll() yönteminin içinde bir val randomNumber oluşturun. Bu öğeye 1..6 aralığında rastgele bir sayı atayın. Aralıkta random() işlevini çağırmak için nokta gösterimini kullanın.

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

3. Rastgele sayıyı oluşturduktan sonra konsola yazdırın. Tamamlanmış roll() yönteminiz aşağıdaki koda benzemelidir.

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

4. myFirstDice öğesini main() içinde gerçekten kullanıma sunmak için myFirstDice üzerinde roll() yöntemini çağırın. "Nokta gösterimi"ni kullanarak bir yöntemi çağırırsınız. Bu nedenle, myFirstDice öğesinin roll() yöntemini çağırmak için myFirstDice.roll() yazarsınız. Bu, "myFirstDice nokta roll()" olarak telaffuz edilir.

myFirstDice.roll()

Tamamlanmış kodunuz aşağıdaki gibi görünmelidir.

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. Kodunuzu çalıştırın. Kenar sayısının altında rastgele bir zar atma sonucu görürsünüz. Kodunuzu birkaç kez çalıştırın. Kenar sayısının aynı kaldığını ve zar atma değerinin değiştiğini fark edeceksiniz.

6
4

Tebrikler! Dice değişkeni ve roll() işlevi içeren bir Dice sınıfı tanımladınız.sides main() işlevinde yeni bir Dice nesne örneği oluşturup rastgele bir sayı üretmek için roll() yöntemini çağırdınız.

Şu anda roll() işlevinizde randomNumber değerini yazdırıyorsunuz ve bu harika çalışıyor. Ancak bazen bir işlevin sonucunu, işlevi çağıran yere döndürmek daha faydalı olabilir. Örneğin, roll() yönteminin sonucunu bir değişkene atayabilir ve ardından oyuncuyu bu miktarda hareket ettirebilirsiniz. Bunun nasıl yapıldığını görelim.

1. main() bölümünde myFirstDice.roll() yazan satırı değiştirin. val adlı bir diceRoll oluşturun. Bu değeri, roll() yöntemi tarafından döndürülen değere eşit olarak ayarlayın.

val diceRoll = myFirstDice.roll()

roll() henüz bir şey döndürmediği için bu işlem henüz bir şey yapmaz. Bu kodun amaçlandığı gibi çalışması için roll() bir değer döndürmelidir.

Önceki codelab'lerde, işlevlere giriş bağımsız değişkenleri için bir veri türü belirtmeniz gerektiğini öğrenmiştiniz. Aynı şekilde, bir işlevin döndürdüğü veriler için de bir veri türü belirtmeniz gerekir.

2. Hangi tür verilerin döndürüleceğini belirtmek için roll() işlevini değiştirin. Bu durumda, rastgele sayı Int olduğundan dönüş türü Int olur. Dönüş türünü belirtme söz dizimi şöyledir: İşlev adından sonra, parantezlerden sonra iki nokta üst üste, boşluk ve ardından işlevin dönüş türü için Int anahtar kelimesini ekleyin. İşlev tanımı aşağıdaki koda benzemelidir.

fun roll(): Int {

3. Bu kodu çalıştırın. Sorunlar görünümünde bir hata görürsünüz. Şöyle diyor:

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

İşlev tanımını Int döndürecek şekilde değiştirdiniz ancak sistem,

kod aslında Int döndürmüyor. "Blok gövdesi" veya "işlev gövdesi", bir işlevin küme parantezleri arasındaki kodu ifade eder. İşlev gövdesinin sonunda return ifadesini kullanarak bir işlevden değer döndürerek bu hatayı düzeltebilirsiniz.

4. roll() içinde println() ifadesini kaldırın ve randomNumber için return ifadesiyle değiştirin. roll() işleviniz aşağıdaki koda benzemelidir.

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

5. main() içinde zarın kenarları için yazdırma ifadesini kaldırın.
6. sides ve diceRoll değerini bilgilendirici bir cümleyle yazdırmak için bir ifade ekleyin. Tamamlanmış main() işleviniz aşağıdaki koda benzer olmalıdır.

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

7. Kodunuzu çalıştırın. Çıkışınız aşağıdaki gibi olmalıdır.

Your 6 sided dice rolled 4!

Şu ana kadar yazdığınız tüm kodlar burada yer alıyor.

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
    }
}

Her zarın 6 yüzü yoktur. Zarlar her şekil ve boyutta olabilir: 4 yüzlü, 8 yüzlü, hatta 120 yüzlü!

1. Dice sınıfınızda, roll() yönteminizde, aralığın ve dolayısıyla atılan rastgele sayının her zaman kenar sayısına uygun olması için sabit kodlanmış 1..6 değerini sides olarak değiştirin.

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

2. main() işlevinde, zar atma işlemi yazdırıldıktan sonra FirstDice değişkeninin sides değerini 20 olarak değiştir.

myFirstDice.sides = 20

3. Aşağıdaki mevcut yazdırma ifadesini, sayfa sayısını değiştirdiğiniz yerin sonrasına kopyalayıp yapıştırın.
4. diceRoll yazdırma işlemini, myFirstDice üzerinde roll() yöntemi çağrıldığında elde edilen sonucu yazdırma işlemiyle değiştirin.

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

Programınız aşağıdaki gibi görünmelidir.

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. Programınızı çalıştırdığınızda 6 yüzlü zar için bir mesaj ve 20 yüzlü zar için ikinci bir mesaj görmeniz gerekir.

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

Sınıf kavramı, genellikle gerçek dünyadaki fiziksel bir şeyi temsil etmek için kullanılır. Bu durumda, Dice sınıfı fiziksel bir zarı temsil eder. Gerçek dünyada zarların kenar sayısı değiştirilemez. Farklı sayıda yüzü olan bir zar istiyorsanız başka bir zar almanız gerekir. Programatik olarak bu, mevcut bir Dice nesne örneğinin sides özelliğini değiştirmek yerine, ihtiyacınız olan sayıda yüzü olan yeni bir zar nesnesi örneği oluşturmanız gerektiği anlamına gelir.

Bu görevde, yeni bir örnek oluştururken kenar sayısını belirtebilmeniz için Dice sınıfını değiştireceksiniz. Dice sınıf tanımını, kenar sayısı için bir bağımsız değişken kabul edecek şekilde değiştirin. Bu, bir işlevin girdi için bağımsız değişkenleri kabul etmesine benzer.

1. Dice sınıf tanımını, numSides adlı bir tam sayı bağımsız değişkenini kabul edecek şekilde değiştirin. Sınıfınızdaki kod değişmez.

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

2. Dice sınıfında, artık numSides değişkenini kullanabileceğiniz için sides değişkenini silin.
3. Ayrıca, numSides kullanmak için aralığı düzeltin.

Dice sınıfınız aşağıdaki gibi görünmelidir.

class Dice (val numSides: Int) {

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

Bu kodu çalıştırırsanız main() sınıfındaki değişikliklerle çalışması için main() sınıfını güncellemeniz gerektiğinden birçok hata görürsünüz.Dice

4. main() içinde 6 kenarlı myFirstDice oluşturmak için artık kenar sayısını aşağıdaki örnekte gösterildiği gibi Dice sınıfına bağımsız değişken olarak iletmeniz gerekir.

    val myFirstDice = Dice(6)

5. Yazdırma ifadesinde sides ifadesini numSides olarak değiştirin.
6. Bunun altında, sides değerini 20 olarak değiştiren kodu silin. Çünkü bu değişken artık mevcut değildir.
7. Altındaki println ifadesini de silin.

main() işleviniz aşağıdaki koda benzemelidir ve çalıştırdığınızda hata olmamalıdır.

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

8. İlk zar atışını yazdırdıktan sonra 20 yüzlü mySecondDice adlı ikinci bir Dice nesnesi oluşturup yazdırmak için kod ekleyin.

    val mySecondDice = Dice(20)

9. Döndürülen değeri kaydıran ve yazdıran bir yazdırma ifadesi ekleyin.

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

10. Tamamlanmış main() işleviniz aşağıdaki gibi görünmelidir.

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. Tamamladığınız programı çalıştırın. Çıkışınız aşağıdaki gibi görünmelidir.

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

Kod yazarken kısa ve öz olmak daha iyidir. randomNumber değişkenini kaldırabilir ve rastgele sayıyı doğrudan döndürebilirsiniz.

1. Rastgele sayıyı doğrudan döndürmek için return ifadesini değiştirin.

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

İkinci yazdırma ifadesinde, rastgele sayıyı almak için yapılan çağrıyı dize şablonuna yerleştirirsiniz. İlk yazdırma ifadesinde aynı şeyi yaparak diceRoll değişkeninden kurtulabilirsiniz.

2. Dize şablonunda myFirstDice.roll() işlevini çağırın ve diceRoll değişkenini silin. main() kodunuzun ilk iki satırı artık aşağıdaki gibi görünüyor.

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

3. Kodunuzu çalıştırın. Çıkışta herhangi bir fark olmamalıdır.

Not: Kodu daha kısa, daha verimli veya okunup anlaşılması daha kolay hale getirmek için yapılan değişikliklere yeniden düzenleme denir. Bu, bir belge yazmaya benzer. Tüm bilgileri içeren bir ilk taslak yazarsınız, ardından kelimelerinizi düzenleyip iyileştirirsiniz.

Bu, yeniden düzenleme işleminden sonraki son kodunuzdur .

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()
    }
}

• Rastgele sayı oluşturmak için IntRange üzerinde random() işlevini çağırın: (1..6).random()
• Sınıflar, bir nesnenin planı gibidir. Değişkenler ve işlevler olarak uygulanan özellikleri ve davranışları olabilir.
• Bir sınıf örneği, genellikle fiziksel bir nesne olan bir zar gibi bir nesneyi temsil eder. Nesne üzerindeki işlemleri çağırabilir ve özelliklerini değiştirebilirsiniz.
• Sınıf tanımı için bir bağımsız değişken belirterek örnek oluşturduğunuzda sınıfa giriş iletebilirsiniz. Örneğin: class Dice(val numSides: Int) ve ardından Dice(6) ile bir örnek oluşturun.
• İşlevler bir değer döndürebilir. İşlev tanımında döndürülecek veri türünü belirtin ve bir şey döndürmek için işlev gövdesinde return ifadesini kullanın. Örneğin: fun example(): Int { return 5 }

• Rastgele sayı üretme (Wikipedia)
• 120 yüzlü zar tasarlamanın akıl almaz zorluğu
• Kotlin'de sınıflar
• Kotlin'de işlev bildirimleri
• İşlevden değer döndürme

Not: Pratikler isteğe bağlıdır. Bu alıştırmalar, bu codelab'de öğrendiklerinizi uygulamanıza olanak tanır.

Aşağıdakileri yapın:

• Dice sınıfınıza başka bir renk özelliği verin ve farklı sayıda yüzü ve rengi olan birden fazla zar örneği oluşturun.
• Coin sınıfı oluşturun, sınıfa çevirme özelliği verin, sınıfın bir örneğini oluşturun ve birkaç madeni para çevirin. Yazı tura atmak için random() işlevini bir aralıkla nasıl kullanırsınız?