Kotlin และ Java มีความแตกต่างหรือไม่?

สวัสดีทุกคน. ฉันอยากจะบอกคุณเกี่ยวกับสิ่งพื้นฐานบางประการเกี่ยวกับภาษา Kotlin ซึ่งจะเป็นประโยชน์สำหรับผู้เริ่มต้น มันเกิดขึ้นจนตอนนี้การพัฒนา Android ด้วยภาษาเดียวเป็นเรื่องยาก - โปรเจ็กต์ใหม่ส่วนใหญ่เริ่มเขียนด้วย Kotlin โปรเจ็กต์สำเร็จรูปส่วนใหญ่เขียนด้วยภาษา Java ในขณะนี้ฉันมี 4 โปรเจ็กต์ในที่ทำงาน: สองโปรเจ็กต์ใน Kotlin และสองโปรเจ็กต์ใน Java (หนึ่งโปรเจ็กต์หลักขนาดใหญ่และโปรเจ็กต์เล็กสามโปรเจ็กต์สำหรับใช้ภายใน) เมื่อบริษัทตัดสินใจเขียนโปรเจ็กต์ใหม่ใน Kotlin การตัดสินใจครั้งนี้ดูแปลกสำหรับฉัน ทำไมต้องผสมภาษาต่างกัน? ให้คนอื่นเขียนด้วย Kotlin ทำไมเราถึงต้องการมัน? แต่ไม่มีทางออก ฉันจึงตัดสินใจลองใช้ภาษาใหม่และเริ่มศึกษามัน แน่นอนว่าโค้ดแรกเขียนในรูปแบบ Java ทั้งหมด ซึ่งทำให้เกิดความเข้าใจผิดเพิ่มเติม: เหตุใดฉันจึงต้องมีภาษาใหม่ แต่เมื่อฉันใช้มันฉันก็พบข้อดีมากขึ้นเรื่อย ๆ และตอนนี้ (ฉันเขียนด้วย Kotlin มาเกือบ 2 ปีแล้ว) พูดได้เลยว่า Kotlin สะดวกกว่าในการพัฒนา Android ฉันต้องการแสดงความแตกต่างบางอย่างที่จะไม่ชัดเจนสำหรับผู้ที่ตัดสินใจเริ่มเรียนรู้ Kotlin หลังจาก Java ฉันขอเตือนคุณด้วยว่า Android ใช้ Java 8 โดยเวอร์ชันปัจจุบันคือ 14 ดังนั้นก่อนอื่น - Variables : Java:

Int a = 1;
String s = "test";

คอตลิน:

val a = 1
var b = 2
val c: Int
val d = "test"

ตัวแปรใน Kotlin มีสองประเภท: val (อ่านอย่างเดียว) และ var (อ่าน-เขียน) ขอแนะนำให้ใช้ val ทุกครั้งที่เป็นไปได้ ไม่จำเป็นต้องประกาศประเภทของตัวแปรหากตัวแปรได้รับการเตรียมใช้งานแล้ว ประการที่สอง - if/else, switch คำสั่ง : คุณใช้ชุดคำสั่งนี้ใน Java บ่อยแค่ไหน:

if (вариант 1)
{...}
else if (вариант 2)
{...}
...
else
{...}

หรือเช่นนี้:

switch(выражениеДляВыбора) {
        case (meaning 1):
                Код1;
                break;
        case (meaning 2):
                Код2;
                break;
...
        case (meaning N):
                КодN;
                break;
        default:
                КодВыбораПоУмолчанию;
                break;
        }

ใน Kotlin ตัวดำเนินการ when ใช้สำหรับนิพจน์ดังกล่าว (แม้ว่าจะสามารถใช้ if/else ก็ได้):

val x = 5
val result = when(x) {
        0, 1 -> "cool"
        2 -> "bad"
        5 -> "normal"
        else -> "error"
}
System.out.println(result)

ที่นี่เราไม่เพียงแต่ผ่านห่วงโซ่ของเงื่อนไขเท่านั้น แต่ยังกำหนดนิพจน์ทั้งหมดให้กับตัวแปรผลลัพธ์ทันที ซึ่งช่วยให้เราประหยัดโค้ดได้ไม่กี่บรรทัด แต่ถึงกระนั้น หากคุณมีเพียงสองตัวเลือกในสาขาหนึ่ง ฉันขอแนะนำให้ใช้ if..else ปกติ เมื่อการก่อสร้างจะสั้นลงเพียงสามรูปแบบเท่านั้น เดินหน้าต่อไป - คอนสตรัคเตอร์ . มันเป็นเทพนิยายที่นี่ เพียงเปรียบเทียบโค้ดใน Java และ Kotlin ชวา:

public class Person {

    private String firstName;
    private String lastName;
    private int age;

    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

คอตลิน:

class Person(private val firstName: String,
             private val lastName: String,
             private var age: Int) {
}

อาจดูเหมือนว่ามีบางอย่างเหลืออยู่ในโค้ด Kotlin ที่ยังไม่เสร็จ แต่เปล่าเลย นี่เป็นรหัสสองรหัสที่เหมือนกันในภาษาต่างกัน ลองคิดดูหน่อย ใน Kotlin ตัวสร้างสามารถเขียนได้โดยตรงในเนื้อหาของชื่อคลาส (แต่ถ้าคุณต้องการ คุณสามารถทำได้ด้วยวิธีเก่า เช่นเดียวกับใน Java) ดังนั้นเราจึงเขียนตัวแปรสามตัว ใน Java เราได้สร้างตัวสร้าง ตัวรับ และตัวตั้งค่าหนึ่งตัวสำหรับตัวแปรอายุ อย่างที่เราจำได้ใน Kotlin ตัวแปร val เป็นแบบอ่านอย่างเดียว ดังนั้นจึงไม่มีตัวตั้งค่าสำหรับตัวแปรเหล่านี้ (Kotlin ใช้ getter-setters ภายใต้ประทุนนั้นเอง) ตัวแปร var ช่วยให้คุณใช้ตัวตั้งค่าได้ เป็นผลให้เราเขียนเกือบในหนึ่งบรรทัดสิ่งเดียวกับที่กินมากกว่าหนึ่งสิบบรรทัดใน Java ที่นี่ฉันแนะนำให้อ่านเพิ่มเติมเกี่ยวกับคลาสข้อมูลใน Kotlin แต่นั่นไม่ใช่ทั้งหมดที่ Constructors Kotlin จะเก่ง แต่ถ้าคุณต้องการตัวสร้างสองตัวล่ะ? แล้วถ้ามีสามล่ะ? ใน Java จะมีลักษณะดังนี้:

public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

public Person(String firstName) {
        this.firstName = firstName;
    }

ไม่มีอะไรซับซ้อน แค่มีนักออกแบบจำนวนมากเท่าที่จำเป็น นั่นคือสิ่งที่พวกเขาทำ ใน Kotlin คุณสามารถไปได้โดยใช้ Constructor เพียงตัวเดียว ยังไง? ง่ายมาก - ค่าเริ่มต้น

class Person(private val firstName: String,
             private val lastName: String? = null,
             private var age: Int = 5) {
}

เราได้กำหนดค่าเริ่มต้นในตัวสร้างและตอนนี้การเรียกพวกเขาจะมีลักษณะดังนี้:

Person(firstName = "Elon", lastName = "Mask", age = 45)
Person(firstName = "Elon", age = 45)
Person(firstName = "Elon", lastName = "Mask")

คำถามอาจเกิดขึ้น: นี่คืออะไร:

private val lastName: String? = null

เครื่องหมายคำถามอื่นๆ เหล่านี้คืออะไร? ใช่ หากค่าสามารถเป็น null ได้ ก็จะถูก set นอกจากนี้?ยังมีตัวเลือกเช่นนี้ - !!(หากตัวแปรไม่สามารถยอมรับค่า null ได้) อ่านด้วยตัวเองมันง่ายมาก และเราไปยังจุดถัดไป ส่วนขยาย นี่เป็นเครื่องมือที่ยอดเยี่ยมมากใน Kotlin ที่ไม่มีใน Java บางครั้งในโปรเจ็กต์เราใช้วิธีการเทมเพลตที่ทำซ้ำในหลายคลาส ตัวอย่างเช่นเช่นนี้:

Toast.makeText(this, "hello world :)", Toast.LENGTH_SHORT).show();

ใน Kotlin เราสามารถขยายคลาสได้:

fun Context.toast(message: CharSequence) = Toast.makeText(this, message, Toast.LENGTH_SHORT).show()

จากนั้นใช้มันเช่นนี้ตลอดทั้งโครงการ:

context?.toast("hello world")

เราสร้างส่วนขยายสำหรับคลาสบริบท และตอนนี้ไม่ว่าบริบทจะเป็นอย่างไร วิธีการโทสต์แบบใหม่ก็จะพร้อมใช้งาน ซึ่งสามารถทำได้สำหรับคลาสใดก็ได้: สตริง, แฟรกเมนต์, คลาสที่คุณกำหนดเอง โดยไม่มีข้อจำกัด และจุดสุดท้ายที่เราจะดูคือการทำงานกับ Strings ทุกอย่างเรียบง่ายที่นี่ ใน Java มันเขียนดังนี้:

String s = "friends";
int a = 5;
System.out.println("I have" + a + s + "!");

มันง่ายกว่าใน Kotlin:

val s = "friends"
val a = 5
println("I have $a $s!")

นี่คือความแตกต่างที่ฉันพบเมื่อเริ่มเรียน Kotlin ฉันหวังว่าสิ่งนี้จะช่วยคุณได้