מבוא לשפת קוטלין

1. סקירה כללית

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

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

2. תלות Maven

כדי להשתמש בקוטלין בפרויקט Maven שלך, עליך להוסיף לספרייה הסטנדרטית של Kotlin pom.xml:

 org.jetbrains.kotlin kotlin-stdlib 1.0.4 

כדי להוסיף תמיכה ב- JUnit ל- Kotlin, תצטרך לכלול את התלות הבאות:

 org.jetbrains.kotlin kotlin-test-junit 1.0.4 test junit junit 4.12 test 

תוכל למצוא את הגרסאות האחרונות של kotlin-stdlib, kotlin-test-junit ו- junit ב- Maven Central.

לבסוף, יהיה עליך להגדיר את ספריות המקור ואת התוסף Kotlin על מנת לבצע בניית Maven:

 $ {project.basedir} / src / main / kotlin $ {project.basedir} / src / test / kotlin kotlin-maven-plugin org.jetbrains.kotlin 1.0.4 הידור הידור מבחן קומפילציה של מבחן קומפילציה 

תוכל למצוא את הגרסה האחרונה של תוסף kotlin-maven ב- Maven Central.

3. תחביר בסיסי

בואו נסתכל על אבני הבניין הבסיסיות של שפת קוטלין.

יש דמיון מסוים ל- Java (למשל, הגדרת חבילות היא באותו אופן). בואו נסתכל על ההבדלים.

3.1. הגדרת פונקציות

בואו נגדיר פונקציה עם שני פרמטרים של Int Int סוג החזרה:

סכום מהנה (a: Int, b: Int): Int {return a + b}

3.2. הגדרת משתנים מקומיים

הקצה משתנה מקומי פעם אחת (לקריאה בלבד):

val a: Int = 1 val b = 1 val c: Int c = 1

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

var x = 5 x + = 1

4. שדות אופציונליים

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

דוא"ל val: מחרוזת?

כאשר הגדרת שדה בטל, זה תקף לחלוטין להקצות a ריק לזה:

דוא"ל val: מחרוזת? = אפס

כלומר בשדה דוא"ל יכול להיות ריק. אם נכתוב:

val email: String = "value"

לאחר מכן עלינו להקצות ערך לשדה הדוא"ל באותה הצהרה עליה אנו מכריזים על דוא"ל. לא יכול להיות לזה ערך null. נחזור לקוטלין ריק בטיחות בחלק מאוחר יותר.

5. שיעורים

בואו נדגים כיצד ליצור מחלקה פשוטה לניהול קטגוריה ספציפית של מוצר. שֶׁלָנוּ ItemManager בכיתה למטה יש בנאי ברירת מחדל שמאכלס שני שדות - categoryId ו dbConnection - ואופציונלי אימייל שדה:

class ItemManager (val categoryId: String, val dbConnection: String) {var email = "" // ...}

זֶה ItemManager (...) קונסטרוקט יוצר קונסטרוקטור ושני שדות בכיתה שלנו: categoryId ו dbConnection

שים לב שהבנאי שלנו משתמש ב- val מילת מפתח לטיעוניה - פירוש הדבר שהשדות המתאימים יהיו סופי ובלתי משתנה. אם היינו משתמשים ב- var מילת מפתח (כפי שקבענו בעת הגדרת התווית אימייל שדה), ואז שדות אלה יהיו ניתנים לשינוי.

בואו ליצור מופע של ItemManager באמצעות קונסטרוקטור ברירת המחדל:

ItemManager ("cat_id", "db: // connection")

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

ItemManager (categoryId = "catId", dbConnection = "db: // Connection")

זה מאוד שימושי כשאנחנו צריכים להעביר טיעונים נוספים לפונקציה.

אם אתה זקוק לבנאים נוספים, היית מגדיר אותם באמצעות ה- בַּנַאִי מילת מפתח. נגדיר קונסטרוקטור אחר שמגדיר גם את אימייל שדה:

constructor (categoryId: String, dbConnection: String, email: String): this (categoryId, dbConnection) {this.email = email}

שים לב שבנאי זה מזמין את קונסטרוקטור ברירת המחדל שהגדרנו לעיל לפני הגדרת שדה הדוא"ל. ומכיוון שכבר הגדרנו categoryId ו dbConnection להיות בלתי משתנה באמצעות val מילת המפתח בבנאי ברירת המחדל, איננו צריכים לחזור על ה- val מילת מפתח בבונה הנוסף.

עכשיו, בואו ניצור מופע באמצעות הבנאי הנוסף:

ItemManager ("cat_id", "db: // connection", "[email protected]")

אם ברצונך להגדיר שיטת מופע ב- ItemManager, היית עושה זאת באמצעות כֵּיף מילת מפתח:

fun isFromSpecificCategory (catId: String): בוליאני {return categoryId == catId}

6. ירושה

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

כדי לציין שהכיתה פתוחה להארכה, היית משתמש ב- לִפְתוֹחַ מילת מפתח בעת הגדרת הכיתה.

בואו נגדיר פריט כיתה שפתוחה להארכה:

פריט מחלקה פתוחה (val id: String, val name: String = "unknown_name") {open fun getIdOfItem (): String {return id}}

שים לב שציינו גם את getIdOfItem () השיטה כפתוחה. זה מאפשר לעקוף אותו.

עכשיו, בואו נאריך את ה- פריט בכיתה ולדרוס את getIdOfItem () שיטה:

class ItemWithCategory (id: String, name: String, val categoryId: String): Item (id, name) {override fun getIdOfItem (): String {return id + name}}

7. הצהרות מותנות

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

make makeAnalyisOfCategory (catId: String): יחידה {val result = if (catId == "100") "כן" אחרת "לא" println (תוצאה)}

בדוגמה זו אנו רואים שאם catId שווה לחסימת "100" מחזירה "כן" אחרת היא מחזירה "לא". הערך המוחזר מוקצה ל תוֹצָאָה.

אתה יכול ליצור נורמלי אםאַחֵר לַחסוֹם:

מספר val = 2 אם (מספר 10) {println ("המספר גדול מ- 10")}

Kotlin יש גם מאוד שימושי מתי פקודה שמתנהגת כמו משפט מתג מתקדם:

val name = "John" when (name) {"John" -> println ("Hi man") "Alice" -> println ("היי גברת")} 

8. אוספים

ישנם שני סוגים של אוספים בקוטלין: ניתנים לשינוי ובלתי משתנים. כשאנחנו יוצרים אוסף שאינו משתנה פירושו שהוא לקריאה בלבד:

פריטי val = listOf (1, 2, 3, 4)

אין רכיב פונקציה להוסיף ברשימה זו.

כאשר אנו רוצים ליצור רשימה ניתנת לשינוי שאפשר לשנות אותה, עלינו להשתמש בה mutableListOf () שיטה:

val rwList = mutableListOf (1, 2, 3) rwList.add (5)

לרשימה משתנה יש לְהוֹסִיף() שיטה כדי שנוכל להוסיף לה אלמנט. יש גם שיטה שווה ערך לסוגים אחרים של אוספים: mutableMapOf (), mapOf (), setOf (), mutableSetOf ()

9. חריגים

מנגנון הטיפול בחריגים דומה מאוד לזה שב- Java.

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

כדי לזרוק אובייקט חריג, עלינו להשתמש בביטוי השלכה:

זרוק חריג ("msg")

הטיפול בחריג נעשה באמצעות נסה ... לתפוס חסום (סוף סוף אופציונאלי):

נסה {} לתפוס (e: SomeException) {} סוף סוף {}

10. למבדות

בקוטלין נוכל להגדיר פונקציות למבדה ולהעביר אותן כטיעונים לפונקציות אחרות.

בואו נראה כיצד להגדיר למבדה פשוטה:

val sumLambda = {a: Int, b: Int -> a + b}

הגדרנו sumLambda פונקציה שלוקחת שני ארגומנטים מהסוג Int כוויכוח וחוזר Int.

נוכל להעביר למבדה מסביב:

@Test fun givenListOfNumber_whenDoingOperationsUsingLambda_shouldReturnProperResult () {// given val listOfNumbers = listOf (1, 2, 3) // when val sum = listOfNumbers.reduce {a, b -> a + b} // then assertEquals (6, sum)}

11. קונסטרוקציות לולאה

בקוטלין, ניתן לבצע לולאה באמצעות אוספים באמצעות תקן ב לִבנוֹת:

val numbers = arrayOf ("ראשון", "שני", "שלישי", "רביעי")
עבור (n במספרים) {println (n)}

אם אנו רוצים לחזור על טווח של מספרים שלמים נוכל להשתמש במבנה טווח:

עבור (אני ב 2..9 שלב 2) {println (i)}

שים לב שהטווח בדוגמה לעיל כולל משני הצדדים. ה שלב הפרמטר הוא אופציונלי והוא שווה ערך להגדלת הדלפק פעמיים בכל איטרציה. הפלט יהיה הבא:

2 4 6 8

נוכל להשתמש ב- rangeTo () פונקציה שמוגדרת ב- Int בכיתה באופן הבא:

1.rangeTo (10) .map {it * 2}

התוצאה תכיל (שים לב לכך rangeTo () כולל גם):

[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

12. בטיחות אפסית

בואו נסתכל על אחת התכונות המרכזיות של קוטלין - בטיחות אפס, המובנית בשפה. כדי להמחיש מדוע זה שימושי, ניצור שירות פשוט המחזיר פריט לְהִתְנַגֵד:

class ItemService {fun findItemNameForId (id: String): פריט? {val itemId = UUID.randomUUID (). toString () Return Item (itemId, "name- $ itemId"); }}

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

אם לחתימת השיטה יש סוג ללא סימן שאלה:

fun findItemNameForId (id: String): פריט

ואז קוד חיוג לא יצטרך לטפל במקרה ריק מאחר שהוא מובטח על ידי המהדר ושפת קוטלין, שהאובייקט שהוחזר לא יכול להיות ריק.

אחרת, אם יש אובייקט אפס המועבר לשיטה, ואותו מקרה לא מטופל, הוא לא יורכב.

בוא נכתוב מקרה מבחן לבטיחות מסוג קוטלין:

val id = "item_id" val itemService = ItemService () val result = itemService.findItemNameForId (id) assertNotNull (result?. let {it -> it.id}) assertNotNull (result !!. id) 

אנו רואים כאן כי לאחר ביצוע השיטה findItemNameForId (), הסוג המוחזר הוא של קוטלין מאפשרת ערכי null. כדי לגשת לשדה של אותו אובייקט (תְעוּדַת זֶהוּת), עלינו לטפל במקרה זה בזמן הקומפילציה. שיטה לתת() יבוצע רק אם התוצאה אינה בטלה. אניד ניתן לגשת לשדה בתוך פונקציית lambda מכיוון שהיא בטוחה null.

דרך נוספת לגשת לאותו שדה אובייקט בטל היא להשתמש באופרטור Kotlin !!. זה שווה ערך ל:

אם (תוצאה == null) {throwNpe (); } להחזיר תוצאה;

קוטלין יבדוק אם אובייקט זה הוא א ריק אם כן, זה יזרוק א NullPointerException, אחרת זה יחזיר חפץ ראוי. פוּנקצִיָה throwNpe () היא פונקציה פנימית של קוטלין.

13. שיעורי נתונים

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

פריט בכיתת נתונים (מזהה val: מחרוזת, שם val: מחרוזת)

המהדר ייצור עבורנו שיטות hashCode (), שווים(), ו toString (). זה נוהג טוב להפוך את שיעורי הנתונים לבלתי משתנים באמצעות val מילת מפתח. למחלקות נתונים יכולים להיות ערכי שדה ברירת מחדל:

מחלקת נתונים פריט (מזהה val: מחרוזת, שם val: מחרוזת = "unknown_name")

אנחנו רואים ש שֵׁם לשדה יש ​​ערך ברירת מחדל "unknown_name".

14. פונקציות הרחבה

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

בואו ניקח בחשבון דוגמא בה יש לנו רשימת אלמנטים ואנחנו רוצים לקחת אלמנט אקראי מאותה רשימה. אנו רוצים להוסיף פונקציה חדשה אַקרַאִי() לצד שלישי רשימה מעמד.

כך זה נראה בקוטלין:

כיף List.random (): T? {if (this.isEmpty ()) להחזיר null return get (ThreadLocalRandom.current (). nextInt (count ()))}

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

בתוך שיטת ההרחבה, אנו פועלים על טווח של רשימה, ולכן משתמשים בה זֶה נתן גישה לשימוש לרשימת שיטות מופע כמו זה ריק() אוֹ לספור(). ואז אנו מסוגלים להתקשר אַקרַאִי() שיטה בכל רשימה שנמצאת בתחום זה:

כיף getRandomElementOfList (רשימה: רשימה): T? {return list.random ()}

יצרנו שיטה שלוקחת רשימה ואז מבצעת פונקציית סיומת מותאמת אישית אַקרַאִי() שהוגדר בעבר. בוא נכתוב מקרה מבחן לפונקציה החדשה שלנו:

רכיבי val = listOf ("a", "b", "c") val result = ListExtension (). getRandomElementOfList (elements) assertTrue (elements.contains (result)) 

האפשרות להגדיר פונקציות ש"מרחיבות "שיעורי צד ג 'היא תכונה חזקה מאוד ויכולה להפוך את הקוד שלנו לתמציתי וקריא יותר.

15. תבניות מחרוזת

תכונה נחמדה מאוד של שפת קוטלין היא אפשרות להשתמש בתבניות עבור חוּטס. זה מאוד שימושי כי אנחנו לא צריכים לשרשר חוּטs באופן ידני:

val firstName = "Tom" val secondName = "Mary" val concatOfNames = "$ firstName + $ secondName" val sum = "four: $ {2 + 2}" 

אנו יכולים גם להעריך ביטוי בתוך ה- ${} לַחסוֹם:

val itemManager = ItemManager ("cat_id", "db: // connection") val result = "תוצאת פונקציה: $ {itemManager.isFromSpecificCategory (" 1 ")}"

16. יכולת פעולה הדדית של Kotlin / Java

Kotlin - יכולת פעולה הדדית של Java קלה בצורה חלקה. נניח שיש לנו שיעור Java עם שיטה שפועלת חוּט:

class StringUtils {public stic String toUpperCase (שם מחרוזת) {return name.toUpperCase (); }}

עכשיו אנחנו רוצים לבצע את הקוד הזה ממעמד הקוטלין שלנו. אנחנו רק צריכים לייבא את המעמד הזה ואנחנו יכולים לבצע את שיטת Java מקוטלין ללא בעיות:

val name = "tom" val res = StringUtils.toUpperCase (name) assertEquals (res, "TOM")

כפי שאנו רואים, השתמשנו בשיטת java מקוד קוטלין.

קל מאוד להתקשר לקוד קוטלין מג'אווה. בואו נגדיר פונקצית קוטלין פשוטה:

class MathematicsOperations {fun addTwoNumbers (a: Int, b: Int): Int {return a + b}}

מְבַצֵעַ addTwoNumbers () מקוד Java קל מאוד:

int res = MathematicsOperations new (). addTwoNumbers (2, 4); assertEquals (6, מיל ');

אנו רואים שקריאה לקוד קוטלין הייתה שקופה בעינינו.

כאשר אנו מגדירים שיטה ב- Java, סוג ההחזרה הוא a בָּטֵל, בקוטלין הערך המוחזר יהיה של יחידה סוּג.

ישנם כמה מזהים מיוחדים בשפת Java ( הוא, לְהִתְנַגֵד, ב, ..) שכשמשתמשים בהם בקוד קוטלין צריך להימלט. לדוגמה, נוכל להגדיר שיטה שיש לה שם לְהִתְנַגֵד() אבל עלינו לזכור לברוח מהשם הזה מכיוון שמדובר במזהה מיוחד ב- Java:

fun `object` (): מחרוזת {return" זה אובייקט "}

אז נוכל לבצע את השיטה הזו:

'אובייקט' ()

17. מסקנה

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

ניתן למצוא את היישום של כל הדוגמאות וקטעי הקוד בפרויקט GitHub.


$config[zx-auto] not found$config[zx-overlay] not found