תוֹכֶן
- Kotlin לעומת Java, המאוחר יותר מציע קוד תמציתי יותר - ללא findViewByIds
- כברירת מחדל Kotlin בטוחה
- פונקציות הרחבה
- קורוטין הם אזרחים מהשורה הראשונה
- אין חריגים מסומנים
- תמיכה מולדת במשלחת
- שיעורי נתונים
- מטיל חכם
- תמיכה בבניינים
- אין תמיכה בהרחבת המרות מרומזות
- ספריות לעיבוד ביאורים עם קוטלין
- החלפות עם ג'אווה
- מסיימים
ג'אווה עדיין יכולה להיות שפת התכנות הראשונה שעולה בראש כשאתה חושב על אנדרואיד, אבל לא יש להשתמש ב- Java לפיתוח אנדרואיד. למעשה, קוטלין הוא עכשיו של גוגלמועדףשפה רשמית לאנדרואיד!
למידע נוסף על Java קבל קורס מבוא חינם ל- Java ב- Make Android Apps.
כיום, סטודיו אנדרואיד נשלח עם תמיכה מובנית של Kotlin, כך שיצירת פרויקט אנדרואיד שמבין את קוד Kotlin היא קלה כמו בחירת תיבת סימון באשף יצירת הפרויקטים של Android Studio. התמיכה גדלה עבור האופציה שעות נוספות מדי, עד כדי כך שההחלטה הזו כעת בעיקר מסתכמת בעדיפות.
אבל אם אתה מבצע את המעבר מג'אווה לקוטלין, מה בדיוק אתה מרוויח? אילו תכונות יש לקוטלין, לג'אווה אין, ולהיפך?
במאמר זה, אנו נבחן את כל ההבדלים העיקריים בין קוטלין לעומת ג'אווה.
Kotlin לעומת Java, המאוחר יותר מציע קוד תמציתי יותר - ללא findViewByIds
אם אתה משווה בין מחלקת Kotlin לבין כיתת Java שמבצעות את אותה עבודה, אז בדרך כלל שיעור ה- Kotlin יהיה הרבה יותר תמציתי, אבל יש תחום אחד במיוחד בו קוטלין יכול להפחית ברצינות את כמות קוד לוח הדוד שאתה צריך לכתוב: findViewByIds.
תוספי אנדרואיד של קוטלין מאפשרים לך לייבא הפניה לתצוגה לקובץ הפעילות שלך, ואז תוכל לעבוד עם תצוגה זו כאילו היא חלק מהפעילות. התוצאה? לעולם לא תצטרך לכתוב שיטה אחרת של findViewById שוב!
לפני שתוכל להשתמש בתוספים אלה, עליך להוסיף תוסף נוסף לקובץ build.gradle ברמת המודול (החל תוסף: 'הרחבות kotlin-android-extensions') אך לאחר מכן אתה מוכן להתחיל לייבא תצוגות, עבור דוגמה אם הקובץ Activity_main.xml שלך הכיל תצוגה מקדימה עם התצוגה text מזהה, היית מוסיף את הפעולות הבאות:
ייבא kotlinx.android.synthetic.main.activity_main.textView
לאחר מכן תוכל לגשת ל- TextView זה רק באמצעות המזהה שלו:
textView.setText ("שלום עולם")
זה הרבה תמציתית יותר מקבילה של ג'אווה:
TextView text = (TextView) findViewById (R.id.textView); text.setText ("שלום עולם");
כברירת מחדל Kotlin בטוחה
NullPointerExceptions הם מקור עצום לתסכול עבור מפתחי Java. ג'אווה מאפשרת לך להקצות null לכל משתנה, אך אם אתה מנסה להשתמש בהתייחסות לאובייקט שיש לו ערך null, אז התחבר לעצמך להיתקל NullPointerException!
קרא גם: קוטילן למבוא אנדרואיד
בקוטלין, כל הסוגים אינם ניתנים לאפס (ללא אפשרות להחזיק ערך null) כברירת מחדל. אם אתה מנסה להקצות או להחזיר null בקוד ה- Kotlin שלך, הוא ייכשל בזמן ההרכבה, כך שאף אחת מהשורות הבאות לא תקבץ:
שם val: מחרוזת = null
כיף getName (): מחרוזת = null
אם אתה באמת רוצה להקצות ערך null למשתנה ב- Kotlin, תצטרך לסמן במפורש את המשתנה הזה כמוסמך, על ידי הוספת סימן שאלה אחרי הסוג:
מספר מספר: בינוני? = null
זה כמעט בלתי אפשרי להיתקל ב NullPointerExceptions בקוטלין - למעשה, אם אתה נתקל בחריג הזה, רוב הסיכויים שזה בגלל שביקשת מפורשות מקוטלין לזרוק אחת, או שה- NullPointerException נובע מקוד Java חיצוני.
פונקציות הרחבה
קוטלין מעניק למפתחים את היכולת להרחיב מחלקה עם פונקציונליות חדשה, שהיא אידיאלית אם יש כיתה שתמיד הרגשת שהיא חסרה שיטה חשובה!
'פונקציות סיומת' אלה אינן זמינות ב- Java, למרות שהן זמינות בשפות תכנות אחרות בהן תוכל להשתמש לפיתוח אנדרואיד, כגון C #.
קרא את הבא: מדריך Java למתחילים
אתה יוצר פונקציית סיומת על ידי קידומת של שם הכיתה שברצונך להרחיב (כגון 'מחרוזת') לשם הפונקציה שאתה יוצר ('styleString') למשל:
fun String.styleString (): מחרוזת {// סגנון את המחרוזת ואז החזירה //}
לאחר מכן תוכל לקרוא לפונקציה זו על מקרים של הכיתה המורחבת, דרך. ציון, כאילו זה חלק מהכיתה ההיא:
קורוטין הם אזרחים מהשורה הראשונה
בכל פעם שאתה מתחיל לבצע פעולה ממושכת, כגון קלט / פלט רשת או עבודה עתירת מעבד, חוט השיחה נחסם עד לסיום הפעולה. מכיוון שאנדרואיד הוא הברגה חד-הברגה, ברגע שתחסום את השרשור הראשי ממשק המשתמש של האפליקציה שלך יקפא, והוא יישאר לא מגיב עד לסיום הפעולה.
בג'אווה הפיתרון היה באופן מסורתי ליצור חוט רקע בו תוכלו לבצע עבודה אינטנסיבית או ארוכת טווח זו, אך ניהול של מספר האשכולות עלול להוביל לקוד מורכב ומועדי שגיאה, ויצירת פתיל חדש היא פעולה יקרה.
אמנם אתה יכול ליצור חוטים נוספים בקוטלין, אך אתה יכול להשתמש גם בקורוטינים. Coroutines מבצעים משימות ארוכות ואינטנסיביות על ידי השעיית הביצוע בנקודה מסוימת מבלי לחסום את החוט ואז לחדש את הפונקציה בנקודה מאוחרת יותר, יתכן על חוט אחר. זה מאפשר לך ליצור קוד אסינכרוני שאינו חוסם את זה מבט סינכרוני, ולכן ברור יותר, תמציתי וקריא אנושי. Coroutines גם הם חסרי ערימה, כך שיש להם שימוש בזיכרון נמוך יותר בהשוואה לחוטים, והם פותחים את הדלת לסגנונות נוספים של תכנות אסינכרוניות שאינן חוסמות, כגון אסינכרון / מחכה.
אין חריגים מסומנים
קוטלין לא בדק חריגים, לכן אינך צריך לתפוס או להכריז על חריגים.
אם זה משהו שמושך אותך לקוטלין, או שגורם לך לרצות להישאר עם ג'אווה, יהיה תלוי בדעתך לגבי חריגים שנבדקו, מכיוון שזו תכונה המפלגת את קהילת המפתחים. אם נמאס לכם לנסות / לתפוס חסימות עמוסות בקוד ה- Java שלכם, אתם תהיו מרוצים מהמחדל הזה, אולם אם תגלו שחריגים מסומנים מעודדים אתכם לחשוב על התאוששות שגיאות ובסופו של דבר לדחוף אתכם לעבר יצירת איתנים יותר קוד, אז סביר יותר שתראה את זה כאזור שבו ל- Java יש את הקצה מעל קוטלין.
תמיכה מולדת במשלחת
קוטלין, בשונה מג'אווה, תומך בתבנית העיצוב "קומפוזיציה על ירושה", באמצעות משלחת מהשורה הראשונה (המכונה לפעמים משלחת מרומזת). המשלחת היא המקום בו אובייקט שקיבל מאציל פעולות לאובייקט ציר שני, שהוא אובייקט עוזר עם ההקשר המקורי.
משלחת הכיתה של קוטלין היא אלטרנטיבה לירושה המאפשרת שימוש בירושה מרובה. בינתיים, הנכסים המוחזקים של קוטלין עוזרים במניעת כפילות הקוד, לדוגמה אם אתה צריך לעשות שימוש חוזר באותו קוד למגדרים ולמתיישבים מרובים של נכסים, אתה יכול לחלץ את הקוד הזה לנכס שהוזמן. נציג הנכסים צריך להגדיר את פונקציית מפעיל getValue ואופציונלי, את מפעיל setValue:
בכיתה נציג {מפעיל כיף getValue (...) ... ... ...} מפעיל כיף setValue (...) ... ... ...}}
לאחר מכן, כשאתה יוצר נכס אתה יכול להצהיר כי פונקציות getter ו- setter עבור נכס מסוים זה מטופלות על ידי מחלקה אחרת:
class MyClass {var property: String by delegated ()}
שיעורי נתונים
לא יוצא דופן שלפרויקט יהיו שיעורים מרובים שאינם עושים דבר מלבד נתונים. ב- Java, אתה תמצא את עצמך כותב המון קוד לוח הדוד לשיעורים אלה, למרות שלכיתות עצמן יש מעט מאוד פונקציונליות. בדרך כלל, עליך להגדיר קונסטרוקטור, שדות לאחסון נתונים, פונקציות getter ו- setter עבור כל שדה, בתוספת פונקציות hashCode (), שוות () ו- toString ().
בקוטלין, אם תכלול את מילת המפתח 'נתונים' בהגדרת הכיתה שלך, המהדר יבצע עבורך את כל העבודה הזו, כולל יצירת כל האותרים והמתנחלים הדרושים:
כיתת נתונים תאריך (var חודש: מחרוזת, יום var: בינוני)
מטיל חכם
ב- Java לעיתים קרובות עליך לבדוק את סוג ואז להטיל אובייקט במצבים בהם כבר ברור שניתן להטיל את האובייקט.
העברות החכמות של קוטלין יכולות להתמודד עם הצבעים המיותרים האלה עבורך, כך שאתה לא צריך להטיל הצהרה אם כבר בדקת אותה אצל המפעיל 'is' של קוטלין. לדוגמה, המהדר יודע שהצילום הבא בטוח:
אם (שלום זה מחרוזת) {printString (שלום)}
תמיכה בבניינים
שלא כמו ג'אווה, בכיתה של קוטלין יכולות להיות בנאי ראשוני ובוני משני או יותר, אותם אתה יוצר על ידי הכללתם בהצהרת הכיתה שלך:
כיתת בנאי MainActivity (firstName: String) {}
אין תמיכה בהרחבת המרות מרומזות
קוטלין אינו תומך בהמרות הרחבות מרומזות למספרים, כך שסוגים קטנים יותר אינם מומרים באופן מרומז לסוגים גדולים יותר. בקוטלין, אם ברצונך להקצות ערך מסוג Byte למשתנה Int, תצטרך לבצע המרה מפורשת, בעוד שג'אווה תומכת בהמרות מרומזות.
ספריות לעיבוד ביאורים עם קוטלין
Kotlin תומך בכל המסגרות והספריות של ג'אווה הקיימות, כולל מסגרות מתקדמות הנשענות על עיבוד הערות, אם כי ספריות ג'אווה מסוימות כבר מספקות הרחבות של קוטלין, כמו RxKotlin.
אם ברצונך להשתמש בספריית Java הנשענת על עיבוד הערות, הוספת אותה לפרויקט Kotlin שלך שונה במקצת, מכיוון שתצטרך לציין את התלות באמצעות kotlin-kapt ואז השתמש בכלי עיבוד ההערות Kotlin (kapt) במקום annotationProcessor. לדוגמה:
// החל את התוסף // החל תוסף: kotlin-kapt // הוסף את התלות בהתאמה באמצעות תצורת kapt // תלות {kapt "com.google.dagger: פגיון-מהדר: $ פגיון-גרסה" ... ... ...}
החלפות עם ג'אווה
כשמתלבטים אם להשתמש ב- Kotlin או ב- Java לצורך פיתוח אנדרואיד, עליכם להיות מודעים לכך שיש אפשרות שלישית: השתמש בשניהם. למרות כל ההבדלים בין שתי השפות, ג'אווה וקוטלין פועלים ביניהם במאה אחוז. אתה יכול לקרוא קוד Kotlin מג'אווה, ואתה יכול לקרוא קוד ג'אווה מקוטלין, כך שאפשר להכיל שיעורי Kotlin ו- Java זה לצד זה באותו פרויקט, והכל עדיין יתחבר.
הגמישות הזו למעבר בין שתי השפות מועילה כשאתה מתחיל לעבוד עם קוטלין מכיוון שהיא מאפשרת לך להכניס את קוטלין לפרויקט קיים באופן מצטבר, אך ייתכן שתעדיף להשתמש בשתי השפות על בסיס קבוע. לדוגמה, יתכנו תכונות מסוימות שאתה מעדיף לכתוב בקוטלין, ותכונות מסוימות שנמצא לך קל יותר לכתוב ב- Java. מכיוון שקוטלין וג'אווה שניהם מתחברים לקוד-בייט, משתמשי הקצה שלך לא יוכלו לדעת היכן מסתיים קוד ה- Java שלך, וקוד ה- Kotlin מתחיל, כך שאין סיבה שלא תוכל לשחרר אפליקציה שמורכבת מג'אווה. ו קוד קוטלין.
אם אתה רוצה לנסות בעצמך את Kotlin, כל עוד מותקנת תצוגה מקדימה של Android Studio 3.0 ומעלה, יש כמה דרכים שתוכל להתחיל:
- צור פרוייקט Android Studio חדש. השיטה הקלה ביותר היא ליצור פרויקט חדש ולבחור בתיבת הסימון 'כלול תמיכה בקוטלין' באשף יצירת הפרויקט.
- הוסף כיתת Kotlin לספרייה קיימת. לחץ על שליטה על התיקיה המדוברת ובחר 'קובץ> חדש> קובץ / כיתה של Kotlin.' סטודיו אנדרואיד יציג באנר שמבקש ממך להגדיר את הפרויקט שלך כך שיתמוך בקוטלין; לחץ על הקישור 'הגדר' ופעל לפי ההוראות שעל המסך.
- המרת קבצי Java קיימים לקוטלין. אתה יכול להריץ כל קובץ Java דרך ממיר Kotlin, על ידי לחיצה על הקובץ על בקרה ובחירה 'קוד> המר קובץ Java לקובץ Kotlin.'
מסיימים
כפי שניתן לראות יש המון סיבות טובות להעדיף את קוטלין על פני ג'אווה, עם זאת ישנם כמה תחומים שבהם ג'אווה על העליונה. אולי הבולט ביותר: מפתחי אנדרואיד רבים פשוט מכירים את Java בשלב זה. סביר להניח שהוויכוח על קוטלין לעומת ג'אווה לא יסתיים בקרוב, כאשר לשניהם יש את היתרונות שלהם. אז האם אתה הולך לעבור לקוטלין, או שאתה מרגיש שג'אווה היא עדיין האפשרות הטובה ביותר לפיתוח אנדרואיד?
קרא את הבא: מבוא לתחביר Java לפיתוח אנדרואיד
