ยังคงใช้ Java เพื่อพัฒนาแอพ Android ของคุณหรือไม่ ลอง Kotlin แทน

Kotlin ได้รับการพัฒนาอย่างมากในช่วง 2 ปีที่ผ่านมา โดยเป็นหัวข้อที่กำลังเป็นที่นิยมในทุกที่และความนิยมยังคงเพิ่มขึ้น และยังเป็นทางการอีกด้วยว่า Google ได้ผลักดันให้ Kotlin เป็นภาษาทางการสำหรับการพัฒนาแอพ Android

แต่ถึงอย่างนั้น ผู้คนจำนวนมากยังคงชอบ Java มากกว่า Kotlin สำหรับการพัฒนา Android เหตุใดจึงเป็นเช่นนั้น สาเหตุหลักประการหนึ่งก็คือผู้คนยังคงไม่สบายใจในการเปลี่ยนภาษาหลักที่เลือกจาก Java เป็น Kotlin ผู้คนกลัวที่จะเปลี่ยนไปเป็นสิ่งใหม่

เริ่มใช้ Kotlin ทันที วิธีที่ง่าย

ในความเป็นจริง มันง่ายมากที่จะเปลี่ยนมาใช้ Kotlin จาก Java เนื่องจากเป็นภาษาที่ยืดหยุ่นมาก คุณสามารถเขียนโค้ด Kotlin ได้ง่ายๆ แต่โดยปริยาย มันคือ Java!

ต่อไปนี้คือสิ่งที่ควรสังเกตเมื่อเปลี่ยนไปใช้ Kotlin จาก Java:

1. การทำงานร่วมกันของ Java
Kotlin สามารถทำงานร่วมกันได้อย่างสมบูรณ์กับ Java และในทางกลับกัน หมายความว่าอย่างไร หมายความว่า Kotlin ของคุณสามารถเรียกโค้ด Java ของคุณได้ มันทำให้การโยกย้ายแอปเป็นเรื่องง่ายมาก คุณเขียนโค้ดด้วย Java ไปแล้วครึ่งทางแล้วใช่หรือไม่ ไม่เป็นไร รหัส Kotlin อยู่ดี

2. ไม่มีประเภทข้อมูลพื้นฐานอีกต่อไป
อย่าลืมว่าเมื่อเลือกใช้ int หรือ Int ใน java จะใช้เวลาครึ่งวัน? Kotlin ไม่มีประเภทข้อมูลพื้นฐานอีกต่อไปแล้ว ทุกอย่างถูกรวมไว้ใน Object แทน

3. ไวยากรณ์ที่เปลี่ยนไปเล็กน้อย (แต่ไม่ต้องกังวลว่าจะสามารถติดตามได้ง่าย)
ไวยากรณ์หลายอย่าง เช่น การประกาศตัวแปร ฟังก์ชัน และคลาส มีการเปลี่ยนแปลงเล็กน้อย แต่ถ้าคุณมาจากพื้นหลัง OOP เช่น Java จะไม่เป็นปัญหาดังกล่าว และยังลบคำหลักที่เป็นโมฆะและเซมิโคลอน (';') ออกแล้ว ขอบคุณ Kotlin สำหรับการลบอัฒภาคนั้น!!
ฉันจะนำเสนอตัวอย่างพื้นฐานเกี่ยวกับคลาส Android:

//Inheritance and implementation is using ':' now
class BasicActivity : AppCompatActivity() {
    //variables declaration is now variable name first then type
    var a :Int = 10 //var is for mutable
    val b :Int = 15 //val is for immutable

    /*lateinit keyword must be added for initialisation of non-
    primitive type without initial value in Kotlin*/
    lateinit var someTextView:TextView

    //Also, no more new keyword here
    var gameList:List<Integer> = ArrayList()

    //overriding is using keyword instead of 
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_basic)
    }
}

4. การอนุมานประเภท
Kotlin จะทำให้ชีวิตง่ายขึ้นด้วยการอนุมานประเภทสำหรับตัวแปร:

var a = 5 //will automatically infer this as integer
var b = "John" // will automatically infer this as String

5. ไม่มีการตรวจสอบความปลอดภัย
Kotlin ได้จัดให้มีการตรวจสอบความปลอดภัยเป็นโมฆะเพื่อหลีกเลี่ยงข้อยกเว้นตัวชี้ค่าว่าง ทุกตัวแปรที่อาจคืนค่า null จะถูกทำเครื่องหมาย (และต้องทำเครื่องหมาย) ด้วย ? เข้าสู่ระบบ.

var a:String? = null
var b:String = null //not allowed 

นอกจากนี้ยังมีการเรียกความปลอดภัยเป็นโมฆะเพื่อหลีกเลี่ยงข้อยกเว้น Null-Pointer (ข้อผิดพลาดของ Java Billon Dollar)

//not allowed, a might be null
a.function() 

// this will not throw null pointer, instead will continue the flow
a?.function()

//force function call, can cause NPE, use this only if 100% sure that this value will not be null
a!!.function()

6. ไม่มีคำหลักคงที่อีกต่อไป
คีย์เวิร์ดสแตติกถูกแทนที่ด้วยคีย์เวิร์ด Object ทั้งสำหรับคลาสและเมธอด โดยเฉพาะอย่างยิ่ง Companion Object สำหรับเมธอด

7. เปลี่ยนเคสที่แก้ไขแล้ว
Switch case ได้รับการแก้ไขเป็นคำสำคัญใหม่ เรียกว่า when ซึ่งดูสะอาดตาและยืดหยุ่นมากขึ้น:

when (x) {
    1 -> println("One")
    2 -> print("Two")
	else -> print("Others")
}

8. ไม่มีการตรวจสอบข้อยกเว้นอีกต่อไป
จำได้ไหมว่าตอนที่คุณกำลังดำเนินการหรือแคสต์ใน Java และคำเตือนสีแดงนั้นออกมาและบอกให้คุณเพิ่มการตรวจสอบข้อยกเว้นที่นั่น? มันถูกลบไปแล้วใน Kotlin ตอนนี้ IDE ของคุณจะไม่บังคับให้คุณทำข้อยกเว้นอีกต่อไป!!

นั่นคือทั้งหมดสำหรับส่วนที่คุณต้องเริ่มพัฒนาใน Kotlin แต่เป็นภาษา Java
การเข้า Kotlin ไม่ใช่เรื่องยากเลยใช่ไหม? ตอนนี้ Kotlin ไม่ได้แตกต่างจาก Java มากนัก

คุณลักษณะที่จัดเตรียมโดย Kotlin

ตอนนี้ หลังจากที่ได้พิจารณาความแตกต่างของ Kotlin และ Java แล้ว เรายังต้องดูคุณลักษณะที่ Kotlin จัดเตรียมไว้ให้และวิธีเริ่มทำ Kotlin แบบช้าๆ ตามแนวทางของ Kotlin:

1. ความยืดหยุ่น
เหตุผลหลักประการหนึ่งที่ทำให้ฉันรัก Kotlin คือความยืดหยุ่นของภาษา คุณเป็นคนเจ้าระเบียบ OOP หรือไม่? คุณอยากลองใช้ Functional Programming ซึ่งกำลังเป็นประเด็นร้อนอยู่หรือเปล่า? และสำหรับความรักใน การเข้ารหัส พระเจ้า คุณสามารถทำได้ทั้งสองอย่างใน Kotlin! แม้จะไม่ได้ให้ฟีเจอร์ทั้งหมดที่ FP มีให้อย่างเต็มที่ แต่ก็ดีพอที่จะรองรับได้

2. การสนับสนุนแลมบ์ดา
ใช่ ฉันรู้ว่าตอนนี้ Java 8 รองรับแลมบ์ดา แต่ Kotlin มาก่อนในเรื่องนี้และทำงานได้ดีมากในเรื่องนั้น แน่นอนว่าการเปลี่ยนไปใช้ Lambda Function ในตอนแรกอาจเป็นเรื่องยาก แต่อย่างที่กล่าวไว้ Kotlin มีความยืดหยุ่นในเรื่องนี้ เฮ้ มันเป็นสายของคุณแล้ว!
ไลบรารี Android บางตัวได้เปิดใช้งานการรองรับ Lambda เช่น View.OnClickListener (หากคุณมาจากพื้นหลังของ Android ฉันแน่ใจว่าวิธีนี้คุ้นเคยกับคุณอยู่แล้ว) :

val randomButton : Button

//using lambda function as argument
randomButton.setOnClickListener{v -> doRandomStuff(v) }

3. คลาสข้อมูล
Kotlin ได้จัดเตรียมการแทนที่สำหรับคลาส Model/Entity ที่เรียกว่า Data class มันขจัดความจำเป็นใน setter getter ที่ซ้ำซ้อน และยังมี method ที่เท่ากันและฟังก์ชัน toString ในตัวโดยที่คุณไม่ต้องสร้างมันขึ้นมา นอกจากนี้ยังใช้งานง่ายมาก:

data class Person(
    val id:String,
    val name:String = "John Doe" //Default Value
)

//Initialisation block
var person = Person("id","Not John")

4. ฟังก์ชันส่วนขยาย
Kotlin อนุญาตให้ใช้ฟังก์ชันส่วนขยาย ซึ่งทำให้โค้ดอ่านง่ายขึ้น นอกจากนี้ยังช่วยให้คุณสามารถมอบฟังก์ชันการทำงานให้กับคลาสโดยไม่ต้องแก้ไขคลาสเอง:

fun Int.superOperation(anotherInt:Int):Int {
    val superNumber = this * anotherInt + anotherInt
    return superNumber
}

//you can now call the functions
val someNumber = 5
val superNumber = someNumber.superOperation(10) //65

5. อาร์กิวเมนต์ที่มีชื่อและค่าเริ่มต้น
เช่นเดียวกับ C # Kotlin ยังรองรับพารามิเตอร์ที่มีชื่อและค่าเริ่มต้นสำหรับวิธีการ ไม่จำเป็นต้องส่งผ่านค่าในแต่ละอาร์กิวเมนต์โดยสิ้นเชิง คุณสามารถเลือกค่าที่คุณต้องการแก้ไขและ voila! ไม่ต้องยุ่งยากอีกต่อไปในการส่งผ่านค่าเดิมสำหรับการเรียกใช้ฟังก์ชัน 10 ครั้ง!

//variable declaration
fun someOperations(var x: Int, var y:Int, var z:Int = 1){
	return x+y+z
}

someOperations(1,2) //return 4
someOpeartions(y = 1, x = 1) //return 3

6. ความเท่าเทียมกันในการอ้างอิง
Kotlin ยังมาพร้อมกับความเท่าเทียมกันในการอ้างอิง ('===') ซึ่งจะตรวจสอบว่ามีตัวแปรสองตัวที่อ้างอิงถึงวัตถุเดียวกันหรือไม่

var a = 10
var b = 10
a == b //true
a === b //true also, primitive type object equation will only check its value

data class Person (val name: String)

val p1 = Person("John")
val p2 = Person("John")

p1 == p2 //true
p1 === p2 //false

7. การแคสต์อัจฉริยะ
แทนที่จะใช้อินสแตนซ์ของ Kotlin ตอนนี้ให้ไวยากรณ์ที่อ่านง่ายกว่าและอ่านง่ายกว่าเพื่อใช้สำหรับการแคสต์หรือการตรวจสอบประเภท:

//type checking
//kotlin smart cast mechanism will also automatically change the object into corresponding type if it passes the type checking
if (shape is Circle) {
    println(“it’s a Circle”)
    shape.radius //automatically be casted as Circle
} else if (shapeObject is Square) {
    println(“it’s a Square”)
} else if (shapeObject is Rectangle) {
    print(“it’s a Rectangle”)
}

Kotlin ยังมี as คีย์เวิร์ดเพื่อเปิดใช้งานการแคสต์อย่างชัดแจ้ง:

//It's considered unsafe since it behaves simillarly like static casting
var anotherShape = shape as Circle

//This can be used instead for safe casting
var safeShape = shape as? Circle

8. คอรูทีน
การโทรแบบอะซิงโครนัสเป็นเรื่องยุ่งยากใน Java มาโดยตลอด การทำ Thread นั้นใช้พื้นที่โค้ดมากและทำให้ไม่สามารถอ่านโค้ดได้ Coroutines ถูกสร้างขึ้นมาเพื่อแทนที่การทำงานของเธรดแบบเดิม ทำให้ได้โค้ดที่สะอาดและมีประสิทธิภาพ:

import kotlinx.coroutines.*

fun main() {
    // launch a new coroutine in background and continue
    GlobalScope.launch { 
        // non-blocking delay for 1 second (default time unit is ms)
        delay(1000L) 
        
        // print after delay
        println("World!") 
    }
    // main thread continues while coroutine is delayed
    println("Hello,") 
    
    // block main thread for 2 seconds to keep JVM alive
    Thread.sleep(2000L) 
}

Coroutines ยังรองรับการทำงานที่ซับซ้อนมากขึ้น เช่น การเข้าร่วมงาน ช่อง บริบทที่ใช้ร่วมกัน และผู้ปกครอง สามารถอ่านรายละเอียดและการใช้งานเพิ่มเติมได้ที่นี่

ปิดท้าย

โดยสรุปแล้ว เริ่มใช้ Kotlin ได้ง่ายมาก คุณสามารถเขียนโค้ด Kotlin ได้เหมือนกับที่คุณเขียนโค้ด Java นอกจากนี้ Kotlin ยังได้จัดเตรียมคุณลักษณะหลายอย่างที่ช่วยให้คุณได้เปรียบในการใช้ Java

แน่นอนว่า Java ยังคงแข็งแกร่งอยู่ในขณะนี้ แต่การเริ่มเรียนรู้สิ่งใหม่ๆ ก็ไม่ผิด เราในฐานะโปรแกรมเมอร์จำเป็นต้องเปิดรับการเรียนรู้ตลอดชีวิตและไม่หยุดเรียนรู้ สิ่งที่ดีที่สุดเกี่ยวกับ Kotlin คือความง่ายในการโยกย้ายจาก Java

ขอบคุณที่อ่าน. ฉันหวังว่าคุณจะสนุกและหวังว่าจะเป็นประโยชน์! ขอให้โชคดีในการสำรวจ Kotlin แล้วพบกันใหม่