KotlinRush: האם זה הגיוני להמשיך לכתוב בג'אווה?

שלום, תלמיד JavaRush, לפני שתיקלט לחלוטין ב-Java, ברצוני להרחיב את האופקים שלך ולמשוך את תשומת הלב לשפת Kotlin הפופולרית יותר ויותר ! Kotlin היא שפה צעירה למדי שפותחה על ידי JetBrains . כן, כן, אותה חברה שפיתחה את ה-IDE האהוב עלינו: IntelliJ IDEA. Kotlin היא שפת JVM ותואמת לחלוטין ל-Java , כלומר מקוד Kotlin ניתן לגשת בקלות לספריות Java מוכרות. מה לגבי ספריות: מחלקות Kotlin ו-Java יכולות להתקיים במקביל בחבילה אחת! קוטלין הייתה כל כך פופולרית בקרב קהילת המתכנתים שגוגל הכירה בה כשפת הפיתוח הרשמית לאנדרואיד, ולאחרונה החלה קוטלין לצבור פופולריות בפרויקטים ארגוניים. במאמר זה, ברצוני לתת מספר דוגמאות השוואתיות לקוד שנכתב ב-Kotlin וב-Java, ולהסיק כמה מסקנות. ללכת! נתחיל, כרגיל, עם "Hello World"

// Java
public class Application {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

// Kotlin
class Application
fun main(vararg args: String) {
    println("Hello World!")
}

בהסתכלות על הדוגמה של קוטלין, אנו יכולים לציין מיד את הדברים הבאים:

• אין צורך לכתוב נקודה-פסיק בסוף השורה;
• כל השיטות מתוארות על ידי מילת המפתח כיף ;
• כדי להדפיס שורה, מספיקה מילה אחת בלבד - println() !

יצירת מופע

// Java (до 10)
final Application application = new Application();

// Kotlin
val application = Application()

הבדלים בקוטלין:

• אין צורך להצהיר על סוג המשתנה אם הוא ברור מהמופע;
• במקום סוג המשתנה - val (בלתי ניתן לשינוי) או var (ניתן לשינוי);
• אינך צריך לכתוב את מילת המפתח החדשה כדי ליצור מופע !

תיאור השיטות

// Java
public int sum(int a, int b) {
    return (a + b);
}

// Kotlin
fun sum(a: Int, b: Int): Int {
return (a + b)
}

הבדלים בקוטלין:

• אם צריך להחזיר משהו משיטה, " : Int " מתווסף לחתימה, כאשר Int הוא סוג ההחזרה;
• תיאור פרמטרי השיטה: תחילה שם המשתנה ולאחר מכן הסוג;
• מכיוון שגוף השיטה מורכב משורה אחת בלבד, אתה יכול להשמיט את ההחזר :
  

  fun sum(a: Int, b: Int): Int = (a+b)

פלט מחרוזת מעוצב

// Java
public int sum(int a, int b) {
    int result = (a + b);
    System.out.printf("Сумма %d и %d равна %d\n", a, b, result);
    return result;
}

// Kotlin
fun sum(a: Int, b: Int): Int {
    val result = (a + b)
    println("Сумма $a и $b равна $result")
    return result
}

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

// Java
object1.equals(object2)

// Kotlin
object1 == object2

בקוטלין, ההשוואה " ==" לסוגי אובייקטים מתורגמת ל- equals! וכדי להשוות קישורים, ===נעשה שימוש ב" ". חריגים

// Java
public List<String> getFileContent(String file) throws IOException {
    Path path = Paths.get(file);
    return Files.readAllLines(path);
}

// Kotlin
fun getFileContent(file: String): List<String> {
    val path = Paths.get(file)
    return Files.readAllLines(path)
}

אין חריגים מסומנים ב-Kotlin ; כעת אינך צריך לזרוק חריג ללא סוף דרך היישום כולו או ליצור חריגים מרובי רמות try-catch. בטיחות אפס

// Java
public class Data {
    String value;

    String render() {
        if (value == null) {
            return "Value: undefined";
        } else {
            return "Value:" + value.toUpperCase();
        }
    }
}

// Kotlin
class Data {
    var value: String? = null
    fun render(): String =
            "Value: ${value?.toUpperCase() ?: "undefined"}"
}

קוטלין טיפל בבעיית ה-NPE והציג מספר דרישות:

• יש לאתחל את כל שדות המחלקה והמשתנים;
• אתה יכול לכתוב "null" בשדה או במשתנה, אבל אז עליך לומר במפורש שהמשתנה שלך הוא Nullable (כתוב את הסימן "?");
• המפעיל של אלביס "?:" עובד כך: אם יש Null בצד שמאל, קח את מה שמימין. במקרה של הדוגמה שלנו, כאשר משתנה הערך אינו מאותחל, הערך " undefined " יילקח.

שדות כיתה וגישה אליהם

// Java
public class Data {
    private String value;

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
}
class App {
    void execute() {
           Data data = new Data()
           data.setValue("Foo")
     }
}

// Kotlin
class Data {
    var value: String = ""
}
class App {
    fun execute() {
          val data = Data()
          data.value = "Foo" // Под капотом выполнится data.set("Foo")
     }
}

בקוטלין, מספיק פשוט לתאר שדה וזהו: יש לו כבר גטרים וקבעים מרומזים (שלום לומבוק ), שניתן לעקוף אותם בכל עת אם רוצים. במקביל, אנו קוראים ומשנים את הערך של השדה פשוט על ידי גישה ישירה אליו, ומתחת למכסה המנוע הוא נקרא get()|set(). מחזורים

// Java
void example() {
    for(int i = 1; i <= 10; i++) {
        System.out.println(i);
    }

    for(String line : "a,b,c".split(",")) {
        System.out.println(line);
    }
}

// Kotlin
fun example() {
    for(i in 1..10) {
        println(i)
    }

    for(line in "a,b,c".split(",")) {
        println(line)
    }
}

קוטלין סיפק תחביר נוח ואחיד למעבר רצפים: אתה פשוט משתמש במשתנה בצד שמאל , ברצף בצד ימין ובמילת המפתח " ביניהם ", הסוג נקבע אוטומטית לפי התוכן. קְלָף בּוֹדֵד

// Java
public class Singleton {
    private static Singleton ourInstance = new Singleton();

    public static Singleton getInstance() {
        return ourInstance;
    }

    private Singleton() {
    }
}
class App {
    void execute() {
         Singleton singleton = Singleton.getInstance()
    }
}

// Kotlin
object Singleton {}

class App {
    fun execute() {
          val singleton = Singleton
    }
}

תבנית ה"סינגל " המוכרת משמשת לעתים קרובות למדי בפועל, אז קוטלין החליט ליצור מילת מפתח נפרדת " אובייקט ", שנכתבת במקום " מחלקה " ומשמעותה שהמחלקה היא יחידה; כאשר משתמשים בה, אתה אפילו לא צריך לקרוא לבנאי או כל שיטה אחרת! פרמטרי שיטה בעלי שם וערכי ברירת מחדל

// Java
void setStatus(String code) {
    setStatus(code, "");
}

void setStatus(String code, String desc) {
    this.code = code;
    this.desc = desc;
}

// Kotlin
fun setStatus(code: String, desc: String = "") {
    this.code = code;
    this.desc = desc;
}

fun execute() {
    setStatus("200")
    setStatus(code = "200", desc = "Ok")
}

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

// Java
String getFirst(List<String> strings, String alpha) {
    return strings.stream()
            .filter(x -> x.startsWith(alpha))
            .findFirst()
            .orElse("");
}

// Kotlin
fun getFirst(strings: List<String>, alpha: String): String {
    return strings.first { it.startsWith(alpha) }
}

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

• קל מאוד למפתח Java לשלוט בתחביר Kotlin ולהתחיל לכתוב קוד;
• Kotlin תואם לחלוטין ל-Java, ואתה כבר יכול לנסות את זה בפרויקטים הקיימים שלך, למשל, בבדיקות;
• קוד Kotlin נקי יותר וקריא יותר, אינך צריך לכתוב אוסף של לוחות ;
• ל-IDEA יש ממיר Java לקוטלין אוטומטי, אתה יכול לקחת קוד Java מוכן ולהמיר אותו אוטומטית לקוטלין;
• צריך לכתוב פרויקט חדש בקוטלין, כי מנקודת מבט של תשתית זה זהה לג'אווה, אבל מבחינת השימוש זה טוב ונוח יותר!

אם אהבתם את המאמר ואתם רלוונטיים באופן כללי על משאב על Java, אני יכול להמשיך לכתוב על חווית השימוש ב-Kotlin בפרויקט אמיתי של ארגון. קישורים שימושיים:

• נסה לכתוב משהו בקוטלין באינטרנט
• לימוד קוטלין - סט ותיאור דוגמאות אינטראקטיביות שונות
• תוסף עבור IDEA לאימון עם אימות (כגון mini-JavaRush)
• האתר הרשמי של קוטלין
• אתר קוטלין הרוסי