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

Bu yoldaki codelab'ler için bir Zar Toplayıcı Android uygulaması derleyeceksiniz. Kullanıcı zar attığında rastgele bir sonuç oluşturulacak. Sonuç, zarın kenar sayısını dikkate alır. Örneğin, 6 kenarlı bir zardan yalnızca 1-6 arasındaki değerler yuvarlanabilir.

Son uygulama bu şekilde görünecek.

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

İlk codelab'de, zar atmayı simüle eden bir Kotlin programı oluşturup zar atacağınız gibi rastgele bir sayı çıktısını elde edersiniz.

Ön koşullar

• https://try.kotlinlang.org/ adresinde kodu açma, düzenleme ve çalıştırma
• Değişkenleri ve işlevleri kullanan ve konsola bir sonuç yazdıran bir Kotlin programı oluşturup çalıştırın.
• ${variable} gösterimine sahip dize şablonunu kullanarak metindeki sayıları biçimlendirin.

Neler öğreneceksiniz?

• Zar oyunlarının simülasyonunu yapmak için programatik olarak nasıl rastgele sayılar oluşturulur?
• Değişken ve yönteme sahip bir Dice sınıfı oluşturarak kodunuzu yapılandırma.
• Bir sınıfın nesne örneği oluşturma, değişkenlerini değiştirme ve yöntemlerini çağırma.

Derlemeniz istenen nedir?

• Tarayıcı tabanlı Kotlin programlama aracında, rastgele zar atma imkanı sunan bir Kotlin programı.

İhtiyacınız olanlar

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

Oyunlarda genellikle rastgele bir öğe vardır. Oyun tahtasında rastgele bir ödül kazanabilir veya rastgele bir dizi adım gerçekleştirebilirsiniz. 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 atmayı simüle eden bir program yazabilirsiniz. Zar attığınız her seferinde sonuç, olası değerler aralığındaki herhangi bir sayı olabilir. Neyse ki böyle bir program için kendi rastgele sayı oluşturucunuzu oluşturmanız gerekmez. Kotlin gibi çoğu programlama dili, rastgele sayılar oluşturmak için yerleşik bir yönteme sahiptir. 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 tüm mevcut kodları silin ve aşağıdaki kodla değiştirin. Bu, önceki codelab'lerde birlikte çalıştığınız main() işlevidir (İlk Kotlin programınızı yazma codelab'ine bakın).

fun main() {

}

Rastgele işlevi kullanma

Zar atmak için geçerli tüm zar atma değerlerini göstermenin bir yolu olmalıdır. Normal 6 kenarlı zar için, kabul edilebilir zar atılması şu şekildedir: 1, 2, 3, 4, 5 ve 6.

Daha önce, tam sayı 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 uç noktaya kadar bir dizi tam sayı temsil eder. IntRange, bir zar atmanın oluşturabileceği olası değerleri temsil etmek için uygun bir veri türüdür.

1. main() fonksiyonunuzun içinde, diceRange adlı bir değişkeni val olarak tanımlayın. Bunu, 6 yüzlü bir zarın yuvarlayabileceği tam sayı numaralarını temsil eden 1 ile 6 arasında bir IntRange atayın.

val diceRange = 1..6

Başlangıç numarası, iki nokta ve bitiş numarası (arada boşluk olmadan) olduğundan 1..6 öğesinin Kotlin aralığı olduğunu anlayabilirsiniz. Diğer tam sayı aralıkları, 2 ile 5 arasındaki sayılar için 2..5 ve 100 ile 200 arasındaki sayılar için 100..200 şeklindedir.

İpucu: Bu tanımda tam sayı veya dize oluştururken değişken oluştururken Int veya String belirtmeniz gerekmediği için IntRange ifadesini belirtmez. Çoğu zaman sistem istediğiniz veri türünü belirleyebilir.

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

val diceRange = 1..6

şu şekilde:

val diceRange: IntRange = 1..6

println() çağrısının sisteme verilen metni yazdırması gibi, belirli bir aralıkta sizin için rastgele bir sayı oluşturup döndürmek amacıyla random() adlı bir işlevden yararlanabilirsiniz. Daha önce olduğu gibi sonucu bir değişkende depolayabilirsiniz.

2. main() içinde, bir değişkeni randomNumber adlı bir val olarak tanımlayın.
3. randomNumber değerinin, aşağıda gösterildiği gibi diceRange aralığında çağrılmasından kaynaklanan değeri olmasını sağlayın.

 val randomNumber = diceRange.random()

diceRange öğesinde değişken ile işlev çağrısı arasında nokta veya nokta kullanarak random() aradığınıza dikkat edin. Bunu, "diceRange"tan rastgele bir sayı oluşturma olarak okuyabilirsiniz. Sonuç, randomNumber değişkeninde depolanır.

4. Rastgele oluşturulan numaranızı görmek için, aşağıda gösterildiği gibi dize biçimlendirmesini (""dize şablonu" da denir) ${randomNumber} kullanın.

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

Tamamlanan kodunuz bu şekilde 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ılar içeren bir çıkış göreceksiniz.

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 elleriniz gerçek nesnelerdir. Az önce yazdığınız kod her ne kadar sorunsuz bir şekilde çalışsa da gerçek zarla ilgili olduğunu hayal etmek zordur. Bir programı, temsil ettiği şeylere daha fazla benzeyecek şekilde düzenlemek daha kolay anlaşılabilir. Bu nedenle, programa dayalı bir zar atmanın güzel olacağını düşünüyorum.

Tüm zarın işleyiş şekli aynıdır. Kenarlar gibi aynı özelliklere sahiptirler ve yuvarlanabilirler gibi aynı davranışlara sahiptirler. Kotlin'de, zarın kenarları olduğunu ve rastgele bir sayı yuvarladığını belirten bir zarın programlı bir şemasını oluşturabilirsiniz. Bu şemaya sınıf denir.

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

İpucu: Sınıf, bir mimarın eski planlarının evi olmadığı gibidir. Evin nasıl yapılacağına dair talimatlardır. Ev, şemaya göre oluşturulmuş gerçek nesne veya nesne örneğidir.

Not: Zarlarla ilgili her şeyin sınıfa düzenlenmesine kapsülleme denir. Kapsülleme çok büyük bir kelimedir, ancak mantıksal olarak ilgili işlevleri tek bir yere yerleştirebileceğiniz anlamına gelir.

Zar grubu tanımlama

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

1. En baştan başlamak için, main() işlevindeki kodu çıkarın. Böylece, kodu aşağıda gösterildiği gibi bulursunuz.

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şlamalı, bunu sınıfın adı ve ardından açılış ve kapanış kıvrık ayraç bulunmalıdır. Sınıfın kodunu yerleştirmek için süslü ayraçlar arasında boşluk bırakın.

class Dice {

}

Not:

• Yeni bir işlev oluşturmak için Kotlin’deki fun anahtar kelimesine benzer şekilde, yeni bir sınıf oluşturmak için class anahtar kelimesini kullanın.
• Bir class için herhangi bir ad seçebilirsiniz, ancak ad sınıfın neyi temsil ettiğini gösterirse faydalı olur. Genel olarak, sınıf adı deve düzenindedir. Örneğin: Car, ParkingMeter ve CustomerRecord geçerli sınıf adlarıdır ve bunların neyi temsil ettiğini tahmin edebilirsiniz.

Sınıf tanımında, değişkenleri kullanarak sınıf için bir veya daha fazla özellik belirtebilirsiniz. Gerçek zarın birden fazla tarafı, rengi veya ağırlığı olabilir. Bu görevde zarın kenarlarının sayısına odaklanacaksınız.

3. Dice sınıfının içine zarınızın sahip olacağı yüzeylerin sayısı için sides adlı bir var ekleyin. sides değerini 6 olarak ayarlayın.

class Dice {
    var sides = 6
}

Hepsi bu. Artık zarı temsil eden çok basit bir sınıfınız var.

Zar sınıfı örneği oluşturma

Bu Dice sınıfıyla bir zarın ne olduğunu gösteren bir şemanız var. Programınızda gerçek bir zar olması için bir Dice nesne örneği oluşturmanız gerekir. (Üç zarınız olması gerekiyorsa üç nesne örneği oluşturursunuz.)

1. Dice nesnesinin 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ının ardından, sınıftan yeni bir nesne örneği oluşturduğunuzu gösteren paranteze dikkat edin.

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

Şablondan yapılan myFirstDice nesnesine göre artık özelliklerine erişebilirsiniz. Dice mülkü, tek sides özelliğidir. Bir mülke erişmek için "nokta gösterimi"ni kullanabilirsiniz. Dolayısıyla, myFirstDice işleminin sides özelliğine erişmek için "myFirstDice" sides noktasının telaffuz edildiği myFirstDice.sides ifadesini çağırıyorsunuz.

2. myFirstDice tanımlamasının altına, myFirstDice. ifadesi için sides ifadesi göndermek amacıyla bir println() ifadesi ekleyin

println(myFirstDice.sides)

Not: diceRange.random() çağrısında daha önce nokta gösterimini kullanmışsınızdır. Genel olarak, nokta gösterimini "noktalı performans gösteren bir eylemde" diyebilirsiniz. Örneğin, myFirstDice.sides gibi bir örnekte sides özelliğini alın.

Kodunuz böyle 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ı gösterilir.

6

Artık Dice sınıfınız ve 6 sides ile gerçek bir zarınız, myFirstDice.

Zar oyunları yapalım!

Zar Oyunları

Daha önce, pasta katmanlarını yazdırma işlemini yapmak için bir işlev kullanıyordunuz. Zar atma da işlev olarak uygulanabilecek bir işlemdir. Ayrıca, tüm zarlar yuvarlanabileceği için Dice sınıfının içinde buna bir işlev ekleyebilirsiniz. Bir sınıfın içinde tanımlanan işleve yöntem de denir.

1. Dice sınıfının altında sides değişkeninin altına boş bir satır ekleyin ve zarı göndermek için yeni bir işlev oluşturun. fun Kotlin anahtar kelimesiyle başlamalı, yöntemin adını, ardından parantez () ve ardından süslü ayraç {} açıp açmalıdır. Aşağıda gösterildiği gibi, daha fazla koda yer açmak için süslü ayraçlar arasına boş bir satır bırakabilirsiniz. Sınıfınız şu şekilde görünmelidir:

class Dice {
    var sides = 6

    fun roll() {

    }
}

Not: Bu yöntemi istediğiniz gibi adlandırabilirsiniz, ancak hangi işlemi gerçekleştirdiğini gösteren bir ad vermek faydalıdır. İşlevler ve yöntemler için adlandırma kuralı küçük bir harfle başlamak, deve büyük/küçük harf kullanımı ve mümkünse bir işlem fiiliyle başlamaktır.

Altı taraflı bir zar yuvarladığınızda 1 ile 6 arasında bir rastgele sayı üretilir.

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

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

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

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

4. myFirstDice özelliğini sunmak için main() uygulamasında, myFirstDice tarihinde roll() yöntemini çağırın. Bir yöntemi "nokta gösterimi" ile ararsınız. Yani, myFirstDice yönteminin roll() yöntemini çağırmak için "myFirstDice" roll() işaretini telaffuz eden myFirstDice.roll()" yazarsınız.

myFirstDice.roll()

Tamamlanan kodunuz bu şekilde 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 atmanın sonucunu görürsünüz. Kodunuzu birkaç kez çalıştırın ve kenar sayısının aynı kaldığını ve zar atma değerinin de değiştiğini görün.

6
4

Tebrikler! sides değişkeni ve roll() işlevi olan bir Dice sınıfı tanımladınız. main() işlevinde yeni bir Dice nesne örneği oluşturdunuz ve ardından, rastgele bir sayı oluşturmak için üzerindeki roll() yöntemini çağırdınız.

Şu anda roll() fonksiyonunuzdaki randomNumber değerini yazdırıyorsunuz. Bu harika bir sonuç! Ancak bazen, bir işlevin sonucunu işlev olarak adlandırılan bir şeye döndürmek daha yararlıdır. Örneğin, roll() yönteminin sonucunu bir değişkene atayabilir ve ardından bir oyuncuyu bu tutara taşıyabilirsiniz. Google'ın bu işi nasıl yaptığına bakalım.

1. main() satırında myFirstDice.roll() yazan satırı değiştirin. diceRoll adlı val oluşturun. Bu değeri, roll() yöntemi tarafından döndürülen değere eşit olacak şekilde 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 istediğiniz şekilde çalışması için roll() tarafından bir sonuç döndürülmesi gerekir.

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

2. Döndürülecek veri türünü belirtmek için roll() işlevini değiştirin. Bu durumda, rastgele sayı Int olduğundan döndürme türü Int olur. Döndürme türünü belirtmek için söz dizimi: İşlev adından sonra parantez içinde iki nokta, boşluk, ardından Int anahtar kelimesi 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,

kodu aslında Int döndürmüyor. "Gövdeyi engelle" veya "işlev gövdesi", bir işlevin kıvrık ayraçları arasındaki kodu belirtir. İşlev gövdesinin sonundaki 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() fonksiyonunuz aşağıdaki koda benzemelidir.

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

5. main() içinde zarın kenarlarındaki baskı beyanını kaldırın.
6. Bilgilendirici bir cümlede sides ve diceRoll değerlerini yazdırmak için bir ifade ekleyin. Tamamlanan main() işleviniz aşağıdaki koda benzer şekilde olmalıdır.

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

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

Your 6 sided dice rolled 4!

Şu ana kadarki tüm kodlarınız.

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 tarafı yok. Zarların tüm şekil ve boyutları vardır: 4 kenar, 8 kenar, en fazla 120 kenar!

1. Dice sınıfınızda, roll() yönteminizde sabit kodlanmış 1..6 öğesini sides kullanacak şekilde değiştirin. Böylece aralık ve bu nedenle rastgele rastgele sayı, her zaman kenar sayısı için doğru olur.

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

2. main() işlevinde, zarı yazdırdıktan sonra, zarın FirstDice değerinin sides değerini 20 olarak ayarlayın.

myFirstDice.sides = 20

3. Kenar sayısını değiştirdikten sonra, mevcut yazdırma beyanını kopyalayıp yapıştırın.
4. diceRoll dosyasının yazdırma işlemini, myFirstDice yönteminde roll() yöntemini çağırma sonucunu alacak şekilde değiştirin.

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

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

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, 20 yüzlü zar için ikinci bir mesaj görmeniz gerekir.

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

Dersin amacı, genellikle gerçek dünyadaki fiziksel bir şeyi temsil etmektir. Bu durumda Dice sınıfı fiziksel bir zarı temsil eder. Gerçek dünyada zarın kenar sayısını değiştiremez. Farklı boyutlara ulaşmak isterseniz zar atmanız gerekiyor. Programatik olarak, mevcut bir Dice nesne örneğinin kenar özelliklerini değiştirmek yerine, ihtiyacınız olan kenar sayısıyla yeni bir zar nesnesi örneği oluşturmanız gerekir.

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

1. numSides adlı tam sayı bağımsız değişkenini kabul etmek için Dice sınıf tanımını değiştirin. Sınıfınızın içindeki kod değişmez.

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

2. Artık numSides öğesini kullanabildiğinizden, Dice sınıfının içindeki sides değişkenini silin.
3. Ayrıca, aralığı kullanmak için aralığı düzeltin: numSides.

Dice sınıfınız şöyle 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 çok sayıda hata görürsünüz. Çünkü, Dice sınıfındaki değişikliklerle çalışması için main() ürününü güncellemeniz gerekir.

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

    val myFirstDice = Dice(6)

5. Ekstrede sides değerini 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 kısımdaki println ifadesini de silin.

main() fonksiyonunuz aşağıdaki koda benzemelidir. Çalıştırırsanız herhangi bir hata olmaz.

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

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

    val mySecondDice = Dice(20)

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

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

10. Tamamladığınız main() işlevi aşağıdaki gibi görünecektir.

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ünecektir.

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

Kod yazarken kısa ve öz öneriler daha iyidir. randomNumber değişkeninden kurtulabilir 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 baskı ifadesinde, çağrıyı dize şablonuna rastgele bir sayı almak için yaparsınız. İlk ekstrede aynı işlemi yaparak diceRoll değişkeninden kurtulabilirsiniz.

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

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

3. Kodunuzu çalıştırın ve çıktıda farklılık olmamalıdır.

Not: Kodu daha kısa, daha verimli veya daha kolay okunup anlaşılması için değiştirmek yeniden düzenleme olarak adlandırılır. Bir doküman yazmaya benzer. Burada tüm bilgileri içeren bir taslak hazırlar, ardından da kelimelerinizi düzenleyip hassaslaştırırsınız.

Bu, yeniden düzenledikten sonra nihai 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 bir sayı oluşturmak için bir IntRange öğesinde random() işlevini çağırın: (1..6).random()
• Sınıflar, bir nesnenin şeması gibi. Değişkenler ve işlevler olarak uygulanan özelliklere ve davranışlara sahip olabilirler.
• Sınıfın bir örneği, genellikle zar gibi fiziksel bir nesneyi temsil eder. Nesneyle ilgili 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 girişi bir sınıfa aktarabilirsiniz. Örneğin: class Dice(val numSides: Int) ve ardından Dice(6) ile bir örnek oluşturun.
• İşlevler bir şey döndürebilir. İşlev tanımında döndürülecek veri türünü belirtin ve işlev gövdesinde bir şey döndürmek için return ifadesi kullanın. Örneğin: fun example(): Int { return 5 }

• Rastgele sayı oluşturma (Wikipedia)
• 120 Taraflı Zar Oyunları Tasarlamak İçin Zihin Bozukluğu
• Kotlin dersleri
• Kotlin'deki işlev bildirimleri
• Bir işlevden değer döndürme

Not: Alıştırmalar isteğe bağlıdır. Bu codelab'de öğrendiklerinizi alıştırma yapmanıza fırsat tanır.

Aşağıdakileri yapın:

• Dice sınıfına başka bir renk özelliği ekleyin ve farklı sayıda kenar ve renk içeren zar örnekleri oluşturun.
• Coin sınıfı oluşturun, çevirme, sınıfın örneği oluşturma ve madeni paraları kullanma yetkisi verin! Madeni para çevirisini gerçekleştirmek için rastgele() işlevini bir aralıkla nasıl kullanırsınız?