האם יש הבדל בין קוטלין לג'אווה?

שלום לכולם. אני רוצה לספר לכם כמה דברים בסיסיים על שפת Kotlin, שיהיו שימושיים למתחילים. במקרה שעכשיו יהיה קשה להיכנס לפיתוח אנדרואיד עם שפה אחת בלבד - רוב הפרויקטים החדשים מתחילים להיכתב בקוטלין, רוב הפרויקטים המוכנים נכתבים ב-Java. כרגע יש לי 4 פרויקטים בעבודה: שניים בקוטלין ושניים בג'אווה (אחד מרכזי אחד גדול ושלושה קטנים לשימוש פנימי). כשהחברה החליטה לכתוב פרויקטים חדשים בקוטלין, ההחלטה הזו נראתה לי מוזרה. למה לערבב שפות שונות? שמישהו אחר יכתוב בקוטלין, למה אנחנו צריכים את זה? אבל לא הייתה מוצא, אז החלטתי לנסות שפה חדשה והתחלתי ללמוד אותה. הקוד הראשון, כמובן, נכתב כולו בסגנון ג'אווה, מה שהוסיף עוד לאי ההבנה: למה אני צריך שפה חדשה? אבל ככל שהשתמשתי בו, מצאתי יותר ויותר יתרונות ועכשיו (אני כותב בקוטלין כבר כמעט שנתיים) אני יכול לומר שקוטלין נוח יותר בפיתוח אנדרואיד. אני רוצה להראות כמה ניואנסים שלא יהיו ברורים למי שהחליט להתחיל ללמוד קוטלין אחרי ג'אווה. הרשו לי גם להזכיר לכם שאנדרואיד משתמש ב-Java 8, כאשר הגרסה הנוכחית היא 14. אז, ראשית - משתנים : Java:

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

קוטלין:

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

ישנם שני סוגים של משתנים בקוטלין: val (לקריאה בלבד) ו-var (קריאה-כתיבה). מומלץ להשתמש ב-val במידת האפשר. אין צורך להצהיר על סוג המשתנה אם המשתנה כבר אותחל. שנית - if/else, switch statements : באיזו תדירות אתה משתמש בשרשרת ההצהרות הזו ב-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;
        }

בקוטלין, האופרטור 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. Java:

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, ניתן לכתוב את הבנאי ישירות בגוף שם המחלקה (אבל אם תרצו, תוכלו לעשות זאת בדרך הישנה, ​​כמו בג'אווה). אז, כתבנו שלושה משתנים, ב-Java יצרנו בנאי, getters ו-seter אחד למשתנה הגיל. בקוטלין, כזכור, משתנה val הוא לקריאה בלבד, ולכן הקובע למשתנים אלו אינו זמין (קוטלין מיישמת getter-seters מתחת למכסה המנוע עצמו). משתנה var מאפשר לך להשתמש במגדיר. כתוצאה מכך, כתבנו כמעט בשורה אחת את אותו דבר שלקח יותר מתריסר שורות בג'אווה. כאן אני ממליץ לקרוא עוד על שיעורי נתונים בקוטלין. אבל זה לא כל מה שקונסטרוקטורי קוטלין טובים בו. אבל מה אם אתה צריך שני בנאים? מה אם יש שלושה? ב-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;
    }

שום דבר מסובך, רק כמה מעצבים שצריך, זה מה שהם עשו. בקוטלין אפשר להסתדר עם קונסטרוקטור אחד בלבד. אֵיך? זה פשוט - ערכי ברירת מחדל.

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, אז הוא מוגדר ?.יש גם אפשרות כזו - !!(אם המשתנה לא יכול לקבל null). קרא על זה בעצמך, הכל פשוט. ונעבור לנקודה הבאה. הרחבות . זהו כלי מגניב מאוד בקוטלין שאינו זמין בג'אווה. לפעמים בפרויקט אנו משתמשים בשיטות תבנית שחוזרות על עצמן בשיעורים רבים. לדוגמה, כך:

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

בקוטלין נוכל להרחיב שיעור:

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

ולאחר מכן השתמש בו כך לאורך הפרויקט:

context?.toast("hello world")

עשינו הרחבה לשיעור ההקשר. ועכשיו בכל מקום שבו ההקשר זמין, שיטת הטוסט החדשה שלה תהיה זמינה. ניתן לעשות זאת עבור כל מחלקה: מחרוזת, פרגמנט, המחלקות המותאמות אישית שלך, אין הגבלות. והנקודה האחרונה שנסתכל עליה היא עבודה עם מיתרים . הכל פשוט כאן. בג'אווה זה כתוב כך:

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

זה יותר קל בקוטלין:

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

אלו הניואנסים שנתקלתי בהם בתחילת לימוד קוטלין, אני מקווה שזה יעזור לך.