Các lớp và bản sao đối tượng trong Kotlin

1. Trước khi bắt đầu

Đối với các lớp học lập trình trong lộ trình này, bạn sẽ xây dựng ứng dụng Android có tên Dice Roller (Đổ xúc xắc). Khi người dùng "đổ xúc xắc", kết quả ngẫu nhiên sẽ được tạo ra. Kết quả xét đến số cạnh của xúc xắc. Ví dụ: bạn chỉ có thể tung các giá trị từ 1-6 từ một xúc xắc có 6 mặt.

Giao diện của ứng dụng chính thức sẽ có dạng như thế này.

8299aaca25c93863.png

Để giúp bạn tập trung vào các khái niệm lập trình mới cho ứng dụng, bạn sẽ sử dụng công cụ lập trình Kotlin dựa trên trình duyệt để tạo chức năng ứng dụng cốt lõi. Chương trình sẽ xuất kết quả của bạn sang bảng điều khiển. Sau đó bạn sẽ triển khai giao diện người dùng trong Android Studio.

Trong lớp học lập trình đầu tiên này, bạn sẽ tạo một chương trình Kotlin mô phỏng hoạt động đổ xúc xắc và cho ra một số ngẫu nhiên, tương tự như cách xúc xắc cho ra kết quả ngẫu nhiên khi đổ.

Điều kiện tiên quyết

  • Cách mở, chỉnh sửa và chạy mã trong https://developer.android.com/training/kotlinplayground
  • Tạo và chạy chương trình Kotlin sử dụng các biến và hàm, cũng như in kết quả ra bảng điều khiển.
  • Định dạng số trong văn bản sử dụng mẫu chuỗi có ký hiệu ${variable}.

Kiến thức bạn sẽ học được

  • Cách tạo số ngẫu nhiên có lập trình để mô phỏng việc đổ xúc xắc.
  • Cách định cấu trúc mã bằng cách tạo một lớp Dice có một biến và một phương thức.
  • Cách tạo bản sao đối tượng của một lớp, sửa đổi các biến của lớp và gọi phương thức của lớp đó.

Sản phẩm bạn sẽ tạo ra

  • Một chương trình Kotlin trong công cụ lập trình Kotlin dựa trên trình duyệt có thể thực hiện việc đổ xúc xắc ngẫu nhiên.

Bạn cần có

  • Một máy tính có kết nối Internet

2. Đổ số ngẫu nhiên

Trò chơi thường có một phần tử ngẫu nhiên. Bạn có thể nhận được một phần thưởng ngẫu nhiên hoặc tiến một số bước ngẫu nhiên trên bảng trò chơi. Trong cuộc sống hằng ngày, bạn có thể dùng các chữ cái và số ngẫu nhiên để tạo mật khẩu an toàn hơn!

Thay vì đổ xúc xắc thực tế, bạn có thể viết một chương trình mô phỏng việc đổ xúc xắc cho bạn. Mỗi lần đổ xúc xắc, kết quả có thể là bất kỳ số nào trong phạm vi giá trị có thể. May mắn là bạn không phải tạo trình tạo số ngẫu nhiên của riêng mình cho một chương trình như vậy. Hầu hết ngôn ngữ lập trình, bao gồm cả Kotlin, đều có một phương thức tích hợp cho phép bạn tạo số ngẫu nhiên. Trong nhiệm vụ này, bạn sẽ sử dụng mã Kotlin để tạo một số ngẫu nhiên.

Thiết lập mã bắt đầu

  1. Trên trình duyệt, hãy mở trang web https://developer.android.com/training/kotlinplayground.
  2. Xoá tất cả mã hiện có trong trình chỉnh sửa mã và thay thế bằng mã bên dưới. Đây là hàm main() mà bạn đã sử dụng trong lớp học lập trình trước đó.
fun main() {

}

Sử dụng hàm ngẫu nhiên

Để đổ xúc xắc, bạn cần có cách thể hiện tất cả các giá trị đổ xúc xắc hợp lệ. Đối với xúc xắc 6 mặt thông thường, giá trị đổ xúc xắc được chấp nhận là: 1, 2, 3, 4, 5 và 6.

Trước đây, bạn đã biết có một số loại dữ liệu như Int cho số nguyên và String cho văn bản. IntRange là một loại dữ liệu khác và đại diện cho phạm vi số nguyên từ một điểm bắt đầu đến một điểm cuối. IntRange là loại dữ liệu phù hợp để biểu thị các giá trị có thể mà một giá trị đổ xúc xắc.

  1. Bên trong hàm main(), xác định một biến là val có tên là diceRange. Hãy gán nó cho IntRange từ 1 đến 6, đại diện cho dải số nguyên mà một khối xúc xắc 6 mặt có thể đổ.
val diceRange = 1..6

Có thể nói 1..6 là một phạm vi Kotlin do nó có một số bắt đầu, hai dấu chấm, theo sau là một số kết thúc (không có dấu cách ở giữa). Ví dụ khác về dải số nguyên là 2..5 cho các số từ 2 đến 5 và 100..200 cho các số từ 100 đến 200.

Tương tự như cách gọi println() yêu cầu hệ thống in văn bản đã cho, bạn có thể sử dụng hàm có tên random() để tạo và trả về một số ngẫu nhiên cho bạn trong một dải đã cho. Như trước đây, bạn có thể lưu trữ kết quả trong một biến.

  1. Bên trong main(), xác định một biến là val có tên là randomNumber.
  2. Đặt randomNumber có giá trị kết quả cuộc gọi random() trên dải diceRange như minh hoạ bên dưới.
 val randomNumber = diceRange.random()

Lưu ý bạn đang gọi random() trên diceRange bằng dấu chấm giữa biến và lệnh gọi hàm. Bạn có thể đọc nội dung này là "đang tạo số ngẫu nhiên từ diceRange". Sau đó, kết quả được lưu trong biến randomNumber.

  1. Để xem số được tạo ngẫu nhiên, sử dụng ghi chú định dạng chuỗi (còn gọi là "mẫu chuỗi") ${randomNumber} để in, như bên dưới.
println("Random number: ${randomNumber}")

Mã hoàn thiện của bạn sẽ có dạng như sau.

fun main() {
    val diceRange = 1..6
    val randomNumber = diceRange.random()
    println("Random number: ${randomNumber}")
}
  1. Chạy mã của bạn vài lần. Mỗi lần như vậy, bạn sẽ thấy kết quả như bên dưới, với số ngẫu nhiên khác nhau.
Random number: 4

3. Tạo lớp Xúc xắc

Khi đổ xúc xắc, chúng là các đối tượng thật trong tay bạn. Mặc dù mã bạn vừa viết hoạt động cực tốt, nhưng khó có thể tưởng tượng việc nó cho ra xúc xắc thực tế. Việc sắp xếp một chương trình sao cho giống với nội dung mà chương trình đại diện sẽ giúp dễ hiểu hơn. Vì vậy, sẽ rất thú vị nếu bạn có được xúc xắc có lập trình!

Tất cả các xúc xắc cơ bản hoạt động giống nhau. Chúng có các thuộc tính giống nhau, chẳng hạn như các cạnh và có cùng hành vi, hoặc như đều có thể đổ. Trong Kotlin, bạn có thể tạo bản thiết kế có lập trình của một hạt xúc xắc cho biết chúng có các cạnh và có thể đổ ra một số ngẫu nhiên. Bản thiết kế này được gọi là lớp.

Từ lớp đó, bạn có thể tạo các đối tượng xúc xắc thực tế, được gọi là phiên bản đối tượng. Ví dụ: bạn có thể tạo xúc xắc 12 mặt hoặc 4 mặt.

Định nghĩa lớp Xúc xắc

Ở các bước sau, bạn sẽ xác định một lớp mới có tên là Dice để đại diện cho một con xúc xắc có thể đổ.

  1. Để bắt đầu làm mới, hãy xoá mã trong hàm main() để có thể sử dụng mã như bên dưới.
fun main() {

}
  1. Bên dưới hàm main() này, thêm một dòng trống, sau đó thêm mã để tạo lớp Dice. Như hiển thị bên dưới, hãy bắt đầu bằng từ khoá class, theo sau là tên lớp, theo sau nữa là dấu ngoặc nhọn mở và đóng. Hãy để khoảng trống giữa các dấu ngoặc nhọn để đặt mã cho lớp.
class Dice {

}

Bên trong định nghĩa về lớp, bạn có thể chỉ định một hoặc nhiều thuộc tính cho lớp bằng cách sử dụng biến. Xúc xắc thực có thể có một vài cạnh, màu sắc hoặc trọng lượng. Trong nhiệm vụ này, bạn sẽ tập trung vào thuộc tính của số cạnh xúc xắc.

  1. Bên trong lớp Dice, hãy thêm một var có tên là sides để biết số cạnh của xúc xắc. Đặt sides thành 6.
class Dice {
    var sides = 6
}

Vậy là xong. Giờ đây, bạn có một lớp rất đơn giản để thể hiện xúc xắc.

Tạo một phiên bản của lớp Xúc xắc

Với lớp Dice này, bạn có bản vẽ thiết kế của xúc xắc. Để có xúc xắc thực trong chương trình, bạn cần tạo một phiên bản đối tượng Dice. (Và nếu cần ba xúc xắc, bạn sẽ tạo ba đối tượng.)

ba2038022410942c.jpeg

  1. Để tạo một phiên bản đối tượng Dice, trong hàm main(), tạo một val có tên là myFirstDice và khởi chạy phiên bản đó dưới dạng phiên bản của lớp Dice. Lưu ý dấu ngoặc đơn sau tên lớp để cho biết bạn đang tạo phiên bản đối tượng mới từ lớp.
fun main() {
    val myFirstDice = Dice()
}

Bây giờ bạn đã có một đối tượng myFirstDice, nó được tạo từ bản vẽ thiết kế, bạn có thể truy cập các thuộc tính của đối tượng đó. Thuộc tính duy nhất của Dicesides. Truy cập vào một thuộc tính sử dụng "ký hiệu dấu chấm". Vì vậy, để truy cập thuộc tính sides của myFirstDice, bạn gọi myFirstDice.sides được gọi là "myFirstDicedot sides" (dấu chấm).

  1. Bên dưới phần khai báo myFirstDice, thêm câu lệnh println() để xuất số sides myFirstDice.
println(myFirstDice.sides)

Mã của bạn sẽ có dạng như thế này.

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

class Dice {
    var sides = 6
}
  1. Chạy chương trình của bạn và chương trình sẽ trả về số sides đã xác định trong lớp Dice.
6

Giờ bạn có một lớp Dice và một xúc xắc thực tế myFirstDice với 6 sides.

Hãy cùng đổ xúc xắc!

Đổ xúc xắc

Trước đây, bạn đã sử dụng một hàm để thực hiện hành động in các lớp bánh. Đổ xúc xắc cũng là một hành động có thể được triển khai dưới dạng hàm. Vì tất cả các xúc xắc đều có thể được đổ, nên bạn có thể thêm một hàm cho nó trong lớp Dice. Hàm được xác định bên trong một lớp còn được gọi là phương thức.

  1. Trong lớp Dice, bên dưới biến sides, chèn một dòng trống sau đó tạo hàm mới để đổ xúc xắc. Bắt đầu bằng từ khoá Kotlin fun, theo sau là tên phương thức, theo sau nữa là dấu ngoặc đơn (), sau đó là dấu ngoặc nhọn mở và đóng {}. Bạn có thể để trống một dấu cách giữa các dấu ngoặc nhọn để tạo chỗ cho nhiều mã hơn, như minh hoạ bên dưới. Lớp của bạn sẽ có dạng như sau.
class Dice {
    var sides = 6

    fun roll() {

    }
}

Khi bạn đổ một con xúc xắc sáu cạnh, nó sẽ tạo ra một số ngẫu nhiên từ 1 đến 6.

  1. Bên trong phương thức roll(), tạo một val randomNumber. Chỉ định cho nó một số ngẫu nhiên trong dải1..6. Sử dụng ký hiệu dấu chấm để gọi random() trên dải đó.
val randomNumber = (1..6).random()
  1. Sau khi tạo số ngẫu nhiên, hãy in số đó vào bảng điều khiển. Phương thức roll() đã hoàn tất của bạn sẽ có dạng như mã bên dưới.
fun roll() {
     val randomNumber = (1..6).random()
     println(randomNumber)
}
  1. Để thực sự tung myFirstDice, trong main(), hãy gọi phương thức roll() trên myFirstDice. Bạn gọi một phương thức bằng "ký hiệu dấu chấm". Vì vậy, để gọi phương thức roll() của myFirstDice, nhập myFirstDice.roll() và phát âm "myFirstDice do roll()" (dấu chấm).
myFirstDice.roll()

Mã đã hoàn tất của bạn sẽ có dạng như sau:

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

class Dice {
    var sides = 6

    fun roll() {
        val randomNumber = (1..6).random()
        println(randomNumber)
    }
}
  1. Chạy mã! Bạn sẽ thấy kết quả của một lần đổ xúc xắc ngẫu nhiên bên dưới số cạnh. Chạy mã của bạn nhiều lần, bạn sẽ thấy số cạnh vẫn giữ nguyên và giá trị của mỗi lần đổ xúc xắc thay đổi.
6
4

Xin chúc mừng! Bạn đã xác định được một lớp Dice có biến sides và hàm roll(). Trong hàm main(), bạn đã tạo một phiên bản Dice mới và sau đó bạn đã gọi phương thức roll() trên đối tượng này để tạo một số ngẫu nhiên.

4. Trả về giá trị đổ xúc xắc

Bây giờ bạn sẽ in ra giá trị của randomNumber trong hàm roll() và chức năng này hoạt động rất tốt! Nhưng đôi khi việc trả kết quả của một hàm cho thứ được gọi là hàm sẽ hữu ích hơn. Ví dụ: bạn có thể chỉ định kết quả của phương thức roll() cho một biến, sau đó di chuyển người chơi theo lượng đó! Hãy tìm hiểu cách thực hiện.

  1. Trong main(), hãy sửa đổi dòng chữ myFirstDice.roll(). Tạo val có tên là diceRoll. Hãy đặt giá trị này bằng với giá trị được phương thức roll() trả về.
val diceRoll = myFirstDice.roll()

Thao tác này chưa thực hiện hành động nào vì roll() chưa trả lại nội dung nào. Để mã này hoạt động như dự kiến, roll() phải trả về một giá trị nào đó.

Trong các lớp học lập trình trước đây, bạn đã biết cần chỉ định loại dữ liệu cho các đối số đầu vào đến hàm. Tương tự như vậy, bạn phải chỉ định loại dữ liệu cho dữ liệu mà hàm trả về.

  1. Hãy thay đổi hàm roll() để chỉ định loại dữ liệu sẽ được trả về. Trong trường hợp này, số ngẫu nhiên là Int, vì vậy loại trả về là Int. Cú pháp để xác định loại trả về: Sau tên hàm, sau dấu ngoặc đơn, hãy thêm dấu hai chấm, khoảng trắng và từ khoá Int cho loại trả về của hàm. Định nghĩa hàm phải có dạng như mã bên dưới.
fun roll(): Int {
  1. Chạy mã này. Bạn sẽ thấy lỗi trong Problems View (Chế độ xem vấn đề). Nội dung tin nhắn là:
A ‘return' expression required in a function with a block body (‘{...}')

Bạn đã thay đổi định nghĩa hàm để trả về một Int, nhưng hệ thống lại khiếu nại là mã của bạn thực sự không trả về Int. "Block body" (Phần thân khối) hay "function body" (phần thân hàm) chỉ phần mã giữa các dấu ngoặc nhọn của một hàm. Bạn có thể sửa lỗi này bằng cách trả về một giá trị từ một hàm sử dụng câu lệnh return ở cuối phần thân hàm.

  1. Trong roll(), hãy xoá câu lệnh println() và thay bằng câu lệnh return cho randomNumber. Hàm roll() của bạn phải có dạng như đoạn mã dưới đây.
fun roll(): Int {
     val randomNumber = (1..6).random()
     return randomNumber
}
  1. Trong main(), hãy xoá câu lệnh in cho các cạnh xúc xắc.
  2. Thêm câu lệnh để in ra giá trị của sidesdiceRoll trong một câu nhiều thông tin. Hàm main() đã hoàn tất phải có dạng như mã bên dưới.
fun main() {
    val myFirstDice = Dice()
    val diceRoll = myFirstDice.roll()
    println("Your ${myFirstDice.sides} sided dice rolled ${diceRoll}!")
}
  1. Hãy chạy mã của bạn và kết quả đầu ra phải giống thế này.
Your 6 sided dice rolled 4!

Dưới đây là toàn bộ mã của bạn cho đến thời điểm này.

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

5. Thay đổi số trên cạnh xúc xắc

Không phải tất cả các xúc xắc đều có 6 cạnh! Xúc xắc có đủ mọi hình dạng và kích thước: 4 cạnh, 8 cạnh và lên đến 120 cạnh!

  1. Ở lớp Dice, trong phương thức roll(), hãy thay đổi 1..6 được mã hoá cứng để sử dụng sides, sao cho dải, và sau đó là số ngẫu nhiên được đổ, sẽ luôn phù hợp với số cạnh.
val randomNumber = (1..sides).random()
  1. Trong hàm main(), bên dưới và sau khi in giá trị đổ xúc xắc, hãy thay đổi sides của myFirstDice thành 20.
myFirstDice.sides = 20
  1. Sao chép và dán câu lệnh in hiện có ở bên dưới sau khi bạn thay đổi số cạnh.
  2. Thay thế việc in diceRoll bằng cách in kết quả gọi phương thức roll() trên myFirstDice.
println("Your ${myFirstDice.sides} sided dice rolled ${myFirstDice.roll()}!")

Chương trình sẽ có dạng như sau.

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
    }
}
  1. Chạy chương trình của bạn, bạn sẽ thấy một thông báo cho xúc xắc 6 cạnh và thông báo thứ hai cho xúc xắc 20 cạnh.
Your 6 sided dice rolled 3!
Your 20 sided dice rolled 15!

6. Tuỳ chỉnh xúc xắc

Ý tưởng của lớp là thể hiện một nội dung, thường là điều gì đó thực tế. Trong trường hợp này, lớp Dice biểu thị một cục xúc xắc. Trong thế giới thực, xúc xắc không thể thay đổi số cạnh của chúng. Nếu muốn số cạnh khác, bạn cần có một cục xúc xắc khác. Về mặt lập trình, điều này có nghĩa là thay vì thay đổi thuộc tính cạnh của một phiên bản đối tượng Dice hiện có, bạn nên tạo một phiên bản đối tượng xúc xắc mới với số cạnh mà bạn cần.

Trong nhiệm vụ này, bạn sẽ sửa đổi lớp Dice để có thể chỉ định số cạnh khi tạo một phiên bản mới. Hãy thay đổi định nghĩa lớp Dice để bạn có thể cung cấp được số cạnh. Điều này tương tự như cách một hàm có thể chấp nhận đối số đầu vào.

  1. Hãy sửa đổi định nghĩa lớp Dice để chấp nhận một số nguyên có tên numSides. Mã trong lớp của bạn không thay đổi.
class Dice(val numSides: Int) {
   // Code inside does not change.
}
  1. Bên trong lớp Dice, xoá biến sides vì giờ đây bạn có thể sử dụng numSides.
  2. Ngoài ra, hãy sửa dải để sử dụng numSides.

Lớp Dice của bạn sẽ có dạng như sau.

class Dice (val numSides: Int) {

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

Nếu chạy mã này, bạn sẽ gặp rất nhiều lỗi bởi bạn cần cập nhật main() để có thể thực hiện các thay đổi đối với lớp Dice.

  1. Trong main(), để tạo myFirstDice có 6 cạnh, bạn hiện phải cung cấp số lượng đối số như đối số của lớp Dice, như minh hoạ bên dưới.
    val myFirstDice = Dice(6)
  1. Trong câu lệnh in, thay đổi sides thành numSides.
  2. Bên dưới, hãy xoá mã thay đổi sides thành 20 bởi biến đó không còn tồn tại.
  3. Xoá cả câu lệnh println bên dưới câu lệnh đó.

Hàm main() của bạn phải có dạng như mã bên dưới và nếu bạn chạy mã này phải không có lỗi xảy ra.

fun main() {
    val myFirstDice = Dice(6)
    val diceRoll = myFirstDice.roll()
    println("Your ${myFirstDice.numSides} sided dice rolled ${diceRoll}!")
}
  1. Sau khi in giá trị đổ xúc xắc đầu tiên, hãy thêm mã để tạo và in đối tượng Dice thứ hai có tên mySecondDice với 20 cạnh.
val mySecondDice = Dice(20)
  1. Thêm một câu lệnh in thực hiện thao tác đổ và in giá trị được trả về.
println("Your ${mySecondDice.numSides} sided dice rolled  ${mySecondDice.roll()}!")
  1. Hàm main() đã hoàn tất sẽ có dạng như sau.
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
    }
}
  1. Hãy chạy chương trình đã hoàn tất và kết quả của bạn sẽ có dạng như sau.
Your 6 sided dice rolled 5!
Your 20 sided dice rolled 7!

7. Áp dụng các phương pháp lập trình hay

Khi viết mã, hãy viết càng ngắn gọn càng tốt. Bạn có thể loại bỏ biến randomNumber và trực tiếp trả về số ngẫu nhiên.

  1. Thay đổi câu lệnh return để trả về trực tiếp số ngẫu nhiên.
fun roll(): Int {
    return (1..numSides).random()
}

Trong câu lệnh in thứ hai, bạn đặt cuộc gọi để nhận số ngẫu nhiên vào mẫu chuỗi. Bạn có thể loại bỏ biến diceRoll bằng cách làm tương tự trong câu lệnh in đầu tiên.

  1. Gọi myFirstDice.roll() trong mẫu chuỗi và xoá biến diceRoll. Hai dòng đầu tiên trong mã main() của bạn phải có dạng như sau.
val myFirstDice = Dice(6)
println("Your ${myFirstDice.numSides} sided dice rolled ${myFirstDice.roll()}!")
  1. Chạy mã của bạn và kết quả phải không có sự khác biệt.

Đây là mã chính thức của bạn sau khi cải tiến cấu trúc mã.

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

8. Mã giải pháp

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

9. Tóm tắt

  • Gọi hàm random() trên IntRange để tạo số ngẫu nhiên: (1..6).random()
  • Các lớp tương tự như bản vẽ thiết kế một đối tượng. Chúng có thể có các thuộc tính và hành vi, được triển khai dưới dạng biến và hàm.
  • Một phiên bản của lớp đại diện cho một đối tượng, thường là đối tượng thực, chẳng hạn như xúc xắc. Bạn có thể gọi các hành động trên đối tượng và thay đổi các thuộc tính của đối tượng đó.
  • Bạn có thể cung cấp giá trị cho lớp khi tạo một phiên bản. Ví dụ: class Dice(val numSides: Int), sau đó tạo một phiên bản với Dice(6).
  • Hàm có thể trả về nội dung nào đó. Chỉ định loại dữ liệu cần được trả về trong định nghĩa hàm và sử dụng câu lệnh return trong phần thân hàm để trả về thông tin. Ví dụ: fun example(): Int { return 5 }

10. Tìm hiểu thêm

11. Tự thực hành

Thực hiện những việc sau:

  • Tạo một thuộc tính màu khác cho lớp Dice và tạo nhiều phiên bản xúc xắc với nhiều số cạnh và màu sắc khác nhau!
  • Tạo một lớp Coin, cho phép nó có thể tung, tạo một phiên bản của lớp và tung vài đồng xu! Bạn sẽ sử dụng hàm random() với một dải (range) như thế nào để thực hiện việc tung đồng xu?