Cách đây vài tháng, khi Google thông báo rằng họ sẽ sử dụng Kotlin làm ngôn ngữ chính thức trong việc phát triển ứng dụng Android. Mình (và mình đoán là nhiều mobile dev khác) đã cảm thấy rất vui mừng và phấn khích. Mình đã ngay lập tức vào trang chủ của Kotlin để tìm hiểu về những tính năng, cú pháp mới của nó. Rồi sau đó đem Swift ra so sánh với Kotlin. Và mình đã có 1 cảm giác cực kỳ lạ: dường như 1 kỷ nguyên mới trong phát triển ứng dụng di động đã bắt đầu.
Thời kỳ mới bắt đầu
Kotlin cũng như Swift mang đến nhiều sự mới mẻ và thú vị trong cú pháp. Chúng làm cho công việc hằng ngày của chúng ta trở nên nhàn hạ và đơn giản hơn rất nhiều. Không chỉ có thế, chúng mang đến những hỗ trợ đáng kể với những mô hình lập trình mới, và cải tiến những mô hình cũ, đặc biệt là lập trình hàm (functional programming).
Functional programming
Thực tế thì lập trình hàm không phải là khái niệm mới trong phát triển phần mềm. Tuy nhiên với Kotlin và Swift, nó đã được hỗ trợ 1 cách tối đa, từ đó việc phát triển ứng dụng iOS hay Android ngày càng trở nên đơn giản.
Nhớ ngày trước, khi mình mới tập toẹ học lập trình Android, lúc đó, 1 bài toán tính tổng dùng vòng for sẽ được viết kiểu thế này:
String[] mixedArray = new String[] { "4", "5", "a", "-2", "Str" };
int results = 0;
for (String element : mixedArray) {
results += Integer.parseInt(element);
}
Còn tại thời điểm hiện tại? Mọi chuyện đơn giản hơn rất nhiều khi ta có thể sử dụng 1 câu lệnh duy nhất, theo cách tiếp cận của tư duy lập trình hàm:
Kotlin:
val mixedArray = arrayOf("4", "5", "a", "-2", "Str")
val results = mixedArray
.filter { obj -> obj.toIntOrNull() != null }
.map { x -> x.toInt() }
.reduce { acc, x -> acc + x }
Swift:
let mixedArray = ["4", "5", "a", "-2", "Str"]
let results = mixedArray
.filter({ (obj) -> Bool in return Int(obj) != nil })
.map { (obj) -> Int in return Int(obj)! }
.reduce(0, +)
Lambda expression
Năm 2014, biểu thức lambda chính thức được đưa vào JDK 8. Nhưng không may, lambda lại không thể được sử dụng trong lập trình Android, bởi Android SDK chỉ hỗ trợ JDK version 7. Đó cũng chính là lý do thử viện kiểu như retrolambda được sinh ra trên đời.
Còn ở thời điểm hiện tại, cả 2 ngôn ngữ lập trình Swift và Kotlin đều đã hỗ trợ tính năng này. Ở swift thì là closure còn với Kotlin thì là lambda express.
Swift closure:
{ _ in
print("Closure is called!")
}
Kotlin lambda express:
{
println("lambda is called!")
}
Inline initialization
Tiếp tục, với Swift, ta có thể khởi tạo dictionary chỉ với 1 dòng:
let dictionary = ["key1": "value1", "key2": "value2"]
Còn với Java, ta chỉ có thể khởi tạo giá trị của đối tượng Map thông qua 1 static block:
private static final Map<String, String> map;
static
{
map = new HashMap<String, String>();
map.put("key1", "value1");
map.put("key2", "value2");
}
Thực tế, Java cũng đã hỗ trợ hàm MapOf, nhưng phải tới JDK 9 hàm này mới được bổ sung. Còn với Kotlin, mọi chuyện đơn giản hơn rất nhiều:
val map = mapOf<String, String>("key1" to "value1", "key2" to "value2")
Có 1 điều nữa mình muốn đề cập đó là toán tử Range (khoảng). Tính năng thú vị này làm cho công việc code của ta nhàn hạ hơn rất nhiều. Thay vì sử dụng vòng lặp for như thế này:
for (int i = 0; i < N; i++) {
// Do something
}
Thì với Kotlin:
for (i in 0..N-1) {
// Do something
}
hoặc Swift:
for i in 0..<N {
// Do Something
}
Rất ngắn gọn đúng không.
Tuples
Một thành phần nữa của Swift (và Kotlin) cũng rất hay đó là tuples. Nó cho phép ta tạo ra những tập hợp đơn giản, thay vì việc phải định nghĩa thêm class.
Tổng kết
Tổng kết lại, với những tính năng mới mình đã kể trên, và còn rất nhiều tính năng mình chưa nói đến, mình tin là 1 kỷ nguyên mới trong phát triển mobile đã bắt đầu. Developer giờ đây đã có thể dành nhiều thời gian hơn cho việc xử lý logic nghiệp vụ cũng như luồng chạy của ứng dụng. Thay vì tốn thời gian vào việc viết hàng trăm dòng code, chỉ để xử lý những logic đơn giản.
Nếu trước đây bạn phải tốn thời gian cài thêm các thư viện như kiểu PromiseKit, ReactiveCocoa, RXJava để việc code của bạn dễ thở hơn, thì nay, bạn đã được “trang bị” đầy đủ nhất ngay từ khi bắt đầu. Và mình tin điều đó cũng sẽ thúc đẩy những người mới, làm cho họ cảm thấy lập trình ko phải là thứ gì đó khó khăn, vất vả lắm. Mình tin 1 thời kỳ tươi sáng đã thực sự bắt đầu.
Xin chào, hôm nay mình sẽ trình bày về kế thừa lớp trong Kotlin. Đây là khái niệm rất quan trọng trong lập trình hướng đối tượng. Tại sao quan trọng thì mình sẽ trình bày trong xuyên suốt bài viết. Kế thừa là việc 1 lớp con thừa hưởng toàn bộ các thuộc tính và phương thức của lớp cha, đồng thời có thể có thêm những thuộc tính và phương thức mà lớp cha không có.
[toc]
Định nghĩa kế thừa
Các bạn vẫn giữ code của bài trước chứ, ta đã định nghĩa lớp Animalđặc trưng cho động vật. Bây giờ ta sẽ định nghĩa 1 lớp Catkế thừa Animalđể làm rõ hơn về khái niệm này nhé. Ta định nghĩa như sau:
Ta đã tạo ra 1 lớp Catkế thừa lớp Animalđã tạo buổi trước bằng cách khai báo Animalsau dấu :. Lớp Catvẫn có các thuộc tính kind, namenhư Animal. Nhưng đã có thêm 1 thuộc tính mới, là thuộc tính color. Và hàm khởi tạo của Catsẽ gọi đến hàm khởi tạo Animal(kind, name) của Animal. Vì sao đối tượng Catlại có kindvà name? Đơn giản vì Catkế thừa từ Animal, nghĩa là mọi đối tượng Catchính là Animalmở rộng, và đều có các thuộc tính của Animal. OK, còn colorthì sao. Đây là thuộc tính mới của Catmà Animalkhông có. Vì Catlà Animalmở rộng mà :)) Catcó toàn bộ các thuộc tính và phương thức của Animal, thêm vào đó là các phương thức, đối tượng mới của riêng Cat.
Ủa nhưng mà sao lại có báo lỗi ở phần khai báo kế thừa: This type is final, so it cannot be inherited from. Nguyên nhân là mặc định trong Kotlin, các class được khai báo được hiểu là final class, tức là không thể kế thừa. Vì vậy ta sẽ phải thêm từ khóa open trước class Animal để lớp này có thể được kế thừa bởi lớp Cat:
open class Animal(var kind: String, var name: String) {
}
OK, giờ đã hết lỗi. Ta sẽ thử tạo 1 đối tượng Catvà sử dụng các phương thức của Animal:
var cat = Cat("Red","Cat", "Lyly")
cat.getInfo() //Hello, i am a Cat, my name is Lyly
Như vậy là các đối tượng Cathoàn toàn sử dụng được phương thức của Animal, do lớp Catkế thừa lớp Animal. Ta thậm chí có thể khai báo như thế này:
var cat:Animal = Cat("Red", "Cat", "Lyly")
Ở đây ta khai báo 1 đối tượng có kiểu Animalvà khởi tạo nó với Cat. Điều này hoàn toàn hợp lệ bởi khi Cat kế thừa Animal, thì Catchính là Animal(mở rộng). Nhưng nếu ta khai báo thế này:
var cat:Cat = Animal("Cat", "Lyly")
Thì lập tức IDE sẽ báo lỗi. Bởi lẽ Animal là lớp cha của Cat, Cat chắc chắn là 1 Animal, nhưng 1 Animalcó thể là Bird, Dog, Chicken, … chứ chưa chắc đã là Cat. Vì vậy ta khai báo đối tượng kiểu Catmà khởi tạo kiểu Animalthì sẽ là không hợp lệ.
Override
Ye, như ở phần trên ta đã biết, 1 đối tượng của lớp con (Cat) có thể gọi được phương thức của lớp cha (Animal). Ta còn có thể làm được nhiều hơn thế: ta có thể mở rộng phương thức đã định nghĩa ở lớp cha. Mình sẽ trình bày ngay đây: ở lớp Animal ta đã khai báo phương thức getInfo, và phương thức này hoàn toàn sử dụng được với các đối tượng Cat. Nhưng giờ đây ta muốn getInfo trả về thêm màu lông của đối tượng Cat. Sau đây là cách làm. Ta định nghĩa hàm getInfoở lớp Cat như sau:
override fun getInfo() {
}
Và thêm từ khóa open vào dòng định nghĩa phương thức getInfo ở lớp Animal:
open fun getInfo()
Ở đây, trong lớp Cat ta đã viết lại phương thức getInfocủa lớp Animal, nên ta phải dùng từ khóa override. Tuy nhiên, chỉ có những phương thức openmới cho phép ta định nghĩa lại, thành ra ta phải thêm từ khóa openkhi định nghĩa getInfoở lớp Animal, dễ hiểu đúng không? Lúc này ta chạy lại chương trình. Kết quả console sẽ không in ra dòng log nào. Vì sao? Bởi với từ khóa override, phương thức getInfoở class Animal đã bị ghi đè hoàn toàn bởi phương thức getInfoở class Cat. Mà như ta thấy trong class Cat, phương thức getInfokhông thực hiện bất cứ điều gì, dẫn đến không có dòng log nào được in ra ở console. Giờ ta sẽ thử in ra các thuộc tính của Cat xem sao:
override fun getInfo() {
print("Hello, i am a $kind, my name is $name")
age?.let {
println(", i am $age years old")
}
}
Kết quả:
Hello, i am a Cat, my name is Lyly
Ồ, vậy là ổn rồi. Nhưng như bạn thấy đấy, mình đã phải copy phương thức getInfoở Animal để cho vào Cat. Thế thì sinh ra hướng đối tượng với cả kế thừa để làm gì, đúng không. Ta có cách khác để làm điều này, đơn giản chỉ cần gọi:
super.getInfo()
Là phương thức getInfo ở lớp cha (Animal) sẽ được thực thi. Ta muốn in ra màu lông của Cat nữa thì sao, đơn giản là thêm dòng lệnh:
println("I am $color")
Như vậy phương thức getInfo ở Cat sẽ như sau:
override fun getInfo() {
super.getInfo()
println("I am $color")
}
Chạy lại chương trình ta thu được:
Hello, i am a Cat, my name is Lyly
I am Red
Lưu ý: Bạn có thể định nghĩa thêm bất kỳ các phương thức mới nào ở class Cat, nhưng chúng sẽ chỉ được gọi bởi các đối tượng Cat, chứ ko thể gọi bởi các đối tượng Animal.
Sử dụng interface
Interface trong Kotlin cũng khá giống với bên Java. Nó chứa các phương thức mà các lớp kế thừa nó sẽ thực hiện. Chúng ta cũng có thể định nghĩa các thuộc tính trong interface. Thôi ta sẽ đi vào ví dụ cho dễ hiểu nhé. Ta định nghĩa interface IAction như sau:
interface IAction {
fun makeSound()
fun eat(food: String)
}
Như các bạn thấy, interface trên có 2 phương thức makeSoundvà eat. Ta sẽ cho lớp Cat kế thừa interface này:
Lưu ý: khi muốn kế thừa thêm bất kỳ class hay interface nào, ta chỉ cần điền thêm tên class hay interface đó, ngăn cách nhau bới dấu ,
Giờ IDE sẽ thông báo lỗi cho ta biết rằng, ta cần định nghĩa các phương thức có ở trong interface IAction vào lớp Cat. Okie, định nghĩa thôi, và ta viết luôn nội dung cho các phương thức đó (nên nhớ ở trong IAction ta mới định nghĩa tên phương thức mà chưa viết nội dung):
override fun makeSound() {
println("Meo meo meo")
}
override fun eat(food: String) {
println("I am eating $food")
}
Sau đó thử gọi :
var cat = Cat("Red", "Cat", "Lyly")
cat.makeSound()
cat.eat("Rat")
Kết quả:
Meo meo meo
I am eating Rat
Vậy là đối tượng Cat đã có thể sử dụng các phương thức khai báo trong IAction nhờ kế thừa interface này. Ta cũng có thể viết nội dung phương thức ngay trong interface, đây là 1 cải tiến lớn của Kotlin so với Java. Ta sử lại nội dung phương thức eattrong IAction:
fun eat(food: String){
println("Yeah")
}
và sửa lại trong class Cat như sau:
override fun eat(food: String) {
super.eat(food)
}
Lại là từ khóa super, từ khóa này dùng để gọi tới phương thức tương ứng của cha (trường hợp này “cha” là IAction).
Thuộc tính trong interface
Cũng giống như phương thức, ta có thể định nghĩa các thuộc tính trong interface và sử dụng chúng ở trong class kế thừa interface đó. Ví dụ ta thêm thuộc tính numberOfFootvào interface IAction:
override var numberOfFoot: Int = 4
Lúc này, khi khai báo numberOfFoottrong class, ta đã có thể (và bắt buộc )khởi tạo giá trị cho nó. Hoặc ta có 1 cách khác:
override var numberOfFoot: Int
get() = 4
set(value) {
}
Vậy là ta đã set được giá trị cho numberOfFoot. Ta định nghĩa thêm 1 phương thức move trong IAction thế này:
fun move(){
println("I move with $numberOfFoot legs")
}
Lưu ý: Các phương thức được viết nội dung trong interface thì không bắt buộc phải khai báo trong class kế thừa interface đó.
Giờ ta thử sử dụng phương thức move mới khởi tạo:
var cat = Cat("white", "cat", "Lyly")
cat.move() // In ra: I move with 4 legs
Vậy là giá trị của thuộc tính numberOfFootđúng là 4 như ta đã khai báo trong class Cat.
Abstract class (lớp trừu tượng)
Về cơ bản abstract class cũng tương tự như interface, nó cho phép ta định nghĩa các thuộc tính, phương thức để sử dụng trong class kế thừa nó. Tuy nhiên abstract class có 1 nhược điểm so với interface là: 1 class chỉ được phép kế thừa từ 1 class khác, trong khi đó có thể kế thừa tùy ý số interface. Vì vậy khi class của bạn đã kế thừa 1 class rồi thì sẽ không thể sử dụng abstract class được nữa. Dù sao mình cũng sẽ demo 1 ví dụ về abstract class:
open abstract class AbstractAction {
abstract fun makeSoundAbstract()
fun eatFood(){
println("I am eating")
}
}
Ta tạo ra 1 abstract class AbstractAction. Trong này ta định nghĩa 2 phương thức makeSoundAbstractvà eat. Phương thức makeSoundAbstractta chưa viết luôn thân hàm nên phải thêm từ khóa abstract ở đầu, còn đối với eatthì không cần. Ok, giờ ta sẽ cho class Cat của ta kế thừa class AbstractAction này:
Ngay lập tức IDE sẽ báo cho ta 1 lỗi: Only one class may appear in supertype list.
Tức là chỉ 1 class được xuất hiện ở danh sách kế thừa. Class Cat của ta đã kế thừa Animal, nên không thể kế thừa thêm 1 class khác (AbstractClass). Ta thử xóa bỏ phần kế thừa Animal và các phương thức liên quan đến Animal đi xem sao. Sau đó overridelại phương thức makeSoundAbstract(Phương thức eatFoodkhông bắt buộc override vì nó đã được viết thân hàm).
override fun makeSoundAbstract() {
println("Meo meo")
}
Rồi, thử các phương thức mới xem nào:
var cat = Cat("Red", "Cat", "Lyly")
cat.makeSoundAbstract()
cat.eatFood()
/*Kết quả:
Meo meo
I am eating*/
Trùng lặp tên phương thức khi kế thừa nhiều interface
Đôi khi trong các class hay interface mà ta kế thừa, có những phương thức trùng tên với nhau. Vậy, chỉ với từ khóa super, làm sao để gọi chính xác phương thức ứng với interface (class) mà ta mong muốn. Ví dụ mình sửa phương thức eatFoodtrong AbstractAction thành như sau:
open fun eat(food: String) {
println("[AbstractAction]I am eating $food")
}
và sửa phương thức eat trong IAction thành như sau:
fun eat(food: String) {
println("[IAction]I am eating $food")
}
Vậy là 2 phương thức đã giống nhau từ tên cho đến tham số đầu vào, giờ hãy để ý trong phương thức override fun eat(food: String) của class Cat: Many supertypes available, please specify the one you mean in angle bracket, egg ‘super<Foo>’. Nghĩa là: phương thức này đã được định nghĩa ở nhiều lớp hoặc interface cha (IAction và AbstractAction). Ta cần chỉ rõ muốn sử dụng phương thức ở lớp cha nào. Cách làm như sau:
super<IAction>.eat(food) // Sử dụng phương thức eat ở interface IAction
super<AbstractAction>.eat(food)// Sử dụng phương thức eat ở class AbstractAction
Thử sử dụng phương thức eat này xem:
var cat = Cat("Red", "Cat", "Lyly")
cat.eat("Rat")
Kết quả:
[IAction]I am eating Rat
[AbstractAction]I am eating Rat
Vậy là ta đã định rõ được phương thức ta muốn sử dụng là tới từ lớp (interface) cha nào.
Tổng kết
Vậy là bài này mình đã trình bày xong những khái niệm cơ bản về kế thừa trong lập trình hướng đối tượng với Kotlin. Các kiến thức về interface, abstract class, override mình đã đưa ra kèm các ví dụ cụ thể. Hy vọng các bạn có thể nắm rõ nội dung bài học.
Lớp (class) là khái niệm cơ bản nhất trong lập trình hướng đối tượng. Nó đặc trưng cho 1 loại đối tượng xác định, với những thuộc tính và hành động xác định. Lớp bao gồm các thuộc tính và các phương thức. Hôm nay, hãy cùng mình tìm hiểu về khái niệm cơ bản nhưng cũng là quan trọng nhất của lập trình hướng đối tượng này nhé.
Định nghĩa lớp
Ta định nghĩa lớp qua từ khóa class, điều này khá giống với Java:
class Human
Dòng code trên vừa khai báo 1 lớp rỗng, lớp đơn giản nhất trong lập trình hướng đối tượng. Nó không có thuộc tính cũng chẳng có thân hàm, tuy nhiên ta vẫn có thể khởi tạo 1 đối tượng của lớp Human trên như sau:
val human = Human()
Như vậy là không giống với Java, ta không cần từ khóa new để khởi tạo 1 đối tượng mới.
Thuộc tính và hàm khởi tạo của lớp
Lớp ta vừa mới khởi tạo ở phần trước còn khá đơn giản, giờ ta sẽ thêm vài thuộc tính cho nó, đồng thời sẽ thêm cách khởi tạo mới cho class này:
class Human(var name: String, var age: Int) {
}
Lớp Humanđã được bổ sung 2 thuộc tính là name và age. Và nó có hàm khởi tạo gồm 2 tham số đầu vào kiểu String và int. (var name: String, var age: Int) được gọi là primary constructor (hàm khởi tạo chính).
Vậy là với đúng 1 dòng, ta đã vừa khai báo được các thuộc tính của class Human, vừa định nghĩa được hàm khởi tạo ứng với 2 thuộc tính đó. Rất ngắn gọn và dễ hiểu đúng không. Giờ ta sẽ thử khởi tạo 1 đối tượng Human bằng hàm khởi tạo ta vừa định nghĩa:
var me: Human = Human("Dương Vũ", 25)
Đơn giản là khai báo biến có kiểu dữ liệu là Humanvà khởi tạo cho nó! Theo đúng định nghĩa lớp viết ra ở trên, mình dùng hàm khởi tạo có các tham số đầu vào là String và Int, tương ứng với tên và tuổi. Giờ mình sẽ lấy ra giá trị các thuộc tính của thằng memà mình vừa khởi tạo:
print("name = ${me.name}, age = ${me.age}") // In ra: name = Dương Vũ, age = 25
Cách truy xuất đến thuộc tính của đối tượng rất đơn giản dễ dàng đúng ko. Ta sử dụng cú pháp:
<tên_đối_tượng>.<tên_thuộc_tính>
để truy xuất đến thuộc tính của đối tượng me.
Định nghĩa phương thức cho lớp
Từ đầu đến giờ ta đã định nghĩa class Human, có các thuộc tính của riêng nó, nhưng chưa định nghĩa các hành động cho nó thực hiện. Ta sẽ viết định nghĩa 1 phương thức nằm trong class Human như thế này:
fun introduce() {
print("Hello, I am $name, I am $age years old")
}
Như vậy việc định nghĩa phương thức trong class đơn giản chỉ là định nghĩa hàm để xử lý các thuộc tính trong class đó. Như ở trên ta đã xây dựng 1 phương thức cho phép Human giới thiệu về bản thân mình. Phương thức này sẽ log ra tên, tuổi của đối tượng gọi phương thức:
var me: Human = Human("Dương Vũ", 25)
me.introduce() // in ra: Hello, I am Dương Vũ, I am 25 years old
Như vậy là phương thức introduceđã hoạt động. Ta thấy, khi ở bên trong thân class, thì truy xuất đến các thuộc tính đơn giản là gọi thẳng tên thuộc tính đó ra: $name, $age. Còn ở bên ngoài class ta cần sử dụng cú pháp <tên_đối_tượng>.<tên thuộc tính>. Mình sẽ có 1 bài viết riêng về các quy tắc truy xuất đến thuộc tính và phương thức của 1 lớp để các bạn hiểu rõ hơn. Còn giờ thì ta cứ biết cơ bản là vậy đã, ok 😉
Ok, giờ ta sẽ tạo 1 phương thức khác cho quen tay. Thêm hàm sau vào lớp Human:
fun greeting(){
print("From $name with love")
}
Ta sẽ gọi hàm greetingnày:
var harry = Human("Harry", 15) // Khởi tạo đối tượng harry
harry.greeting() //In ra: From Harry with love
Block init
Trong Kotlin class, ta có thể định nghĩa ra 1 block init, bao gồm các câu lệnh được thực hiện ngay sau khi đối tượng của lớp đó được khởi tạo. Ví dụ nhé, ta thêm khối lệnh sau vào lớp Human:
init {
println("$name has been born")
}
Block initnày thực hiện việc log ra dòng thông báo ngay sau khi mỗi đối tượng của class Humanđược khởi tạo. Thử khởi tạo 1 đối tượng mới:
var peter = Human("Peter", 15) // In ra: Peter has been born
peter.introduce() // in ra: Hello, I am Peter, I am 15 years old
Như ta thấy các câu lệnh trong block initđã được gọi ngay sau khi đối tượng peter được tạo ra. Và tất nhiên là trước khi phương thức introduceđược thực hiện.
Từ khóa this
Trong 1 lớp , từ khoá thistrỏ tới đối tượng hiện tại của lớp đó. Nghe hơi trúc trắc nhỉ, mình sẽ demo ngay để các bạn dễ hình dung. Ta viết 1 phương thức như sau:
fun increaseAge() {
this.age += 1
}
Phương thức này tăng giá trị của thuộc tính agelên 1 đơn vị. Ở đây, từ khoá this trỏ đến đối tượng hiện tại, tức là đối tượng đang gọi phương thứcincreaseAgenày, và thay đổi thuộc tính agecủa đối tượng đó. Ta thử gọi phương thức:
var human = Human("Nam", 20)
human.increaseAge()
human.introduce() //In ra: Hello, I am Nam, I am 21 years old
Secondary constructor
Một lớp có thể có nhiều hàm khởi tạo khác nhau. Secondary constructor là các hàm khởi tạo khác với hàm khởi tạo chính (primary constructor). Mình sẽ lấy thêm 1 ví dụ khác cho các bạn hiểu rõ hơn nữa nhé. Ta sẽ tạo 1 lớp Animal. Đầu tiên, khai báo lớp và hàm khởi tạo:
class Animal(var kind:String, var name: String){
}
Animallà lớp đặc trưng cho động vật, có các thuộc tính là kind (loài) và name (tên). Giờ mình sẽ thêm 1 thuộc tính nữa:
var age:Int?=null
Thuộc tính age có kiểu Int. Thuộc tính này có thể có giá trị hoặc null. Nếu bạn còn chưa rõ các khái niệm về nullable type, hãy đọc lại bài hướng dẫn về Nullable type – kiểu dữ liệu có thể null của mình nhé.
Thêm 1 phương thức:
fun getInfo() {
print("Hello, i am a $kind, my name is $name")
age?.let {
print(", i am $age years old")
}
}
Đơn giản là log ra câu chào ứng với các giá trị của kindvà name. Nếu ageđược gán giá trị (khác null) thì log thêm cả giá trị của age. Toàn bộ lớp Animalcủa ta sẽ như thế này:
class Animal(var kind: String, var name: String) {
var age: Int? = null
fun getInfo() {
print("Hello, i am a $kind, my name is $name")
age?.let {
print(", i am $age years old")
}
}
}
Thử khởi tạo 1 đối tượng, và gọi phương thức getInfo:
var cat = Animal("cat", "Miu Miu")
cat.age = 1
cat.getInfo() //In ra: Hello, i am a cat, my name is Miu Miu, i am 1 years old
Tạo 1 đối tượng Animalkhác:
var dog = Animal("dog", "Milu")
dog.getInfo() // In ra: Hello, i am a dog, my name is Milu
Lần này, dòng log ko có thông báo age vì age đang có giá trị null. Các bạn có thể thấy rằng mỗi khi khởi tạo 1 đối tượng Animal, ngoài kindvà name là các thuộc tính bắt buộc phải có trong hàm khởi tạo. Thì thuộc tính age là không bắt buộc. Nếu ta quên không set giá trị cho age thì đương nhiên nó sẽ null. Giờ ta muốn đưa age vào 1 hàm khởi tạo khác mà vẫn muốn giữ hàm khởi tạo ta định nghĩa lúc đầu, phải làm thế nào. Ta sẽ định nghĩa thêm 1 hàm khởi tạo nữa, tất cả (những) hàm khởi tạo được định nghĩa thêm được gọi là Secondary constructor:
Secondary constructor phải gọi đến primary constructor: this(kind, name) hoặc gọi đến Secondary constructor nào có gọi primary constructor. Tóm lại bằng mọi giá phải tham chiếu đến primary constructor.
Secondary constructor không cho phép định nghĩa các thuộc tính, tức là ta không thể sử dụng các từ khóa var, val khi định nghĩa Secondary constructor.
Ta thử khởi tạo 1 phương thức dùng hàm Secondary constructor mới được viết xem sao:
var bird = Animal("bird", "Kiki", 3)
bird.getInfo() // In ra: Hello, i am a bird, my name is Kiki, i am 3 years old
Hàm khởi tạo này gọi đến hàm khởi tạo thứ 2 ta định nghĩa ở trên, do hàm khởi tạo thứ 2 đã tham chiếu đến primary constructor, nên hàm khởi tạo thứ 3 này hoàn toàn hợp lệ. Ok, hi vọng các bạn đã hiểu được về secondary constructor.
Getter và setter
Khác với java, mỗi thuộc tính trong các Kotlin class đều được khởi tạo 1 hàm gettervà 1 hàm settermặc định. Hàm gettercủa 1 thuộc tính được gọi đến khi ta truy xuất đến giá trị của thuộc tính đó. Hàm setterthì được gọi khi ta thay đổi giá trị của thuộc tính. Để ví dụ mình sẽ định nghĩa thêm 1 thuộc tính trong lớp Animaltrên và viết getter setter cho nó. Các bạn hãy nhớ kỹ rằng, nếu ta ko viết gettersettercho 1 thuộc tính thì thuộc tính đó sẽ có các hàm gettervà settermặc định, các hàm đó đơn giản chỉ lấy và gán giá trị cho thuộc tính của chúng ta.
var isSafe: Boolean
get() {
println("Getter of property isSafe called")
if (kind.equals("tiger", true) || kind.equals("puma", true)) {
return false
} else {
return true
}
}
set(value) {
println("Setter of property isSafe called")
}
Giờ thử tạo 1 đối tượng và lấy giá trị của thuộc tính isSafe:
var dog = Animal("dog", "Lili")
println("${dog.isSafe}")
Kết quả:
Getter of property isSafe called
true
Như vậy khi lấy giá trị của isSafethì hàm getterứng với thuộc tính isSafeđã được gọi. Ta sẽ thử thay đổi giá trị của isSafexem sao:
dog.isSafe = false // In ra: Setter of property isSafe called
Vậy khi thay đổi giá trị của isSafe thì hàm setter đã được gọi.
Lưu ý: Hàm getter và setter thường được viết lại cho các thuộc tính mà giá trị của nó phụ thuộc vào gía trị của các thuộc tính khác. Như ví dụ trên, giá trị của thuộc tính isSafe phụ thuộc vào gía trị của kind. Nếu trong hàm getter hay setter mà các bạn truy xuất đến thuộc tính tương ứng của nó thì sẽ xảy ra lỗi. Mình ví dụ như sau, ta sẽ thay đổi lại nội dung hàm getter ở trên:
get() {
return isSafe
}
Hàm getter của isSafetrả về đúng giá trị của isSafenghe hợp lý đúng ko. Thử xem:
var dog = Animal("dog", "Lili")
println("${dog.isSafe}")
Kết quả là dòng log đỏ chói : Exception in thread “main” java.lang.StackOverflowError 😀 . Lý do vì bản thân hàm getterở trên đã return về giá trị của isSafe, mà mỗi khi truy xuất đến isSafethì hàm getterlại được gọi, điều đó tạo ra 1 vòng lặp không có điểm dừng, đây chính là nguyên nhân exception java.lang.StackOverflowError bị văng ra. Vì vậy, hãy luôn nhớ, chỉ viết gettervà settercho các thuộc tính mà giá trị của nó phụ thuộc vào các thuộc tính khác. Còn nếu không, settervà getterđã được mặc định viết cho chúng ta rồi, chúng ta ko nên chọc vào chúng nữa.
Xin chào, mình là Vũ. Ở bài viết trước mình đã giới thiệu cơ bản về cách khai báo và sử dụng hàm trong Kotlin. Trong bài này mình sẽ trình bày các kiến thức nâng cao hơn (và thú vị hơn) về hàm trong Kotlin. Chúng là top-level function, lambda function, là extension function, và còn nhiều nhiều nữa. Hãy cùng theo dõi nhé.
Trước khi bắt đầu, hãy tạo cho mình 1 project mới và tạo 1 file Main.kt với hàm main. Main.kt sẽ là nơi để ta viết các đoạn code demo. Nếu bạn chưa biết làm những điều này, vui lòng tham khảo lại bài viết hướng dẫn sử dụng IntelleJ IDEA của mình.
[toc]
Top-level function
Top-level function là các hàm không nằm trong bất kỳ 1 lớp (class) nào. Chúng được định nghĩa trong các package và được sử dụng bằng cách gọi trực tiếp qua tên đầy đủ (trong trường hợp không import package) hoặc tên hàm (trong trường hợp đã import package). Nếu bạn từng làm việc với Java chắc đều đã quen thuộc với các hàm static nằm trong lớp Utils. Top-level function trong Kotlin hoàn toàn tương tự như static function trong Java.
Hàm getPiở bài trước mình định nghĩa chính là 1 top-level function. Giờ để hiểu rõ thêm sẽ làm thêm 1 ví dụ khác nữa. Ta tạo 1 file đặt tên là Utility.kt, định nghĩa package com.duongvu.utils và khai báo 1 hàm getCurrentDatetrong package đó:
package com.duongvu.utils
fun getCurrentDate(): String {
val date = Date()
val dateFormat = "dd/MM/yyyy"
val sdf = SimpleDateFormat(dateFormat)
return sdf.format(date)
}
Lưu ý: tên packge không nhất thiết phải giống tên file chứa nó. Như ở trên mình đã định nghĩa package com.duongvu.utils trong file Utility.kt, điều này hoàn toàn OK.
Lưu ý: Bạn chưa cần phải hiểu rõ từng dòng trong hàm getCurrentDateở trên, chỉ cần hiểu nó trả về ngày hiện tại dưới dạng 1 String. Và hàm này sử dụng các lớp java.util.Date và java.text.SimpleDateFormat, nên ta cần import 2 lớp trên:
Giờ ta đã có thể sử dụng hàm getCurrentDatetrong file Main.ktnhư sau:
import com.duongvu.utils.getCurrentDate
//Sử dụng bằng cách import hàm getCurrentDate trong package com.duongvu.utils
fun main(args: Array<String>) {
print(getCurrentDate()) //in ra ngày hiện tại
}
hoặc:
import com.duongvu.utils.*
//Sử dụng bằng cách import tất cả mọi thứ trong package com.duongvu.utils
fun main(args: Array<String>) {
print(getCurrentDate())
}
hoặc:
//Sử dụng bằng cách gọi tên đầy đủ của hàm getCurrentDate
fun main(args: Array<String>) {
print(com.duongvu.utils.getCurrentDate())
}
Đó là tất cả các cách sử dụng 1 top-level function.
Lambda function
Lambda function là gì? Cấu trúc của lambda function?
Lambda function là các hàm không có tên. Chúng thường được sử dụng như các tham số để truyền vào 1 hàm khác (mình sẽ trình bày ở phần dưới). Lambda function còn có thể được biểu diễn dưới dạng các biến. Để rõ hơn hãy nhìn vào ví dụ của mình, trong file Main.kt mình sẽ khai báo 1 lambda function như thế này:
var message = {
print("Kotlin is awesome :D")
}
Ở trên mình đã định nghĩa 1 lambda function bởi 1 cặp {} và gán lambda function này vào biến message. Như các bạn thấy hàm này không cần định nghĩa bởi từ khóa fun, nó không hề có tên, cũng không hề có kiểu trả về. Trong hàm main, ta sẽ sử dụng nó như sau:
message() // in ra : Kotlin is awesome :D
Giờ ta sẽ nâng cấp lambda function trên 1 chút, ta sẽ truyền thêm tham số cho nó:
val message = {
str:String->
println(str)
println("End lambda function")
}
Gọi hàm:
message("Kotlin is awesome :D") //in ra : Kotlin is awesome
// End lambda function
Như vậy, nếu lambda function có tham số đầu vào thì các tham số sẽ được khai báo như đối với hàm bình thường, sau đó là ký tự -> và kế đến là thân hàm.
Higher-order functions – Sử dụng lambda function như 1 tham số đầu vào
Một điều tuyệt vời mà Kotlin cho phép ta làm đó là có thể sử dụng hàm như 1 tham số. Đây là điều không thể làm được trong Java. Ta làm điều này như thế nào? Hãy cũng xem ví dụ:
fun printSummary(number1: Int, number2: Int, summaryFunction: (Int, Int) -> Int) {
val sum = summaryFunction(number1, number2)
print("Sum of $number1 and $number2 is $sum")
}
Ở đây ta định nghĩa 1 hàm in ra tổng của 2 số nguyên. Hãy nhìn vào các tham số đầu vào của hàm printSummarynày. 2 tham số đầu tiên là 2 số nguyên đầu vào để tính tổng, cái này quá dễ. Còn tham số cuối cùng:summaryFunction là Hàm thực hiện việc tính tổng của 2 tham số đầu tiên. Hàm printSummarycần 1 tham số đầu vào là 1 hàm có đặc điểm:
Nhận 2 tham số Int là tham số đầu vào
Trả về kiểu dữ liệu Int
printSummary chỉ đơn thuần sử dụng giá trị trả về của summaryFunction. Giờ ta thử sử dụng hàm printSummary:
printSummary(number1 = 10, number2 = 10, summaryFunction = { a:Int, b:Int ->
a + b
})
//In ra: Sum of 10 and 10 is 20
Ở đây khi gọi hàm printSummarymình đã truyền giá trị các tham số kèm theo tên để các bạn dễ hiểu. Hãy để ý vào tham số thứ 3, mình đã sử dụng 1 lambda function nhận 2 giá trị đầu vào là a và b, và trả về giá trị a+b. Hàm này thỏa mãn điều kiện là nhận 2 tham số Int và trả về kiểu Int.
Lưu ý 1: Khi truyền 1 lambda function vào 1 hàm khác dưới dạng 1 tham số, ta có thể bỏ qua phần định nghĩa kiểu dữ liệu cho các tham số của lambda function. Kotlin tự động gán kiểu cho các tham số của lambda function sao cho khớp với lúc khai báo hàm. Ví dụ, ta hoàn toàn có thể gọi hàm printSummaryở trên như sau:
printSummary(number1 = 10, number2 = 10, summaryFunction = { a, b ->
a + b
})
//In ra: Sum of 10 and 10 is 20
Ta không cần định nghĩa kiểu dữ liệu cho a và b. 2 tham số này sẽ tự động được gán kiểu là Int, bởi Kotlin thông minh, đơn giản là vậy.
Lưu ý 2: Ta cũng không cần phải chỉ ra kiểu dữ liệu trả về cho lambda function, bởi Kotlin cũng sẽ tự động định nghĩa kiểu dữ liệu trả về cho chúng ta (như ở trường hợp trên, kiểu dữ liệu trả về là Int).
Lưu ý 3: Đối với lambda function, khi muốn trả về 1 giá trị, ta không thể dùng từ khóa return. Ta đơn giản chỉ cần nêu ra giá trị đó. Như ví dụ trên là a+b. Tất nhiên giá trị ta nêu ra phải có cùng kiểu dữ liệu trả về của lambda function (như ví dụ trên là Int), nếu không sẽ nhận được thông báo lỗi Type mismatch.
Lưu ý 4: Vì không thể sử dụng từ khóa return, nên ta có thể nêu ra bao nhiêu giá trị tùy thích. Nhưng lambda function sẽ lấy giá trị cuối cùng làm giá trị trả về của hàm:
printSummary(number1 = 10, number2 = 10, summaryFunction = { a, b ->
a+b
a-b
a*b
})
// a*b sẽ là giá trị trả về của hàm summaryFunction
//In ra: Sum of 10 and 10 is 100
Lưu ý 5: Nếu lambda function là tham số cuối cùng của 1 hàm, ta có thể viết nội dung của lambda function bên ngoài cặp (). Ví dụ:
printSummary(number1 = 10, number2 = 10) { a, b ->
a + b
}
//in ra: Sum of 10 and 10 is 20
Nhìn như này trông code sẽ đẹp hơn và dễ hiểu hơn :).
Tham số it
Khi truyền lambda function vào 1 hàm khác dưới dạng 1 tham số, nếu lambda function đó chỉ có duy nhất 1 tham số, ta có thể bỏ qua việc khai báo tham số đó và sử dụng luôn tham số it. Đây là tham số được tự động generate để sử dụng đối với các lambda function chỉ nhận 1 tham số đầu vào. Ví dụ:
fun printDouble(number: Int, doubleFunction: (Int) -> Int) {
print(doubleFunction(number))
}
Ta định nghĩa hàm printDoublenhận 1 tham số Int và 1 tham số là lambda function. Lambda function này có duy nhất 1 tham số đầu vào kiểu Int. Bình thường, ta sẽ gọi hàm printDoublenhư sau:
printDouble(number = 3) { x->
x* 2
}
//In ra: 6
Tuy nhiên, ta có thể bỏ qua phần khai báo tham số x và sử dụng luôn tham số it (được tự động sinh ra, tương ứng với x):
Đoạn code trên in ra các phần tử bắt đầu bởi ký tự R.
Do hàm filter nhận 1 lambda function có đặc điểm: có duy nhất 1 tham số đầu vào kiểu String. Nên ta có thể sử dụng luôn tham số it (được tự động generate, có kiểu String). Thay vì phải viết thế này:
Hãy cùng xem 1 ví dụ. Ở ví dụ sau đây, ta sẽ truyền 1 lambda function vào hàm forEach của 1 intArray. Lambda function này duyệt qua tất cả các phần tử nếu gặp phần tử nào chia hết cho 3, thì hàm lambda này sẽ dừng lại.
fun testReturnFunction() {
val intList = intArrayOf(1, 3, 5, 7, 9)
intList.forEach {
if (it % 3 == 0) {
return
}
}
println("End of testReturnFunction()")
}
Và gọi thử:
testReturnFunction() //Không có gì xảy ra
Tại sao lại không có gì xảy ra? Bởi câu lệnh returnkhông chỉ kết thúc lambda function, nó còn kết thúc luôn hàm chứa nó là testReturnFunction. Nên câu lệnh println(“End of testReturnFunction()”) không bao giờ được gọi. Để cho Kotlin hiểu rằng, chỉ kết thúc lambda function, ta sửa lại như sau:
fun testReturnFunction() {
val intList = intArrayOf(1, 3, 5, 7, 9)
intList.forEach labelForEach@ { // Định nghĩa nhãn labelForEach cho hàm forEach, khi muốn return sẽ dùng đến nhãn này
if (it % 3 == 0) {
return@labelForEach // Câu lệnh này chỉ kết thúc hàm có nhãn labelForEach
}
}
println("End of testReturnFunction()")
}
Lúc này, khi gọi hàm testReturnFunction() ta sẽ nhận được dòng log như mong đợi:
End of testRuturnFunction()
Trên đây mình đã trình bày những vấn đề cơ bản mà chúng ta cần phải biết về lambda function. Đây cũng sẽ là loại function mà mình rất hay sử dụng trong phát triển ứng dụng Android. Vì nó rất đơn giản, ngắn gọn, tường minh. Nó thay thế được cho các interface cồng kềnh trong Java (mình sẽ nói trong các bài tiếp theo). Hy vọng các bạn nắm rõ được nó. Sau này ở loạt bài Android, mình sẽ có dịp quay trở lại chủ đề này. Còn giờ thì next qua phần khác thôi 😀
Extension function
Chúng ta đều biết rằng, kiểu dữ liệu String cung cấp hàm cho ta biến 1 chuỗi chữ thường thành chữ hoa:
val normalString = "abcdef"
val upperCaseString = normalString.toUpperCase()
print(upperCaseString) // in ra: ABCDEF
Nhưng giờ nếu ta muốn String có thêm hàm chỉ biến ký tự đầu tiên thành chữ hoa thôi, còn các ký tự khác biến thành chữ thường, thì phải làm thế nào? Có thể bạn sẽ nghĩ đến việc kế thừa lớp String và viết hàm bổ sung theo ý muốn. Nhưng String là lớp final, tức là nó không cho phép kế thừa. Giờ mình muốn mỗi biến String đều được cung cấp hàm như thế này:
Hàm upperFirstLetter hiển thị trong danh sách các hàm gợi ý của String
Kotlin lại cung cấp cho ta 1 tính năng tuyệt vời, đó là extension function. Đây là tính năng cho phép ta mở rộng 1 lớp (trong trường hợp này là String) với các hàm bổ sung mà không cần phải kế thừa lớp đó.
Định nghĩa extension function
Giờ mình sẽ tạo file StringUtils.kt chứa 1 package mới com.duongvu.stringutils, và định nghĩa 1 hàm như sau:
package com.duongvu.stringutils
fun String.upperFirstLetter(): String {
val firstLetter = this.substring(0, 1).toUpperCase() //Lấy ký tự đầu, viết hoa lên
return firstLetter.plus(this.substring(1)) // Nối ký tự đầu (đã viết hoa) với phần còn lại của chuỗi.
}
Đây chính là 1 extension function (hàm mở rộng) của kiểu dữ liệu String. Như các bạn thấy, để định nghĩa hàm mở rộng, ta cần phải chỉ ra kiểu dữ liệu (String) trước tên hàm mở rộng (upperFirstLetter). Từ khóa this được sử dụng trong thân hàm biểu diễn cho đối tượng gọi đến hàm upperFirstLetter.
Sử dụng extension function
Sau khi đã định nghĩa xong, để sử dụng extension function thì việc đầu tiên ta phải import package chứa nó. Sau đó ta gọi tới extension function như những hàm bình thường khác của kiểu dữ liệu ta vừa mở rộng (trường hợp này là String):
import com.duongvu.stringutils.upperFirstLetter
fun main(args: Array<String>) {
val myName = "duong vu"
print(myName.upperFirstLetter()) // in ra: Duong vu
}
Các bạn có thể thấy rằng, hàm upperFirstLetterđã xuất hiện trong danh sách gợi ý của IDE (như hình mình gửi bên trên).
Tổng kết
Như vậy ở bài viết này mình đã trình bày về:
Top level function
Lambda function
Extension function
Hy vọng qua 2 bài viết về hàm trong Kotlin vừa qua các bạn đã có được kiến thức nền tảng và kỹ năng cơ bản để sử dụng chúng. Tất nhiên vẫn còn 1 số kiến thức mà mình chưa trình bày ra ở đây. Bởi mình thấy sẽ phù hợp, dễ hiểu và bổ ích hơn khi đan xen chúng vào các kiến thức khác, hơn là việc chỉ nêu ra khái niệm. Các kiến thức đó chắc chắn mình sẽ nêu ra trong các bài viết sắp tới. Và bài tiếp theo mình sẽ bắt đầu trình bày về những khái niệm cơ bản nhất của lập trình hướng đối tượng. Đó là class và object. Đây là những khái niệm cực kỳ quan trọng, và sẽ đi theo ta trong mọi dự án. Hãy theo dõi nhé.
Ở bài trước mình đã trình bày về các cấu trúc điều kiện và vòng lặp trong Kotlin. Bài hôm nay mình sẽ giới thiệu về cách định nghĩa và sử dụng hàm trong Kotlin, sau đó là nói về cách tổ chức code sử dụng package.
[toc]
Hàm (Function)
Hàm là 1 tập hợp các đoạn câu lệnh để thực hiện công việc nào đó. Hàm có thể có tên và cũng có thể không. Việc sử dụng hàm sẽ khiến cho code của ta ngắn gọn hơn và không bị lặp đi lặp lại các đoạn code.
Khai báo và gọi hàm
Trong Kotlin, ta định nghĩa hàm sử dụng từ khóa fun:
fun helloMessage(name: String): String {
return "Hello, $name"
}
Và thử gọi hàm qua câu lệnh:
val helloMessage = helloMessage("Duong Vu")
println(helloMessage) // in ra: Hello, Duong Vu
Trong ví dụ trên, ta đã khai báo hàm helloMessage với 1 tham số đầu vào là namecó kiểu String. Hàm này trả về kiểu dữ liệu String. Cách khai báo tham số khi định nghĩa hàm là:
tên_tham_số:kiểu_dữ_liệu
Lưu ý: Hàm có thể có hoặc không có tham số.
Ta xem thử 1 ví dụ khác:
fun sayHello(name: String):Unit{
print("Hello, $name")
}
Và gọi hàm sayHello:
sayHello("Duong Vu") // in ra: Hello, Dương Vu
Ta thấy là hàm sayHelloở trên cũng tương tự với hàm helloMessageta viết lúc đầu. Chỉ khác 1 điều là hàm sayHellotrả về kiểu dữ liệu Unit (thay vì String) và tự nó print ra câu chào. Bạn có thể thấy hàm sayHellokhông có câu lệnh returnở cuối hàm. Bởi đơn giản, kiểu dữ liệu Unit là kiểu dữ liệu đặc biệt, khi hàm trả về kiểu dữ liệu này, ta không bắt buộc phải có câu lệnh return để trả về kết quả cho hàm. Unit trong Kotlin giống như Void trong C và Java vậy. Và trong Kotlin, khi bạn định nghĩa 1 hàm mà không khai báo kiểu dữ liệu trả về, thì tức là hàm của bạn đã trả về kiểu Unit:
//Kết quả vẫn giống hệt như khi có khai báo trả về kiểu Unit
fun sayHello(name: String) {
print("Hello, $name")
}
Định nghĩa giá trị mặc định của tham số:
Ta viết lại hàm sayHellonhư thế này:
fun sayHello(name: String = "Dương vũ") {
print("Hello, $name!!!")
}
Như ta thấy, so với hàm đã viết ở phần 1, tham số đầu vào name có thêm định nghĩa = “Dương vũ” điều này tức là “Dương Vũ” là giá trị mặc định của tham số name. Nếu ta gọi hàm sayHello mà không truyền tham số name, Kotlin sẽ sử dụng giá trị mặc định của tham số nameđó. Thử gọi hàm:
sayHello() // Kết quả: Hello, Dương Vũ
Còn tất nhiên khi ta truyền giá trị cho tham số name thì giá trị mặc định sẽ không được sử dụng nữa:
sayHello("Mr.Rain") // Kết quả: Hello, Mr.Rain
Việc Kotlin cho phép định nghĩa giá trị mặc định của tham số đã giúp cho ta giảm thiểu số lượng hàm phải viết. Nếu như trong Java, không có tính năng này, ta đã phải viết 2 hàm sayHello(name) và sayHello() để xử lý các trường hợp có và không có tham số đầu vào rồi. Rất tiện đúng không?
Sử dụng tên cho tham số
Sử dụng tên cho tham số là gì và vì sao trong một số trường hợp bắt buộc phải cần đến nó. Hãy cùng mình xem 1 ví dụ. Ta sẽ định nghĩa 1 hàm như sau:
Ở trên ta khai báo 1 hàm với 3 tham số đầu vào: firstName, middleName, lastName. Trong đó middleNamecó giá trị mặc định là Van. Như mình đã nói ở phần trên, nếu không truyền tham số middleNamethì Kotlin sẽ sử dụng giá trị mặc định của nó (là Van) đúng không? Giờ ta thử gọi hàm mà không truyền middleNamevào xem sao:
getFullName("Tran", "Nam") //lỗi No value passed for parameter lastName
Lúc này, ta sẽ nhận được thông báo lỗi: No value passed for parameter lastName (chưa truyền tham số lastName). Vì sao? Vì khi này, Kotlin hiểu rằng tham số thứ 2 (có giá trị “Nam“) là middleName, chứ không phải là lastNamenhư ta mong muốn. Khi này ta cần phải làm như sau:
getFullName("Tran", lastName = "Nam") // In ra Full name: Tran Van Nam
Lúc này ta đã chỉ rõ “Nam” là giá trị của tham số lastNamechứ không phải của middleName, và middleNamedo không truyền vào nên sử dụng giá trị mặc định.
Lưu ý: Việc truyền tên tham số trong lúc gọi hàm đôi khi không bắt buộc, nhưng nó làm cho code của ta dễ đọc hơn, vì vậy mình khuyến khích khi sử dụng hàm, hãy cố gắng truyền thêm tên tham số vào, để sau này đọc lại code không bị vất vả.
Hàm với 1 dòng lệnh duy nhất – Single line function
Khi giá trị trả về của 1 hàm có thể viết được bằng 1 dòng lệnh duy nhất, ta có thể bỏ cặp {} và từ khóa returnđể đơn giản hóa. Ví dụ:
fun getSum(numberOne: Int, numberTow: Int) = numberOne + numberTow
Hàm trên tính tổng của 2 số, và ta chỉ cần duy nhất 1 dòng để định nghĩa hàm, ko cần đến {} và từ khóa return, rất ngắn gọn.
Thêm 1 ví dụ nữa:
fun doubleNumber(number:Int) = 2*number
Hàm không giới hạn tham số
Đôi khi ta không biết trước số lượng tham số cần truyền vào cho hàm. Ta có thể cần truyền 1, 2 hay thậm chí 100 tham số. Lúc này ta cần định nghĩa 1 hàm không giới hạn tham số. Ví dụ như sau:
fun getSum(vararg numbers: Int): Int {
var sum = 0
for (n in numbers) {
sum = sum + n
}
return sum
}
Như các bạn thấy ta đã thêm từ khóa varargvào trước tham số numbers(kiểu Int). Có nghĩa là ở đây ta có thể truyền bao nhiêu tham số (kiểu Int) tùy thích. Và hàm getSumnày sẽ tính tổng của tất cả các tham số truyền vào. Thử gọi hàm:
print(getSum(1,2,3)) // In ra 6
print(getSum(1,2,3,4,5)) // In ra 15
Hàm cục bộ
Kotlin cho phép ta định nghĩa hàm trong thân 1 hàm khác.
fun printGreeting(firstName: String, lastName: String) {
//Bắt đầu định nghĩa hàm cục bộ
fun getFullName(firstName: String, lastName: String): String {
return "$firstName $lastName"
}
//Sử dụng hàm cục bộ
println("Hello ${getFullName(firstName, lastName)}")
}
Vẫn là hàm in ra 1 câu chào, đầu vào là firstNamevà lastName. Nhưng lần này, trong thân hàm printGreetingta đã định nghĩa thêm 1 hàm khác, getFullNametrả về tên đầy đủ dựa vào 2 tham số đầu vào firstNamevà lastNamecủa hàm printGreetingVà hàm printGreetingsẽ sử dụng giá trị trả về từ hàm getFullName. Thử gọi hàm:
printGreeting("Duong", "Vu") // Kết quả: Hello Duong Vu
Lưu ý: Hàm cục bộ chỉ có thể sử dụng được trong thân hàm mà nó được định nghĩa.
Như vậy là trên đây mình đã giới thiệu cơ bản về khai báo hàm và cách sử dụng hàm trong nhiều trường hợp. Vẫn còn 1 số kiến thức khác nâng cao hơn như lambda function, extension function, … mình sẽ trình bày trong những bài sau, trong những tình huống phù hợp hơn. Còn bây giờ, ta chỉ cần biết được cơ bản về hàm trong Kotlin, vậy là đủ nhỉ ;).
Packages
Nếu bạn từng làm việc với Java, chắc hẳn bạn đã biết rằng Java sử dụng các gói (package) để chứa các lớp có liên quan với nhau. Ví dụ như package java.util chứa các lớp tiện ích mà ta thường sử dụng như Date, HashMap, Collections, … Ở trong Kotlin, package cũng có khái niệm tương tự. Tuy nhiên package trong Kotlin không chỉ chứa được các lớp mà nó còn có thể chứa các hàm (lớp là gì thì mình sẽ trình bày ngay bài sau). Và việc định nghĩa package ở trong Kotlin cũng cực kỳ dễ dàng. Trong Kotlin, các package được định nghĩa với từ khóa package.
Định nghĩa package
Giờ mình sẽ hướng dẫn các bạn cách định nghĩa, khai báo 1 package. Các bạn hãy tạo 1 project mới trong IntelliJ IDEA. Tạo 1 file Kotlin đặt tên là Utils.kt:
Tạo file Utils.kt
Note: Nếu bạn còn đang thắc mắc về cách tạo project, tạo file/class thì hãy đọc lại bài hướng dẫn sử dụng IntelliJ IDEA của mình nhé.
Giờ mình sẽ định nghĩa packge Utils như sau:
package Utils
Quá đơn giản đúng không? Vậy là ta đã định nghĩa xong package Utilsbằng từ khóa packagerồi. Giờ, bên trong file Utils.kt, ta sẽ định nghĩa thêm 1 lớp MyClassnữa (ta sẽ tìm hiểu về lớp trong các bài viết sau):
class MyClass
Việc làm trên có nghĩa là ta đã định nghĩa lớp MyClassnằm trong package Utils. Và tên đầy đủ (fully qualified name) của lớp MyClass là: Utils.MyClass. Vậy tên đầy đủ của 1 class nằm trong 1 package sẽ là
tên_package.tên_class
Giờ ta sẽ thử định nghĩa 1 hàm trong package Utilsnhư sau:
fun getPi():Float{
return 3.14f
}
Cũng tương tự như lớp MyClassta vừa tạo ở trên, hàm getPisẽ có tên đầy đủ là Utils.getPi(). Tên đầy đủ dùng để làm gì, mình sẽ trình bày ngay ở phần dưới.
Import package
Trong Kotlin, để sử dụng các lớp, hàm, … nói chung là mọi thứ trong package, ta cần phải import package đó. Để làm việc này, ta sử dụng từ khóa import. Bây giờ ta sẽ thử sử dụng package Utils mà ta đã định nghĩa ở trên. Ta sẽ tạo 1 file mới trong project, đặt tên cho nó là Main.kt. Ta viết sẵn cho file Main.kt này 1 hàm mainnhư sau để chuẩn bị cho việc viết code:
fun main(args: Array<String>) {
}
Rồi Ok, giờ ta sẽ import package Utils đã viết trước đó. Thêm dòng sau vào ngay đầu file Main.kt:
import Utils.*
Câu lệnh này đã import toàn bộ package Utilsvào file Main.kt. Giờ ta có thể sử dụng bất cứ thứ gì có trong package Utils. Trong hàm maincủa file Main.kt, Ta sẽ thử gọi hàm getPi() của package Utils:
print(getPi()) // in ra 3.14
Lưu ý: nếu ta không muốn sử dụng toàn bộ package, mà chỉ muốn sử dụng 1 hàm (hoặc lớp) nào đó trong package, ta có thể import riêng hàm (lớp) đó:
import Utils.getPi
Như vậy là ta đã sử dụng được hàm getPitrong package Utils. Giờ ta sẽ thử xóa dòng lệnh importbên trên đi xem sao. Ngay lập tức sẽ nhận được thông báo lỗi: Unresolved reference: getPi (không nhận biết được hàm getPi). Như vậy là nếu không import package Utils, ta sẽ không sử dụng được các thành phần của nó.
Sử dụng tên đầy đủ (fully qualified name) của các thành phần trong package
Nếu bạn không muốn import 1 package mà vẫn muốn sử dụng các thành phần của nó (vì dụ như hàm, lớp…), bạn cần phải sử dụng tên đầy đủ cùa thành phần đó:
print(Utils.getPi()) // in ra 3.14
Đây chính là vai trò của tên đầy đủ mà mình đã trình bày ở phần định nghĩa package. Nó giúp chúng ta không cần phải import 1 package mà vẫn sử dụng được các thành phần trong package đó. Tên đầy đủ của 1 hàm, lớp còn rất quan trọng trong trường hợp sau: Khi ta sử dụng nhiều package mà các package đó có các hàm trùng tên nhau.
Mình tạo ra 1 package khác có tên là Utils2, và cùng định nghĩa hàm getPicho package Utils2đó:
fun getPi():Float = 6.28f
Giờ trong file Main.kt, ta vừa muốn sử dụng hàm getPitrong package Utils, vừa muốn sử dụng getPitrong package Utils2, lúc này ta cũng cần tới tên đầy đủ:
println("getPi at Utils: ${Utils.getPi()}") // in ra 3.14
println("getPi at Utils2: ${Utils2.getPi()}") // in ra 6.28
Tổng kết
Như vậy bài này mình đã trình bày xong cơ bản về cách khai báo và sử dụng hàm trong Kotlin. Mình cũng đã nói xong về vấn để sử dụng package. Tất nhiên những thứ trên đây không phải là tất cả về hàm hay package trong Kotlin, ta còn rất nhiều thứ nâng cao hơn, mới mẻ hơn. Mình sẽ trình bày trong các bài tiếp theo. Hãy theo dõi nhé.
Xin chào, Mình là Dương Vũ, ở bài viết trước mình đã nói về cách truy xuất biến một cách an toàn. Bài này mình sẽ trình bày về các cấu trúc vòng lặp và điều kiện trong Kotlin. Vòng lặp và điều kiện là những tính năng không thể thiếu đối với 1 ngôn ngữ lập trình hiện đại. Và Kotlin còn làm cho chúng trở nên vô cùng thú vị. Cùng tìm hiểu nhé.
[toc]
Các cấu trúc điều kiện
Cấu trúc if và if else
Cấu trúc if kiểm tra tính thoả mãn của 1 điều kiện và thực hiện một (chuỗi) hành động nếu điều kiện đó thoả mãn. Nếu bạn đã từng làm việc với java, bạn sẽ thấy cấu trúc if và if else của Kotlin sử dụng giống hệt như Java. Đây là 1 ví dụ với việc sử dụng if:
val age = 20
if(age>18){
print("You are adult")
}
bởi điều kiện của cấu trúc if (age>18) thoả mãn, Màn hình sẽ hiển thị dòng log You are adult. 1 ví dụ với if – else:
val a = 10
val b = 20
if(a>b){
print("$a > $b")
}else if(a == b){
print("$a = $b")
}else{
print("$a < $b")
}
Màn hình sẽ hiển thị ra dòng log 10<20.
Tuy nhiên ngoài cách sử dụng truyền thống ra, ta có thể dùng cấu trúc if như 1 biểu thức, tức là biểu thức if cũng trả về giá trị, sau đây là ví dụ:
val firstNumber = 10
val secondNumber = 25
var max = if(firstNumber>secondNumber){
println("$firstNumber is max")
firstNumber
}else{
println("$secondNumber is max")
secondNumber
}
println("Max = $max")
Ta thấy trên đây là bài toán tìm max của 2 số rất đơn giản. Cái hay là trong Kotlin, cấu trúc if có thể return về giá trị và giá trị đó có thể được gán cho 1 biến. Như ở ví dụ trên nếu firstNumber > secondNumber thì cấu trúc if sẽ return về giá trị firstNumber, ngược lại sẽ return về giá trị secondNumber. Chạy đoạn code trên ta sẽ thu được
25 is max
Max = 25
Lưu ý: nếu bạn sử dụng if dưới dạng 1 biểu thức, thì cấu trúc if bắt buộc phải có else.
Cấu trúc when
Cấu trúc when tương tự như switch – case của Java hay C. Đây cũng là 1 cấu trúc điều kiện mình rất hay sử dụng. Nó có dạng như thế này
val age = 19
when (age){
in 1..17 -> print("Child")
in 18..40 -> print("Adult")
else -> print("Old")
}
Cấu trúc when kiểm tra tham số đầu vào (ở trường hợp trên là number) với các điều kiện trong thân cấu trúc. Khi bắt gặp điều kiện đúng, các câu lệnh tương ứng với điều kiện đó sẽ được thực hiện và các điều kiện khác sẽ không được xét đến nữa.
Nếu như trong java, các nhánh điều kiện trong cấu trúc switch – case chỉ có thể là hằng số, thì cấu trúc when trong Kotlin tỏ ra mềm dẻo hơn với việc cho phép các điều kiện có thể là các biểu thức, hoặc hàm. Ví dụ:
Ví dụ trên kiểm tra xem numberOne có phải là 1 nửa của numberTwo hay không. Ví dụ có vẻ ngu ngốc nhưng mô tả rõ ràng việc sử dụng biến trong các nhánh điều kiện của when :)) Khi chạy đoạn code trên ta thu đc dòng log: 19 != 21 /2.
Nếu ta thay giá trị của numberTwo = 38 thì ta sẽ thấy log 19 = 38 /2.
Vậy ta có cấu trúc tổng quát của when là thế này
when(tên_biến){
điều_kiện_1 -> { chuỗi lệnh xử lý 1 }
điều_kiện_2 -> { chuỗi lệnh xử lý 2 }
……
else -> { chuỗi lệnh xử lý ngoại lệ }
}
Lưu ý: nếu chỉ có 1 dòng lệnh thì ta có thể không dùng cặp { }
Vòng lặp
Vòng lặp được sinh ra để thực hiện lặp đi lặp lại 1 công việc nào đó. Kotlin cung cấp cho ta 3 dạng vòng lặp là while, do … while và for. Mình sẽ tìm hiểu từng loại 1 nhé.
Vòng lặp while
Đây là 1 dạng vòng lặp có điều kiện. Vòng lặp sẽ chạy chừng nào điều kiện đó vẫn còn đang đúng. Nếu ai đã code Java thì sẽ thấy vòng lặp while trong Kotlin không khác gì Java cả. Ví dụ:
var age = 1
while (age<100){
println("Now i am $age years old")
age++
}
print("i die T_T")
Trên đây là ví dụ về vòng đời của 1 người. Vòng lặp sẽ chạy chừng nào điều kiện age<100 còn thỏa mãn. Và các bạn thấy khi run đoạn lệnh trên console sẽ hiển thị:
Now i am 2 years old
Now i am 3 years old
…
Now i am 100 years old
i die T_T
Vòng lặp do … while
var age = 1
do {
println("Now i am $age years old")
age++
} while (age <= 100)
print("i die T_T")
Đây là cách viết khác của ví dụ vòng đời trên sử dụng vòng lặp do … while. Vẫn là sống từ 1 đến 100 tuổi rồi chết. Vòng lặp do … while thực tế cũng gần giống như vòng lặp while. Cũng là dạng vòng lặp có điều kiện. Chỉ khác 1 điều là, ở vòng chạy đầu tiên thì điều kiện sẽ không được xem xét. Có nghĩa là với vòng lặp do … while, sẽ có ít nhất 1 vòng được thực thi. Để thấy rõ, bạn hãy thử đặt giá trị khởi tạo của biến age là 101. Khi đó dù age không thoả mãn điều kiện (age <= 100) nhưng vẫn sẽ có 1 câu lệnh được in ra: Now i am 101 years old.
Vòng lặp for
Vòng lặp for duyệt qua tất cả các phần tử trong 1 mảng (array) hoặc danh sách (list) và xử lý giá trị ứng với mỗi phần tử. Ví dụ:
for (i in 1..5) {
print("$i ") // in ra 1 2 3 4 5
}
Ok, giờ ta muốn mỗi vòng lặp nhảy 2 đơn vị thì sao? Ta sẽ làm thế này:
for (i in 1..5 step 2) {
print("$i ") // in ra 1 3 5
}
Đơn giản là thêm từ khoá step và cuối điều kiện lặp.
Thế nếu ta muốn duyệt từ 5 trở về 1 thì sao? Ta có từ khoá downto giúp ta làm việc đó:
for (i in 5 downTo 1) {
print("$i ") //in ra 5 4 3 2 1
}
Và duyệt từ 5 trở về 1, mỗi vòng lặp nhảy 2 đơn vị:
for (i in 5 downTo 1 step 2) {
print("$i ") //in ra 5 3 1
}
Sử dụng vòng for để duyệt qua các phần tử của 1 mảng (Array):
val listOfNumber = listOf<Int>(1, 2, 3, 4, 5, 6)
for (number in listOfNumber){
if(number%2==0){
println("$number is even number")
}else{
println("$number is odd number")
}
}
Ví dụ trên khởi tạo 1 list các số nguyên và duyệt qua list đó, in ra console tính chẵn lẻ của từng phần tử. Đơn giản đến mức ko thể giải thích rõ hơn, đúng ko? Thêm 1 ví dụ nữa nhé:
val listName = arrayOf("Neymar", "Vidal", "Rooney", "Ronaldo", "Messi", "Bale")
for (name in listName) {
if (name.startsWith("R")) {
println(name)
}
}
Ví dụ trên khởi tạo 1 mảng các tên cầu thủ, sau đó sử dụng vòng lặp để duyệt qua tất cả các phần tử trong mảng đó, phần tử nào bắt đầu bằng ký tự R thì sẽ log ra màn hình. Kết quả:
Rooney
Ronaldo
Ngoài cách trên ra ta cũng có thể duyệt mảng bằng cách khác, đó là duyệt qua chỉ số:
val listNumber = listOf<Int>(1, 3, 2, -1, 4, 6, 7)
var sum = 0
for (index in 0..listNumber.size - 1) {
sum += listNumber.get(index)
}
print("Summary of list: $sum")
Đây là bài toán đơn giản tính tổng 1 mảng. Nhưng ở ví dụ này ta duyệt mảng thông qua chỉ số (thứ tự) chứ ko duyệt trực tiếp qua các phần tử của listNumber. Bản chất của việc này là ta tạo ra 1 list chỉ số: 0..listNumber.size – 1 gồm các giá trị từ 0 đến listNumber.size – 1. Sau đó ta duyệt list này để lấy các chỉ số (index) của listNumber và truy xuất các phần tử của listNumber thông qua index, phục vụ cho việc tính tổng.
Break và continue
Lưu ý: break và continue trong Kotlin giống hệt như trong java, anh em nào biết rồi thì có thể bỏ qua không đọc :))
break và continue là 2 từ khóa để tạo ra các bước nhảy trong vòng lặp. Cụ thể:
break dùng để thoát ra khỏi vòng lặp.
continue dùng để lập tức chuyển tới vòng lặp tiếp theo, bỏ qua các câu lệnh còn lại của vòng lặp hiện tại.
break và continue có thể dùng được trong mọi thể loại vòng lặp, dù có là for hay while hay là do – while vẫn ok tất. Ví dụ về break
for(age in 1..100){
println("Now i am $age years old")
if(age == 25){
println("i see girl when ride motorbike, then i hug a big tree in the road")
break
}
}
print("i die T_T")
Vẫn là ví dụ về vòng đời, nhưng ở đây có chút khác biệt. Khi age có giá trị là 25, thanh niên console đi xe máy ra ngoài đường và ngắm gái, kết quả là đâm vào cây và hẹo. Thế nên ta dùng lệnh break để thoát khỏi vòng lặp for(age in 1..100) dù age mới có giá trị là 25. Kết quả hiện ra trên màn hình
Now i am 1 years old
Now i am 2 years old
…..
Now i am 25 years old
i see girl when ride motorbike, then i hug a big tree in the road
i die T_T
Ví dụ về continue:
var level = 1
while (level <= 10) {
if (level == 3) {
level += 6
println("I have a special gift code, my level up!!!")
continue
}
println("My level is $level")
level++
}
Đây là 1 ví dụ về 1 anh cày game, ở mỗi level của anh ấy đều có 1 dòng log println(“My level is $level”), tuy nhiên khi đang ở level 3 thì anh ấy nhận được gift code khủng nên nhảy 1 phát lên level 9: level += 6 và bỏ qua dòng log println(“My level is $level”) ở vòng lặp khi level = 3. Điều này có được nhờ câu lệnh continue, nó sẽ bỏ qua tất cả những câu lệnh ở phía sau nó (trong vòng lặp) và lập tức chuyển sang vòng lặp tiếp theo.
Ví dụ khác:
for (number in 1..10) {
if (number % 2 == 0) {
continue
}
print("Number = $number")
}
Tổng kết
Như vậy, cơ bản mình đã trình bày xong về Các cấu trúc vòng lặp và điều kiện trong Kotlin.
Đến đây ta đã có những trang bị kiến thức:
Các kiểu dữ liệu cơ bản
Các kiểu dữ liệu mảng, danh sách
Kiểu dữ liệu nullable, các cách sử dụng biến an toàn (tránh NullPoiterException)
Cấu trúc điều kiện if, if-else, when
Các dạng vòng lặp for, while
Các cách ngắt vòng lặp sử dụng break, continue
Đây là các thành phần cơ bản nhất mà ngôn ngữ nào cũng phải cung cấp. Đối với ai đã từng làm với Java chắc ko có khó khăn gì. Bài tiếp theo sẽ bắt đầu trình bày về các kiến thức liên quan đến cách sử dụng hàm trong Kotlin. Và những sự ưu việt của Kotlin so với Java (tất nhiên là về cú pháp). Rất mong các bạn sẽ ủng hộ mình.
Xin chào, mình là Dương Vũ. Hôm nay mình sẽ trình bày về các kiểu dữ liệu cơ bản trong Kotlin. Sau bài này các bạn có thể biết cách khai báo biến, hằng số. Đồng thời các bạn cũng có kiến thức về các kiểu dữ liệu cơ bản trong Kotlin (mà thực ra là trong mọi ngôn ngữ lập trình). Các bạn cũng có kiến thức về mảng, danh sách, cách thức làm việc với chúng trong Kotlin. Yeah, bắt đầu nhé!
[toc]
Biến và hằng số
Biến
Trong Kotlin, chúng ta dùng từ khoá var để khai báo 1 biến và dùng từ khoá val để khai báo 1 hằng. Biến có thể thay đổi được giá trị còn hằng số thì không. Ví dụ, ta có thể khai báo biến như sau:
var myName:String = "Duong Vu"
var myAge:Int = 25
var isMeGay:Boolean = false
Ở trên đây mình đã khai báo các biến myName, myAge, isMeGay. Mỗi biến đều được khai báo kiểu dữ liệu và giá trị ban đầu của nó. Chắc các bạn cũng dễ dàng nhận thấy cú pháp khai báo biến sẽ là:
var tên_biến:kiểu_dữ_liệu = giá_trị_khởi_tạo
Cách khai báo biến này cũng tương tự với cách khai báo bên Java:
Tuy nhiên ở bên Kotlin có 1 sự tiện lợi hơn Java, đó là khi khai báo biến ta có thể không cần chỉ ra kiểu dữ liệu. Ví dụ như sau:
var myName = "Duong Vu" //biến myName sẽ được hiểu là kiểu String và có giá trị là Duong Vu
var myAge = 25 // biến myAge sẽ được hiểu là kiểu Int và có giá trị là 25
var isMeGay = true //biến isMeGay sẽ được hiểu là kiểu Boolean và có giá trị là false
Có nghĩa là khi ta khai báo biến có giá trị khởi tạo, Kotlin sẽ tự động gán kiểu cho biến dựa vào giá trị khởi tạo đó.
Hằng số
Hằng số hoàn toàn tương tự như biến số. Chỉ khác là chúng không thể thay đổi giá trị như biến số. Hằng số được khai báo bởi từ khoá val:
val pi = 3.14f
val daysOfWeek = 7
val hoursOfDay = 24
Lưu ý: nếu bạn cố thay đổi giá trị của 1 hằng số, bạn sẽ nhận được thông báo sau: Val cannot be reassigned (hằng số không thể được gán lại gía trị). Ví dụ thế này
val pi = 3.14f
pi = 6.28f
Bạn sẽ nhận ngay thông báo lỗi từ IDE. Hãy tự thử nghiệm thêm nhé!
Các kiểu dữ liệu cơ bản
Kiểu dữ liệu số
Trong Kotlin có nhiều kiểu dữ liệu để biểu diễn số. Nhưng về cơ bản cũng tương tự Java thôi. Kotlin cung cấp những kiểu dữ liệu số sau:
Các kiểu số nguyên
Long – 64 bit
Int – 32 bit
Short – 16 bit
Byte – 8 bit
Các kiểu số thực
Double – 64 bit
Float – 32 bit
Ví dụ:
var varInt = 63
var varLong = 4L
var varFloat = 9.32F
var varDouble = 55.55
var varBinary = 0b000111
var varHexadecimal = 0x1F
Lưu ý: Khi khởi tạo 1 biến số thực, mặc định Kotlin sẽ hiểu biến đó có kiểu Double. Ví dụ:
var pi = 3.4 //Khi này biến pi được hiểu là kiểu Double
Nếu muốn khởi tạo 1 biến dạng Float ta cần thêm ký tự f hoặc F đằng sau giá trị:
var pi = 3.4f //Khi này biến pi được hiểu là kiểu Float
Tương tự với biến số nguyên, mặc định sẽ được hiểu là kiểu Int:
var year = 2018 // Khi này biến year được hiểu là kiểu Int
Nếu muốn đưa nó về dạng long, ta thêm ký tự L sau giá trị:
var year = 2018L // Khi này biến year được hiểu là kiểu Long
Chuyển đổi giữa các kiểu dữ liệu số
Tất cả các kiểu dữ liệu số đều được cung cấp các hàm để chuyển đổi từ kiểu dữ liệu này sang kiểu dữ liệu khác. Ví dụ:
var myInt = 100 // Khởi tạo biến myInt với giá trị 100
var myDouble = myInt.toDouble() //chuyển đổi sang kiểu Double
var myLong = myInt.toLong() //chuyển đổi sang kiểu Long
var myFloat = myInt.toFloat() //chuyển đổi sang kiểu Float
var myByte = myInt.toByte() //chuyển đổi sang kiểu Byte
Như vậy mình có thể convert 1 biến từ kiểu này sang kiểu kia 1 cách dễ dàng.
Lưu ý: Ta không thể trực tiếp gán giá trị của 2 biến khác kiểu như sau:
val myInt = 100
val myLong: Long = myNumber // lỗi: Type mismatch
Kiểu dữ liệu Boolean
Kiểu Boolean trong Kotlin hoàn toàn giống với Java. Giá trị của kiểu dữ liệu này là true hoặc false. Các toán tử đối với kiểu Boolean cũng hoàn toàn giống Java:
|| (hoặc)
&& (và)
! (phủ định)
Ví dụ:
val myTrue = true
val myFalse = false
val a = 1
val b = 3
val c = 4
val d = 6
val result = a < b && d > c // result có giá trị true
Kiểu dữ liệu String
String biểu diễn dữ liệu dạng chuỗi ký tự. Trong Kotlin có 2 dạng String.
Dạng thông thường: các ký tự trong String đc biểu diễn trong cặp ngoặc kép, dạng này khá giống với String trong Java:
var myName = "My name is Duong Vu"
Khi muốn hiển thị các ký tự đặc biệt ,ví dụ như xuống dòng, ta phải dùng cách sử dụng ký hiệu. Ví dụ để tạo 1 string chứa 3 dòng ta phải làm như sau:
var myString = "This is first line\nThis is second line\nThis is first line"
println(myString)
Lưu ý: Ở trên mình đã sử dụng câu lệnh println để in ra giá trị của chuỗi myString trên console. Hàm println có thể in ra giá trị của tất cả các biến, không riêng gì biến kiểu String.
Kết quả in ra ở console sẽ là:
This is first line
This is second line
This is first line
Như mọi người thấy ta phải dùng \n để thay cho ký tự xuống dòng. Nhưng với dạng String thứ 2 thì khác.
Dạng thứ 2: các ký tự trong String được biểu diễn trong cặp dấu nháy 3 “””. Ví dụ:
var text = """
this is first line
this is second line
this is third line
"""
println(text)
Kết quả:
this is first line
this is second line
this is third line
Với dạng này ta có thể sử dụng xuống dòng, tab hay bất kỳ 1 ký tự đặc biệt nào 1 cách thoải mái. Cứ như kiểu ta đang soạn thảo văn bản vậy :3
String template
Nếu trong Java, để hiển thị giá trị của 1 biến số trong 1 chuỗi thì ta phải dùng phép cộng chuỗi hoặc String.format. Thì ở Kotlin, mọi việc đơn giản và trực quan hơn rất nhiều. String trong Kotlin cho phép ta gắn giá trị của 1 biến vào thân chuỗi chỉ với ký tự $. Ví dụ:
var numberOfApples = 4
var numberOfBananas = 5
var numberOfOrange = 2
var fruitDescription = "There are $numberOfApples apples, $numberOfBananas bananas, $numberOfOrange oranges"
print(fruitDescription)
Thế là giá trị của các biến numberOfApples ,numberOfBananas, numberOfOrangeđược gắn vào String cực kỳ gọn nhẹ. Ví dụ 2:
var numberOfRedCar = 2
var numberOfBlueCar = 3
var carDescription = "There are ${numberOfBlueCar+numberOfRedCar} cars"
print(carDescription)
Ví dụ này cho thấy, khi muốn biểu diễn giá trị của 1 biểu thức (hoặc là hàm số) thì biểu thức (hàm số) đó phải được bao bởi cặp {}. Như ví dụ trên mình đã dùng ${numberOfBlueCar+numberOfRedCar} để biểu diễn tổng của 2 biến numberOfBlueCar và numberOfRedCar đó. Ví dụ nữa :
var myString = "Hello, I am Mr.Rain"
print("String length = ${myString.length}")
Kiểu dữ liệu mảng
Mảng (Array) là 1 tập hợp các phần tử. Trong Kotlin có 2 cách để tạo ra mảng, đó là sử dụng phương thức
arrayOf()
hoặc dùng hàm khởi tạo:
Array()
Ví dụ, ta thử tạo 1 mảng chứa các số nguyên và số thực sử dụng phương thức arrayOf()
val firstArray = arrayOf(1, 3, 5, 7, 9, 11f, 13f)
Ta vừa khởi tạo 1 mảng có số phần tử là 7 và các phần tử như trên. Nếu muốn tất cả các phần tử của mảng phải có cùng kiểu dữ liệu, ta cần khai báo kiểu dữ liệu bằng cách sau:
val intArray = arrayOf<Int>(4, 5, 7, 3, 1, 0)
Như ở ví dụ trên ta đã khai báo kiểu Int cho array cần khởi tạo. Có 1 cách khác như thế này:
val intArray = intArrayOf(4, 5, 7, 3, 1, 0)
Kotlin cũng cung cấp cho ta các hàm để tạo mảng chứa kiểu dữ liệu cơ bản khác:
Giờ ta sẽ thử dùng hàm khởi tạo Array() để tạo ra 1 mảng. Hàm này yêu cầu truyền vào size (số phần tử) và 1 lambda function. Mình sẽ tìm hiểu về lambda function trong những bài viết sau, giờ ta chỉ cần hiểu đơn giản đó là 1 hàm không có tên, và thực hiện thao tác với tham số đầu vào là chỉ số của mảng:
val numbersArray = Array(4, { i -> i * 3 })
Trong đoạn code trên, ta đã truyền vào size của mảng là 4. Và 1 lambda function sử dụng tham số đầu vào là chỉ số của mảng để tính toán giá trị của phần tử ứng với chỉ số đó (giá trị bằng 3 lần chỉ số). Mảng numbersArray trên có cùng giá trị với mảng:
val numbersArray = arrayOf<Int>(0, 3, 6, 9)
Đơn giản đúng không?
Comment – Chú thích
Comment là những đoạn code không được biên dịch, có vai trò ghi chú, chú thích trong code. Comment trong Kotlin giống hệt với Java:
/*
This is a multiple lines comment
This is first line.
This is seconde line
*/
// 1 line comment
Kết luận
Ở bài này mình đã giới thiệu về biến, hằng số, các kiểu dữ liệu cơ bản của Kotlin, mảng, comment. Bài sau mình sẽ giới thiệu 1 kiến thức cực kỳ thú vị (và quan trọng) trong lập trình Kotlin. Đó là cách kiểm tra biến null an toàn trong Kotlin. Các bạn hãy đọc và cho ý kiến nhé.
Chào mọi người, mình là Dương Vũ. Hôm nay mình sẽ viết bài đầu tiên trong loạt bài hướng dẫn lập trình Kotlin, sử dụng trong quá trình phát triển ứng dụng Android. Đây sẽ là loạt bài đầu tiên mình chia sẻ đến những ai yêu thích lập trình di động. Các kiến thức trong đây có thể sẽ mới mẻ, cũng có thể sẽ đơn giản đối với một số người đã trải qua. Vậy hãy cùng mình học tập, giúp đỡ và chia sẻ đến những người có cùng đam mê, sở thích về phát triển ứng dụng nhé.
[toc]
Tại sao lại có loạt bài này
Mình nhận thấy Kotlin là 1 ngôn ngữ cực kỳ hay và thú vị. Giữa hàng trăm hàng nghìn bài hướng dẫn về lập trình Android ngoài kia, mình chưa tìm ra 1 loạt bài nào giới thiệu bài bản, có lộ trình và dễ hiểu để cho người mới có thể nắm bắt. Có thể có những bài hướng dẫn về lập trình Android sử dụng Kotlin, nhưng rất ít bài hướng dẫn về những điều cốt lõi của ngôn ngữ này. Thế nên mình quyết định tạo ra loạt bài viết Hướng dẫn ngôn ngữ lập trình Kotlin. Loạt bài này sẽ đảm bảo cho bạn những kiến thức cốt lõi, quan trọng nhất để bạn có thể sử dụng trong phát triển ứng dụng Android nói riêng và các nền tảng khác nói chung. Và nó cũng hướng cho bạn cách học và cách đào sâu nghiên cứu, mở rộng cho ngôn ngữ này. So, let’s start!!!
Loạt bài này hướng đến ai
Nó hướng đến những người phát triển ứng dụng Android, muốn “chuyển giao công nghệ” từ Java sang Kotlin.
Hướng đến những bạn muốn học lập trình Android, mà chưa cả biết Java là gì. Yes!!! Các bạn có thể nhảy ngay vào Kotlin, hoàn toàn không có trở ngại gì cả.
Hướng đến … mình. Mình thực sự thích viết, đó là sở thích lớn của mình, chưa kể viết sẽ làm mình trau dồi thêm đc kha khá kiến thức, hehe :))
Nội dung của loạt bài hướng dẫn ngôn ngữ lập trình Kotlin
15 bài hướng dẫn cover toàn bộ kiến thức cốt lõi của ngôn ngữ lập trình Kotlin, giúp bạn có đủ kiến thức để bay vào dự án thực tế 1 cách tự tin và dễ dàng. Vì chỉ có 15 bài thôi nên mỗi bài sẽ có độ dài tương đối, các bạn hãy chịu khó theo dõi nhé.
Do bài viết hướng đến cả những người mới bắt đầu, nên đôi chỗ có thể giải thích hơi kỹ càng quá (đối với những người đã là dev có kinh nghiệm), nên chỗ nào các bạn thấy dễ quá, hay dài vl, thì xin các bạn đừng ném gạch, mà hãy next qua phần tiếp theo :)) Thanks
Loạt bài này được viết theo ngôn ngữ… đời sống. Tức là mình sẽ cố diễn giải vấn đề theo cách dân dã nhất, dễ hiểu nhất, chứ không sử dụng nhiều những từ ngữ mang tính học thuật, sẽ rất khó khăn cho ai mới tiếp xúc.
Phần sugguest, định hướng để các bạn tìm tòi thêm những kiến thức mới, nâng cao hơn, phục vụ cho dự án sau này.
Cách theo dõi loạt bài Kotlin sao cho hiệu quả nhất
Hãy cài IntelliJ IDEA
Như đã nói lúc đầu, bài viết này mình sẽ tập trung vào cốt lõi của ngôn ngữ Kotlin, và chỉ Kotlin mà thôi, không Android, không gì khác. Mình sẽ có riêng 1 loạt bài về hướng dẫn lập trình Android bằng Kotlin để vận dụng kiến thức thu được từ loạt bài này. Vì vậy ở trong những bài hướng dẫn của loạt bài này, mình sẽ không dùng Android Studio để hướng dẫn, mà thay vào đó sẽ dùng IntelliJ IDEA để code các demo. Tại sao? Bởi dùng Android Studio thì mình chỉ có thể tạo các dự án Android. Mà cứ mỗi lần muốn xem kết quả của 1 đoạn code, ta lại phải build nguyên 1 … con app! Rất mất thời gian.
Vì thế để đơn giản hóa mình sẽ sử dụng IntelliJ IDEA. IDE này cho phép ta tạo ra các project Kotlin. Đại khái là ta có thể dùng nó để xem kết quả của các đoạn code nhanh gọn đơn giản hơn, thay vì build nguyên 1 cái app. Các bạn hãy yên tâm vì nếu các bạn đã quen dùng AndroidStudio thì IntelliJ IDEA cũng có cách sử dụng hoàn toàn tương tự, giống đến 90%. Vì AS cũng build từ IntelliJ IDEA mà ra thôi. Nếu các bạn chưa biết cách cài đặt IDE này, hãy tham khảo bài viết Hướng dẫn cài đặt IntelliJ IDEA của mình nhé.
Hãy đọc thật kỹ
Mình sẽ viết rất kỹ, rất kỹ về từng vấn đề dù là nhỏ nhất. Vì vậy mỗi bài viết có thể khá dài. Tuy nhiên mình mong các bạn đừng bỏ qua chữ nào, bởi đằng sau mỗi đoạn text miên man đó là các kiến thức cốt lõi được diễn giải ra theo 1 cách dễ hiểu nhất (đối với những người mới). Nếu bạn đọc lướt qua, có thể bạn sẽ bỏ qua mất 1 phần kiến thức sâu hơn, nâng cao hơn mà mình muốn truyền đạt cho các bạn.
Hãy ứng dụng
Mặc dù đây mới chỉ là loạt bài giới thiệu về ngôn ngữ lập trình Kotlin, chúng ta sẽ không xây dựng app trong loạt bài này. Tuy nhiên mình muốn các bạn hãy lập tức ứng dụng những gì học được ngay khi đọc các bài viết. Hãy mở IDE lên và sẵn sàng gõ code. Chỉ có cách code thật nhiều mới có thể giúp chúng ta làm quen với 1 ngôn ngữ mới. Mình cũng xin báo trước rằng mình sẽ sử dụng rất, rất nhiều code để demo. Bởi theo mình nghĩ đó là cách đơn giản nhất giúp các bạn nhanh chóng hiểu được kiến thức. Các bạn cũng hãy tự xây dựng cho mình những đoạn code demo để ứng dụng kiến thức đã học nhé. Sẽ rất hiệu quả đấy!
Hãy chia sẻ
Hãy chia sẻ loạt bài đến những người mới bắt đầu. Những ai còn đang hoang mang giữa vô vàn kiến thức cả tiếng Anh lẫn tiếng Việt ngoài kia. Họ cần 1 lộ trình rõ ràng để làm mục tiêu học tập. Dù đã kiểm tra rất kỹ nhưng có thể ở đâu đó trong các bài viết, mình có sai sót. Hãy đọc và nếu thấy có sơ suất ở đâu, comment cho mình biết để mình cập nhật lại, để nội dung truyền tải được tốt hơn. Hãy cho đi, để được nhận lại.
Bắt đầu
Có thể các bạn sẽ tự hỏi rằng
Java ổn rồi ,cần thêm cái thứ Kotlin đó làm chi.
Thứ mới ra đó (Kotlin) chắc gì đã ổn định, Java thì best rồi, chả cần thiết phải mò vào Kotlin
Tao thích code Java, tao đã quen với nó, tao ghét tất cả mọi thứ khác!
Vân vân
Thì đúng, mình không phủ nhận những điều mà các bạn nghĩ ở trong đầu. Nhưng các bạn hãy thử nhìn vào những điểm tốt của Kotlin so với Java, rồi các bạn sẽ thấy, mình có lý do khi viết loạt bài hướng dẫn này.
Sự ngắn gọn
So với Java, Kotlin là vô cùng, vô cùng ngắn gọn. Bạn có thể hình dung, khi mà việc định nghĩa 1 class trong Java có thể tốn đến vài chục dòng hay cả trăm dòng code thì với Kotlin, ta chỉ tốn 1 dòng để làm điều tương tự. Mình sẽ ví dụ ngay đây. Sau đây sẽ là 1 class trong Java:
public class User {
String name;
int age;
String address;
String phoneNumber;
public User(String name, int age, String address, String phoneNumber) {
this.name = name;
this.age = age;
this.address = address;
this.phoneNumber = phoneNumber;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getPhoneNumber() {
return phoneNumber;
}
public void setPhoneNumber(String phoneNumber) {
this.phoneNumber = phoneNumber;
}
}
Trên đây là 1 class với 4 thuộc tính, hàm khởi tạo và các phương thức get, set cho các thuộc tính. Trong Kotlin nó sẽ như thế này:
data class User(var name:String,var age: Int,var address:String,var phoneNumber:String)
Vỏn vẹn 1 dòng duy nhất! Đó chính là sự khác biệt về sự ngắn gọn của Kotlin. Đây chỉ là 1 ví dụ. Trong các dự án thực tế ta sẽ còn gặp hàng trăm tình huống mà nếu sử dụng Kotlin, số dòng code phải viết có thể giảm đi đến 90%. Rất tuyệt đúng không. (mình sẽ viết những loạt bài về xây dựng các ứng dụng với quy trình như trong thực tế)
An toàn hơn với các đối tượng null
Như các bạn đã biết thì NullPointerException là 1 lỗi hay gặp nhất ở trong các dự án viết bằng Java. Java cho phép chúng ta gán giá trị null đến 1 đối tượng, nhưng khi ta truy xuất đến đối tượng đó, lỗi NullPointerException sẽ được bắn ra. Mình đã từng làm 1 dự án Android, khi update version mới cho app, mình đã quên không cập nhật đối tượng Java theo config mới trên server. Và kết quả là trong 2 ngày đã có hơn 5000 log crash được báo về hệ thống, tất cả đều là NullPointerException gây ra, bạn có thể hiểu được cảm giác thốn đến thế nào, khi có đến 95% người dùng app bị crash :-s Yeah, và Kotlin được thiết kế để giảm thiểu tối đa sự xuất hiện của cái Exception khốn nạn này 😀 Cực an toàn và tiện lợi, mình sẽ có riêng 1 bài về vấn đề này, các bạn hãy đón chờ nghe.
Hoàn toàn tương thích với Java
Yes! Bạn có thể làm 1 dự án với cả Java và Kotlin cùng 1 lúc. Kotlin được thiết kế để giao tiếp với Java 1 cách hoàn hảo. Bạn có thể sử dụng Java class trong Kotlin và ngược lại, cũng có thể sử dụng Kotlin class trong Java. Tuyệt đúng ko? Điều này có nghĩa là Kotlin có thể sử dụng tất cả các thư viện và framework Java hiện có. Điều này cũng có nghĩa là nếu bạn thích, bạn có thể mở rộng, phát triển dự án Java cũ với Kotlin rất dễ dàng.
Trên đây chỉ là 3 trong số rất nhiều điều hay và thú vị khác của Kotlin mà Java không có. Hãy cùng mình tìm hiểu kỹ hơn trong các bài viết loạt bài này nhé.
Như ở bài giới thiệu về loạt bài Kotlin, mình đã có nói là chúng ta sẽ sử dụng IntelliJ IDEA như 1 IDE chính để code các demo. Hôm nay mình sẽ hướng dẫn các bạn cài đặt và sử dụng IDE này 1 cách cơ bản. Qua bài viết này, các bạn sẽ được trang bị những kỹ năng sử dụng IDE. Những kỹ năng đủ để chúng ta sử dụng trong suốt loạt bài hướng dẫn Kotlin của mình.
[toc]
Cài đặt IntelliJ IDEA
Các bạn download file cài của IntelliJ IDEA tại trang chính thức của Jetbrains. Địa chỉ download:
Các bạn hãy download bản Community. Đây là bản miễn phí mà nhà phát hành cung cấp cho chúng ta để phát triển các dự án (trong đó có cả Kotlin). Còn bản Ultimate thì là bản cao cấp với nhiều tính năng hơn và phải trả phí. Mà ta thì không cần dùng đến những tính năng cao cấp (ta đang là beginner mà :D) nên không cần quan tâm đến Ultimate làm gì.
Sau khi download xong bộ cài các bạn hãy cài đặt như 1 phần mềm thông thường (ấn next – next -…. :D). Đối với các bạn dùng Windows, trong quá trình cài đặt sẽ có 1 bước các bạn cần lưu ý:
chọn .java .kt và download JRE
Ở mục Create Desktop Shortcut, các bạn dùng win bản bao nhiêu bit thì chọn bản tương ứng. Điều quan trọng ở đây là ta cần click chọn vào .java và .kt ở trong mục Create Associations. Như vậy ta mới có thể code được Java và Kotlin trên IDE này. Mình cũng khuyến khích các bạn tick chọn option Download and install JRE x86 by JetBrains. Đây là tùy chọn download JRE (Java Runtime Environment) của JetBrains – nhà phát triển ra IDE này. Điều này sẽ giúp IDE chạy 1 cách ổn định nhất.
Cài xong chạy IDE lên ta sẽ có thế này:
Chọn cấu hình setting cho IDE
Hãy tick chọn Do not import settings để sử dụng cấu hình mặc định của IntelliJ IDEA. Tiếp đó là tới phần chọn theme và các plugin cho IDE. Đây là các bước chỉ cần thực hiện duy nhất khi lần đầu bật IDE:
Chọn theme cho IntelleJ IDEA
Có 2 theme sáng và tối, các bạn tùy chọn theo sở thích. Mình thì mình thích theme sáng hơn. Chọn xong nhấn Next: Default plugins để qua bước tiếp theo.
Tùy chọn disable 1 số plugin
Đây là bước cho phép ta disable 1 số plugin (nếu muốn). Mặc định thì các plugin này đều được bật. Ta có thể Next luôn cho nhanh:
Ấn nút Start using IntelliJ IDEA để bắt đầu
Bước này thực chất là IDE giới thiệu ta 1 số plugin hay ho. Nhưng ta cũng không cần đến chúng nên sẽ nhấn Start using IntelliJ IDEA để bắt đầu làm việc.
Tạo 1 dự án Kotlin mới
Màn hình bắt đầu của IDE
Đây là màn hình đầu tiên mỗi khi chạy IDE, để ta có thể tạo project mới hay mở các project đang làm dở. Giờ ta hãy ấn vào Create New Project để tạo 1 project mới:
Tạo project Kotlin mới
Các bạn chọn như hình: loại Project là Kotlin/JVM.
Chọn đường dẫn JDK
Đến bước này, các bạn điền tên, chọn vị trí lưu trữ source của dự án. Nếu ta chưa chọn đường dẫn JDK, ta sẽ phải trỏ đến đường dẫn thư mục chứa JDK để sử dụng cho dự án. Nếu các bạn chưa cài thì các bạn phải download và cài đặt JDK. Nếu các bạn chưa biết cách cài đặt JDK, hãy tham khảo bài viết của mình. Xong xuôi nhấn Finish để khởi tạo dự án.
Các thao tác cơ bản khi làm việc trong dự án
Tạo file source code
Đây là giao diện làm việc khi khởi tạo xong 1 dự án. Trong loạt bài hướng dẫn về Kotlin này, các file source code mình chủ yếu lưu trong thư mục src (như mình đã trỏ vào ở hình trên). Ta có thể tạo file/class mới bằng cách trỏ vào thư mục src, click chuột phải, và chọn New – New Kotlin File/Class
Tạo file/class mới
Sau đó chọn kiểu File hoặc Class và điền tên cho File (class) mới tạo:
Tạo file mới
Kết quả, ta đã tạo được file Main.kt, nó đã xuất hiện dưới thư mục src:
Tạo file mới thành công
Build dự án
Đầu tiên, để hướng dẫn các bạn cách build dự án, mình sẽ thêm 1 chút code vào file Main.kt mới tạo. Các bạn chưa cần hiểu cấu trúc của đoạn code đó làm gì, việc tìm hiểu đó mình sẽ làm sau. Đơn giản đó là đoạn code hiển thị ra console 1 dòng chữ thôi. Giờ hãy copy code của mình vào file vừa mới tạo:
fun main(args:Array<String>){
println("Hello world from Kotlin")
}
Yeah, có vẻ nguy hiểm đó. Giờ ta sẽ build và xem kết quả. Nhấn chuột phải vào vùng soạn thảo code rồi chọn Run MainKt:
Hoặc có cách khác nhanh hơn là nhấn tổ hợp phím Ctrl + Shift + F10. Lúc này IDE sẽ build code của chúng ta. Hãy chờ chút rồi xem kết quả.
Lưu ý rằng lần đầu tiên build code có thể sẽ hơi lâu 1 chút, những lần sau sẽ rất nhanh.
Và nhìn xuống vùng console, ta thấy kết quả đã được in ra:
Kết quả hiện ra ở console
Vậy là ta build dự án thành công và hiển thị được dòng chữ Hello world from Kotlin ở console.
Cài đặt phím tắt
Trong quá trình làm việc, sẽ nhanh và tiện lợi hơn nếu ta sử dụng các phím tắt. Để thiết lập phím tắt, Chọn menu File -> Setting, hộp thoại Setting hiện ra, chọn Keymap:
Thiết lập phím tắt
Ở đây các bạn sẽ tha hồ tìm hiểu và thiết lập các phím tắt riêng phù hợp với sở thích của mình. Tuy nhiên cũng có thể thiết lập theo 1 số mẫu có sẵn. Các bạn nhìn lên mục Keymap, chọn menu sổ xuống sẽ hiện ra rất nhiều tùy chọn cho chúng ta. Ta có thể thiết lập phím tắt giống như của bên Eclipse, JBuilder, Netbean, Visual Studio,…
Rất rất nhiều. Nếu bạn đã quen với 1 IDE nào đó trước, hãy sử dụng luôn bộ phím tắt của IDE đó luôn cho nhanh. Mình thì dùng của Eclipse.
Kết luận
Việc cài đặt và sử dụng IntelliJ IDEA khá đơn giản và dễ dàng, nhất là đối với các bạn đã làm qua với Android Studio. Vì thực chất Android Studio là 1 bản build riêng biệt từ IntelliJ IDEA. Thậm chí ta có thể cài đặt plugin Android vào IntelliJ IDEA để code Android mà không cần tới Android Studio. Nói như vậy để các bạn hiểu, cách sử dụng 2 IDE này là hoàn toàn tương tự. Hy vọng qua bài viết này các bạn đã biết được cách cài đặt và sử dụng cơ bản IntelliJ IDEA để phục vụ cho các bài học Kotlin mà mình sẽ cung cấp. Cảm ơn đã theo dõi, hẹn gặp lại 😉