Những điều căn bản về lập trình Kotlin – AnonyHome

Ủng hộ AnonyHome Team
Chờ một chút: bạn thấy bài viết có ích chứ? Hãy chia sẻ nó với mọi người nhé!
Những điều căn bản về lập trình Kotlin Cr Thắng Blog

Cú pháp cơ bản trong lập trình Kotlin

Định nghĩa package trong Kotlin

Đặc tả package được đặt ở đầu của file source code
package my.demo

import java.util.*

// ...
Không bắt buộc phải match thư mục và package: file source code có thể được đặt tuỳ tiện trong hệ thống file.

Định nghĩa function trong Kotlin

Function có 2 tham số kiểu Int và trả về kết quả kiểu Int:
fun sum(a: Int, b: Int): Int {
return a + b
}

fun main(args: Array<String>) {
print("sum of 3 and 5 is ")
println(sum(3, 5))
}
-----------
Kết quả: sum of 3 and 5 is 8
Function có kiểu kết quả trả về được suy ra từ body biểu thức:
fun sum(a: Int, b: Int) = a + b

fun main(args: Array<String>) {
println("sum of 19 and 23 is ${sum(19, 23)}")
}
----------
Kết quả: sum of 19 and 23 is 42
Function trả về kết quả không có ý nghĩa:
fun printSum(a: Int, b: Int): Unit {
println("sum of $a and $b is ${a + b}")
}

fun main(args: Array<String>) {
printSum(-1, 8)
}
----------
Kết quả: sum of -1 and 8 is 7
Kiểu trả về Unit có thể được bỏ qua:
fun printSum(a: Int, b: Int) {
println("sum of $a and $b is ${a + b}")
}

fun main(args: Array<String>) {
printSum(-1, 8)
}
----------
Kết quả: sum of -1 and 8 is 7

Định nghĩa biến cục bộ (local) trong Kotlin

Biến local chỉ gán giá trị một lần(biến chỉ đọc):
fun main(args: Array<String>) {
val a: Int = 1 // immediate assignment
val b = 2 // `Int` type is inferred
val c: Int // Type required when no initializer is provided
c = 3 // deferred assignment
println("a = $a, b = $b, c = $c")
}
----------
Kết quả: a = 1, b = 2, c = 3
Biến có thể thay đổi:
fun main(args: Array<String>) {
var x = 5 // `Int` type is inferred
x += 1
println("x = $x")
}
----------
Kết quả: x = 6

Comment trong Kotlin

Giống như Java và JavaScript, Kotlin hỗ trợ các kiểu end-of-line và block comments.
// This is an end-of-line comment

/* This is a block comment
on multiple lines. */

Không giống Java, các block comment trong Kotlin có thể lồng nhau.

Sử dụng String template trong Kotlin

fun main(args: Array<String>) {
var a = 1
// simple name in template:
val s1 = "a is $a"

a = 2
// arbitrary expression in template:
val s2 = "${s1.replace("is", "was")}, but now is $a"
println(s2)
}
----------
Kết quả: a was 1, but now is 2

Sử dụng các biểu thức có điều kiện trong Kotlin

fun maxOf(a: Int, b: Int): Int {
if (a > b) {
return a
} else {
return b
}
}

fun main(args: Array<String>) {
println("max of 0 and 42 is ${maxOf(, 42)}")
}
----------
Kết quả: max of and 42 is 42
Sử dụng if như một biểu thức:
fun maxOf(a: Int, b: Int) = if (a > b) a else b

fun main(args: Array<String>) {
println("max of 0 and 42 is ${maxOf(, 42)}")
}
----------
Kết quả: max of and 42 is 42

Sử dụng các giá trị nullable và check null

Trong kotlin, một tham chiếu phải được đánh dấu là nullable khi giá trị null là có thể. Trả về giá trị null nếu str không giữ một số nguyên:
fun parseInt(str: String): Int? {
// ...
}
Sử dụng function trả về giá trị nullable:
fun parseInt(str: String): Int? {
return str.toIntOrNull()
}

fun printProduct(arg1: String, arg2: String) {
val x = parseInt(arg1)
val y = parseInt(arg2)

// Using `x * y` yields error because they may hold nulls.
if (x != null && y != null) {
// x and y are automatically cast to non-nullable after null check
println(x * y)
}
else {
println("either '$arg1' or '$arg2' is not a number")
}
}

fun main(args: Array<String>) {
printProduct("6", "7")
printProduct("a", "7")
printProduct("a", "b")
}
----------
Kết quả:
42
either 'a' or '7' is not a number
either 'a' or 'b' is not a number

Kiểm tra và tự động ép kiểu

Toán tử is kiểm tra nếu một biểu thức là một thể hiện của một kiểu. Nếu một biến địa phương loại chỉ đọc hay một thuộc tính được kiểm tra cho một kiểu cụ thể thì không cần ép kiểu một cách rõ ràng:
fun getStringLength(obj: Any): Int? {
if (obj is String) {
// `obj` is automatically cast to `String` in this branch
return obj.length
}

// `obj` is still of type `Any` outside of the type-checked branch
return null
}


fun main(args: Array<String>) {
fun printLength(obj: Any) {
println("'$obj' string length is ${getStringLength(obj) ?: "... err, not a string"} ")
}
printLength("Incomprehensibilities")
printLength(1000)
printLength(listOf(Any()))
}
----------
Kết quả:
'Incomprehensibilities' string length is 21
'1000' string length is ... err, not a string
'[java.lang.Object@6b884d57]' string length is ... err, not a string

Sử dụng vòng lặp for

fun main(args: Array<String>) {
val items = listOf("apple", "banana", "kiwi")
for (item in items) {
println(item)
}
}
----------
Kết quả:
apple
banana
kiwi
hoặc:
fun main(args: Array<String>) {
val items = listOf("apple", "banana", "kiwi")
for (index in items.indices) {
println("item at $index is ${items[index]}")
}
}
----------
Kết quả:
item at is apple
item at 1 is banana
item at 2 is kiwi

Sử dụng vòng lặp while

fun main(args: Array<String>) {
val items = listOf("apple", "banana", "kiwi")
var index =
while (index < items.size) {
println("item at $index is ${items[index]}")
index++
}
}
----------
Kết quả:
item at is apple
item at 1 is banana
item at 2 is kiwi

Sử dụng biểu thức when

fun describe(obj: Any): String =
when (obj) {
1 -> "One"
"Hello" -> "Greeting"
is Long -> "Long"
!is String -> "Not a string"
else -> "Unknown"
}

fun main(args: Array<String>) {
println(describe(1))
println(describe("Hello"))
println(describe(1000L))
println(describe(2))
println(describe("other"))
}
----------
Kết quả:
One
Greeting
Long
Not a string
Unknown

Sử dụng ranger (dãy ..)

Để kiểm tra một số có thuộc một dãy, sử dụng toán tử in:
fun main(args: Array<String>) {
val x = 10
val y = 9
if (x in 1..y+1) {
println("fits in range")
}
}
----------
Kết quả: fits in range
Kiểm tra một số nằm ngoài dãy:
fun main(args: Array<String>) {
val list = listOf("a", "b", "c")

if (-1 !in 0..list.lastIndex) {
println("-1 is out of range")
}
if (list.size !in list.indices) {
println("list size is out of valid list indices range too")
}
}
----------
Kết quả:
-1 is out of range
list size is out of valid list indices range too

Sử dụng collection

Iterating trên một collection:
fun main(args: Array<String>) {
val items = listOf("apple", "banana", "kiwi")
for (item in items) {
println(item)
}
}
----------
Kết quả:
apple
banana
kiwi
Kiểm tra nếu một collection có chứa một đối tượng, sử dụng toán tử in:
fun main(args: Array<String>) {
val items = setOf("apple", "banana", "kiwi")
when {
"orange" in items -> println("juicy")
"apple" in items -> println("apple is fine too")
}
}
----------
Kết quả: apple is fine too
Sử dụng biểu thức lamda để filter và map collection:
fun main(args: Array<String>) {
val fruits = listOf("banana", "avocado", "apple", "kiwi")
fruits
.filter { it.startsWith("a") }
.sortedBy { it }
.map { it.toUpperCase() }
.forEach { println(it) }
}
----------
Kết quả:
APPLE
AVOCADO

Idioms

Tạo các DTOs (POJOs/POCOs)

data class Customer(val name: String, val email: String)
cung cấp một class Customer với các function sau:
  • getters (và setters trong trường hợp các biến var) cho tất cả các thuộc tính
  • equals()
  • hashCode()
  • toString()
  • copy()
  • component1()component2(), .. cho tất cả các thuộc tính

Giá trị mặc định cho các tham số của function

fun foo(a: Int = , b: String = "") { ... }

Lọc một danh sách

val positives = list.filter { x -> x >  }
hoặc cách khác ngắn gọn hơn:
val positives = list.filter { it >  }

String Interpolation

println("Name $name")

Check các thể hiện

when (x) {
is Foo -> ...
is Bar -> ...
else -> ...
}

Thuộc tính lazy

val p: String by lazy {
// compute the string
}

Mở rộng function

fun String.spaceToCamelCase() { ... }

"Convert this to camelcase".spaceToCamelCase()

Tạo một singleton

object Resource {
val name = "Name"
}

Check null ngắn gọn

val files = File("Test").listFiles()

println(files?.size)

Biểu thức try/catch

fun test() {
val result = try {
count()
} catch (e: ArithmeticException) {
throw IllegalStateException(e)
}

// Working with result
}

Biểu thức if

fun foo(param: Int) {
val result = if (param == 1) {
"one"
} else if (param == 2) {
"two"
} else {
"three"
}
}



Kết luận



Trên đây là những điều cơ bản về cú pháp và các idiom của lập trình Kotlin. Hy vọng sẽ giúp các bạn tiếp cận, làm quen với ngôn ngữ lập trình mới này một cách căn bản và sơ khai nhất. 


Chúc các bạn thành công. Đừng quên theo dõi AnonyHome để cập nhật các bài viết mới nhé!



Share
0 0 vote
Vui lòng đánh giá bài viết
Subscribe
Notify of
guest
0 Comments
Inline Feedbacks
View all comments
XEM THÊM
Mệnh đề FROM trong SQL Server được dùng…
0
Bạn thích bài viết chứ? Hãy để lại bình luận.x
()
x