حرکت به هر زبان جدید می تواند یک کار دلهره آور باشد. دستور موفقیت این است که آهسته شروع کنید، تکه تکه حرکت کنید و مرتباً آزمایش کنید تا تیم خود را برای موفقیت هماهنگ کنید. Kotlin مهاجرت را آسان می کند، زیرا به بایت کد JVM کامپایل می شود و به طور کامل با جاوا سازگار است.
اولین قدم قبل از مهاجرت ایجاد یک درک پایه مشترک برای تیم خود است. در اینجا چند نکته وجود دارد که ممکن است برای تسریع در یادگیری تیمتان مفید باشد.
گروه های مطالعه روشی موثر برای تسهیل یادگیری و یادداری هستند. مطالعات نشان می‌دهند که خواندن آموخته‌هایتان در یک محیط گروهی به تقویت مطالب کمک می‌کند. برای هر یک از اعضای گروه یک کتاب کاتلین یا سایر مطالب مطالعه دریافت کنید و از گروه بخواهید هر هفته چند فصل را مرور کنند. در طول هر جلسه، گروه باید آنچه را که آموخته اند مقایسه کند و در مورد هر گونه سوال یا مشاهدات بحث کند.
در حالی که همه خود را معلم نمی دانند، همه می توانند تدریس کنند. از یک فناوری یا تیمی گرفته تا یک مشارکت کننده فردی، همه می توانند محیط یادگیری را تشویق کنند که می تواند به تضمین موفقیت کمک کند. یکی از راه‌های تسهیل این امر، برگزاری سخنرانی‌های دوره‌ای است که در آن یک نفر در تیم تعیین می‌شود تا درباره چیزی که آموخته یا می‌خواهد به اشتراک بگذارد صحبت کند. شما می توانید با درخواست از داوطلبان برای ارائه فصل جدید هر هفته تا زمانی که به نقطه ای برسید که تیم شما با زبان احساس راحتی کند، از گروه مطالعه خود استفاده کنید.
در نهایت، قهرمانی را برای رهبری یک تلاش یادگیری تعیین کنید. این شخص می تواند به عنوان یک متخصص موضوع (SME) در هنگام شروع فرآیند پذیرش عمل کند. مهم است که این شخص را در تمام جلسات تمرینی خود در رابطه با کاتلین بگنجانید. در حالت ایده آل، این شخص از قبل به کاتلین علاقه دارد و دانش کاری دارد.
شروع به آرامی و تفکر استراتژیک در مورد اینکه کدام بخش از اکوسیستم خود را ابتدا باید حرکت دهید، کلیدی است. اغلب بهتر است این را به یک برنامه واحد در سازمان خود جدا کنید تا یک برنامه شاخص. از نظر انتقال برنامه انتخابی، هر موقعیت متفاوت است، اما در اینجا چند مکان رایج برای شروع آورده شده است.
مدل داده‌های شما احتمالاً شامل تعداد زیادی اطلاعات وضعیت به همراه چند روش است. مدل داده همچنین ممکن است متدهای رایجی مانند toString() ، equals() و hashcode() داشته باشد. این روش ها معمولاً می توانند انتقال داده شوند و واحدها به راحتی به صورت مجزا آزمایش شوند.
به عنوان مثال، قطعه زیر از جاوا را فرض کنید:
public class Person {
private String firstName;
private String lastName;
// ...
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return Objects.equals(firstName, person.firstName) &&
Objects.equals(lastName, person.lastName);
}
@Override
public int hashCode() {
return Objects.hash(firstName, lastName);
}
@Override
public String toString() {
return "Person{" +
"firstName='" + firstName + '\'' +
", lastName='" + lastName + '\'' +
'}';
}
}
همانطور که در اینجا نشان داده شده است، می توانید کلاس جاوا را با یک خط کوتلین جایگزین کنید:
data class Person(var firstName: String?, var lastName : String?)
سپس این کد را می توان در برابر مجموعه آزمایشی فعلی شما آزمایش کرد. ایده در اینجا این است که با یک مدل در هر زمان و کلاس‌های انتقالی که عمدتا حالت هستند و رفتار نیستند، کوچک شروع کنیم. در طول مسیر حتما تست کنید.
راه شروع دیگری که باید در نظر بگیرید تبدیل تست های موجود و شروع نوشتن تست های جدید در کاتلین است. این می تواند به تیم شما فرصت دهد تا قبل از نوشتن کدی که قصد دارید با برنامه خود ارسال کنید، با زبان احساس راحتی کنند.
هر کلاس ابزار ثابت ( StringUtils ، IntegerUtils ، DateUtils ، YourCustomTypeUtils ، و غیره) را می توان به عنوان توابع پسوند Kotlin نشان داد و توسط پایگاه کد جاوا موجود شما استفاده کرد.
برای مثال، در نظر بگیرید که یک کلاس StringUtils با چند روش دارید:
package com.java.project;
public class StringUtils {
public static String foo(String receiver) {
return receiver...; // Transform the receiver in some way
}
public static String bar(String receiver) {
return receiver...; // Transform the receiver in some way
}
}
همانطور که در مثال زیر نشان داده شده است، ممکن است این روش ها در جای دیگری در برنامه شما استفاده شوند:
...
String myString = ...
String fooString = StringUtils.foo(myString);
...
با استفاده از توابع افزودنی Kotlin، می‌توانید همان رابط Utils برای تماس‌گیرندگان جاوا فراهم کنید و در عین حال API مختصرتری را برای پایگاه کد رو به رشد Kotlin خود ارائه دهید.
برای انجام این کار، می توانید با تبدیل این کلاس Utils به Kotlin با استفاده از تبدیل خودکار ارائه شده توسط IDE شروع کنید. خروجی نمونه ممکن است شبیه به موارد زیر باشد:
package com.java.project
object StringUtils {
fun foo(receiver: String): String {
return receiver...; // Transform the receiver in some way
}
fun bar(receiver: String): String {
return receiver...; // Transform the receiver in some way
}
}
در مرحله بعد، تعریف کلاس یا شی را حذف کنید، پیشوند نام هر تابع را با نوعی که این تابع باید روی آن اعمال شود قرار دهید و از آن برای ارجاع به نوع داخل تابع استفاده کنید، همانطور که در مثال زیر نشان داده شده است:
package com.java.project
fun String.foo(): String {
return this...; // Transform the receiver in some way
}
fun String.bar(): String {
return this...; // Transform the receiver in some way
}
در نهایت، همانطور که در مثال زیر نشان داده شده است، یک حاشیه نویسی JvmName به بالای فایل منبع اضافه کنید تا نام کامپایل شده با بقیه برنامه شما سازگار شود:
@file:JvmName("StringUtils")
package com.java.project
...
نسخه نهایی باید شبیه به زیر باشد:
@file:JvmName("StringUtils")
package com.java.project
fun String.foo(): String {
return this...; // Transform `this` string in some way
}
fun String.bar(): String {
return this...; // Transform `this` string in some way
}
توجه داشته باشید که اکنون می توان این توابع را با استفاده از جاوا یا کاتلین با قراردادهایی که با هر زبان مطابقت دارند فراخوانی کرد.
... val myString: String = ... val fooString = myString.foo() ...
... String myString = ... String fooString = StringUtils.foo(myString); ...
هنگامی که تیم شما با Kotlin راحت شد و مناطق کوچک‌تری را مهاجرت کردید، می‌توانید به سراغ اجزای بزرگ‌تر مانند قطعات، فعالیت‌ها، اشیاء ViewModel و سایر کلاس‌هایی بروید که به منطق تجاری مرتبط هستند.
مانند جاوا که سبک خاصی دارد، کاتلین نیز سبک اصطلاحی خود را دارد که به موجز بودن آن کمک می کند. با این حال، ممکن است در ابتدا متوجه شوید که کد Kotlin که تیم شما تولید می کند بیشتر شبیه کد جاوا است که جایگزین آن می شود. این در طول زمان با رشد تجربه تیم شما در Kotlin تغییر می کند. به یاد داشته باشید، تغییر تدریجی کلید موفقیت است.
در اینجا چند کار وجود دارد که می توانید برای دستیابی به یکپارچگی با رشد پایه کد Kotlin خود انجام دهید:
مطمئن شوید که در مراحل اولیه پذیرش، مجموعه استانداردی از قراردادهای کدگذاری را تعریف کنید. شما می توانید از راهنمای سبک Android Kotlin که در آن منطقی است، فاصله بگیرید.
با استفاده از Android lint و سایر ابزارهای تجزیه و تحلیل استاتیک، استانداردهای کدگذاری تعیین شده برای تیم خود را اجرا کنید. klint ، یک لنتر شخص ثالث Kotlin، همچنین قوانین اضافی را برای Kotlin ارائه می‌کند.
مطمئن شوید که با استانداردهای رایج کدنویسی مطابقت دارید و پوشش آزمایشی کافی برای کد Kotlin خود ارائه دهید. ساختن این بخشی از فرآیند ساخت خودکار می‌تواند به اطمینان از ثبات و پایبندی به این استانداردها کمک کند.
کاتلین در اکثر موارد به طور یکپارچه با جاوا کار می کند، اما به موارد زیر توجه کنید.
Kotlin برای استنباط پوچ بودن در سمت Kotlin به حاشیه نویسی های پوچ بودن در کدهای کامپایل شده متکی است. اگر حاشیه نویسی ارائه نشود، Kotlin به طور پیش فرض یک نوع پلتفرم را انتخاب می کند که می تواند به عنوان نوع تهی یا غیر قابل تهی در نظر گرفته شود. این می تواند منجر به مشکلات NullPointerException در زمان اجرا شود، با این حال، اگر به دقت درمان نشود.
کاتلین تعداد زیادی کتابخانه جدید و قند نحوی برای کاهش دیگ بخار فراهم می کند که به افزایش سرعت توسعه کمک می کند. گفته شد، هنگام استفاده از توابع استاندارد کتابخانه کاتلین، مانند توابع مجموعه ، کوروتین ها و لامبداها محتاط و روشمند باشید.
در اینجا یک دام بسیار رایج است که توسعه دهندگان جدیدتر Kotlin با آن مواجه می شوند. کد Kotlin زیر را در نظر بگیرید:
val nullableFoo: Foo? = ...
// This lambda executes only if nullableFoo is not null
// and `foo` is of the non-nullable Foo type
nullableFoo?.let { foo ->
foo.baz()
foo.zap()
}
هدف در این مثال اجرای foo.baz() و foo.zap() در صورتی که nullableFoo null نباشد، در نتیجه از NullPointerException اجتناب می شود. در حالی که این کد همانطور که انتظار می رود کار می کند، خواندن آن نسبت به یک چک ساده و ارسال هوشمند ساده تر است، همانطور که در مثال زیر نشان داده شده است:
val nullableFoo: Foo? = null
if (nullableFoo != null) {
nullableFoo.baz() // Using !! or ?. isn't required; the Kotlin compiler infers non-nullability
nullableFoo.zap() // from guard condition; smart casts nullableFoo to Foo inside this block
}
کلاس ها و توابع آنها به طور پیش فرض در Kotlin برای توسعه بسته هستند. شما باید به صراحت کلاس ها و توابعی را که می خواهید زیر کلاس بندی کنید باز کنید. این رفتار یک تصمیم طراحی زبان است که برای ترویج ترکیب به جای ارث انتخاب شده است. کاتلین دارای پشتیبانی داخلی برای اجرای رفتار از طریق تفویض اختیار برای کمک به ساده‌سازی ترکیب است.
این رفتار برای چارچوب‌های تمسخر آمیز مانند Mockito که برای نادیده گرفتن رفتارها در طول آزمایش به پیاده‌سازی رابط یا وراثت متکی هستند، مشکل ایجاد می‌کند. برای تست های واحد، می توانید استفاده از ویژگی Mock Maker Inline Mockito را فعال کنید که به شما امکان می دهد کلاس ها و روش های نهایی را مسخره کنید. همچنین، می‌توانید از افزونه کامپایلر All-Open برای باز کردن هر کلاس Kotlin و اعضای آن که می‌خواهید به عنوان بخشی از فرآیند کامپایل آزمایش کنید، استفاده کنید. مزیت اصلی استفاده از این افزونه این است که هم با تست های واحد و هم با تست های ابزار دقیق کار می کند.
برای اطلاعات بیشتر در مورد استفاده از Kotlin، لینک های زیر را بررسی کنید:
- رویکرد اول کاتلین اندروید
- منابعی برای شروع کار با Kotlin
- منابعی برای کاربران جاوا در حال یادگیری Kotlin
- مسیر یادگیری جاوا به کاتلین ، مجموعه ای از منابع که به برنامه نویسان جاوا کمک می کند تا کوتلین اصطلاحی را یاد بگیرند و بنویسند.