Съдържание

• Kotlin срещу Java, по-късният предлага по-кратък код - без findViewByIds
• Kotlin е нула безопасно по подразбиране
• Функции за удължаване
• Coroutines са първокласни граждани
• Няма проверени изключения
• Родна подкрепа за делегиране
• Класове данни
• Интелигентни отливки
• Поддръжка за конструктори
• Няма поддръжка за неявни разширяващи се реализации
• Библиотеки за обработка на анотации с Kotlin
• Взаимозаменяемост с Java
• Обобщавайки

Java все още може да е първият език за програмиране, който ви идва на ум, когато мислите за Android, но не го правите имам да използвате Java за разработка на Android. Всъщност Kotlin вече е Googleпредпочитанофициален език за Android!

За да научите повече за Java, вземете безплатен уводен курс за Java в Make Android Apps.

Днес Android Studio се доставя с вградена поддръжка на Kotlin, така че създаването на проект за Android, който разбира кода на Котлин, е толкова лесно, колкото да изберете квадратче за отметка в съветника за създаване на проекти на Android Studio. Подкрепата за опция е твърде извънреден, до момента, че сега това решение главно се свежда до предпочитанията.

Но ако направите преминаване от Java към Котлин, какво точно печелите? Какви функции има Kotlin, че няма Java и обратно?

В тази статия ще разгледаме всички основни разлики между Kotlin срещу Java.

Kotlin срещу Java, по-късният предлага по-кратък код - без findViewByIds

Ако сравните клас Kotlin и клас Java, които изпълняват една и съща работа, тогава класът Kotlin като цяло ще бъде много по-сбит, но има една област, по-специално една от които Kotlin може сериозно да намали количеството код на кокетната плоча, което трябва да напишете: findViewByIds.

Разширенията за Android на Kotlin ви позволяват да импортирате препратка към изглед във вашия файл с активност, в който момент ще можете да работите с този изглед, сякаш е част от дейността. Резултатът? Никога няма да ви се наложи отново да пишете друг метод findViewById!

Преди да можете да използвате тези разширения, ще трябва да добавите допълнителен плъгин към файла на build.gradle на ниво модул (приложите приставка: „kotlin-android-extensions“), но след това сте готови да започнете да импортирате Views, за Например, ако файлът ви Activity_main.xml съдържа TextView с идентификатора textView, тогава ще добавите следното към своята активност:

импортиране kotlinx.android.synthetic.main.activity_main.textView

След това можете да получите достъп до този TextView, използвайки само неговия идентификационен номер:

textView.setText („Здравейте, свят“)

Това е много по-кратък от еквивалента на Java:

TextView text = (TextView) findViewById (R.id.textView); text.setText ("Здравей, свят");

Kotlin е нула безопасно по подразбиране

NullPointerExceptions са огромен източник на неудовлетвореност за разработчиците на Java. Java ви позволява да присвоите нула на която и да е променлива, но ако се опитате да използвате референтен обект, който има нулева стойност, тогава се грижете да се срещнете с NullPointerException!

Прочетете също: Kotiln за Android представяне

В Kotlin всички типове по подразбиране не са нулируеми (не могат да задържат нулева стойност). Ако се опитате да присвоите или върнете нула в своя код на Котлин, той няма да успее по време на компилация, така че нито един от следните редове няма да се компилира:

име име: String = null

fun getName (): String = null

Ако ти наистина ли искате да присвоите нулева стойност на променлива в Kotlin, тогава ще трябва изрично да маркирате тази променлива като нулируема, като добавите въпросителен знак след типа:

номер на val: Int? = нула

Това прави почти невъзможно да се сблъскате с NullPointerExceptions в Котлин - всъщност, ако срещнете това изключение, значи има вероятност, защото изрично сте помолили Kotlin да хвърли такъв, или NullPointerException произхожда от външен Java код.

Функции за удължаване

Kotlin дава на разработчиците възможност да разширяват клас с нова функционалност, което е идеално, ако има клас, за който винаги сте чувствали, че липсва важен метод!

Тези „функции за разширение“ не са налични в Java, въпреки че са налични на други езици за програмиране, които можете да използвате за разработка на Android, като например C #.

Прочетете следващо: Урок за Java за начинаещи

Вие създавате функция за разширение, като префиксирате името на класа, който искате да разширите (например „String“), към името на функцията, която създавате („styleString“), например:

fun String.styleString (): String {// Оформете низа и го върнете //}

След това можете да извикате тази функция в екземпляри от разширения клас, чрез. нотация, сякаш е част от този клас:

myString.styleString ()

Coroutines са първокласни граждани

Всеки път, когато инициирате продължителна операция, като мрежова I / O или интензивна работа на процесора, извикващата нишка се блокира, докато операцията не завърши. Тъй като Android е с една нишка по подразбиране, веднага щом блокирате основната нишка, потребителският интерфейс на приложението ви ще замръзне и той ще остане без отговор, докато операцията не завърши.

В Java традиционно решението е да се създаде фонова нишка, където можете да извършвате тази интензивна или продължителна работа, но управлението на множество нишки може да доведе до сложен, склонен към грешки код и създаването на нова нишка е скъпа операция.

Въпреки че можете да създадете допълнителни нишки в Kotlin, можете също да използвате coututine. Coroutines изпълняват дългосрочни и интензивни задачи, като спират изпълнението в определена точка, без да блокират нишката, и след това възобновяват тази функция в по-късен момент, вероятно в друга нишка. Това ви позволява да създавате незаблокиращ асинхронен код, който външност синхронен и следователно е по-ясен, сбит и четен от човека. Съвместимостите също са безрезултатни, така че имат по-ниска употреба на памет в сравнение с нишките и те отварят вратата за допълнителни стилове на асинхронно неблокиращо програмиране, като async / чакат.

Няма проверени изключения

Kotlin няма проверени изключения, така че не е нужно да хващате или декларирате изключения.

Дали това е нещо, което ви привлича към Kotlin, или ви кара да искате да се придържате към Java, ще зависи от вашето мнение за проверени изключения, тъй като това е функция, която разделя общността на разработчиците. Ако ви е писнало да опитвате / улавяте блокове, претрупващи вашия Java код, тогава ще сте доволни от този пропуск, но ако откриете, че проверените изключения ви насърчават да мислите за възстановяване на грешки и в крайна сметка ви тласкат към създаване на по-стабилни код, тогава е по-вероятно да видите това като област, в която Java има ръба над Kotlin.

Родна подкрепа за делегиране

Kotlin, за разлика от Java, поддържа модела на проектиране на „композиция над наследяване“ чрез първокласна делегация (понякога известна като неявно делегиране). Делегирането е, когато получаващият обект делегира операции на втори делегиран обект, който е помощен обект с оригиналния контекст.

Делегирането на класа на Котлин е алтернатива на наследяването, която прави възможно използването на множество наследявания. Междувременно делегираните свойства на Kotlin помагат да се предотврати дублирането на код, например, ако трябва да използвате повторно един и същ код за получатели и задачи на няколко свойства, след това можете да извлечете този код в делегирана собственост. Делегатът на свойства трябва да дефинира функцията на оператора getValue и, по избор, оператора setValue:

клас делегат {оператор забавно getValue (...) ... ... ...} оператор забавно setValue (...) ... ... ...}}

След това, когато създавате свойство, можете да декларирате, че функциите за получаване и настройка за този конкретен имот се обработват от друг клас:

клас MyClass {var property: String by Delegate ()}

Класове данни

Не е необичайно проектът да има множество класове, които не правят нищо друго освен да съхраняват данни. В Java ще откриете, че пишете много кодови кодове за тези класове, въпреки че самите класове имат много малко функционалност. Обикновено ще трябва да дефинирате конструктор, полета, за да съхранявате функциите за данни, getter и setter за всяко поле, плюс hashCode (), equals () и toString () функции.

В Kotlin, ако включите ключовата дума „data“ в дефиницията на вашия клас, тогава компилаторът ще извърши цялата тази работа за вас, включително генериране на всички необходими получатели и сетери:

дата клас клас (var месец: String, var day: Int)

Интелигентни отливки

В Java често се налага да проверявате типа и след това да хвърляте обект в ситуации, когато вече е ясно, че обектът може да бъде предаван.

Умните роли на Kotlin могат да се справят с тези излишни кастинги за вас, така че не е необходимо да въвеждате вътре в изявление, ако вече сте го проверили с оператора на Kotlin 'е'. Например компилаторът знае, че следният състав е безопасен:

ако (здравей е String) {printString (здравей)}

Поддръжка за конструктори

За разлика от Java, клас Kotlin може да има първичен конструктор и един или повече вторични конструктори, които създавате, като ги включвате в своята декларация за клас:

клас конструктор MainActivity (firstName: String) {}

Няма поддръжка за неявни разширяващи се реализации

Kotlin не поддържа неявни разширяващи се конверсии за числа, така че по-малките типове не се превръщат косвено в по-големи типове. В Kotlin, ако искате да присвоите стойност на тип Byte на Int променлива, ще трябва да извършите изрично преобразуване, докато Java има поддръжка за неявни преобразувания.

Библиотеки за обработка на анотации с Kotlin

Kotlin поддържа всички съществуващи рамки и библиотеки на Java, включително разширени рамки, които разчитат на обработка на пояснения, въпреки че някои Java библиотеки вече предоставят разширения на Kotlin, като например RxKotlin.

Ако искате да използвате Java библиотека, която разчита на обработката на пояснения, добавянето й към вашия проект на Kotlin е малко по-различно, тъй като ще трябва да определите зависимостта, като използвате Kotlin-kapt плъгин и след това използвайте инструмента за обработка на анотации Kotlin (kapt) вместо annotationProcessor. Например:

// Прилагане на приставката // прилагане на приставка: kotlin-kapt // Добавяне на съответните зависимости, като се използва конфигурацията на kapt // зависимости {kapt "com.google.dagger: dagger-компилатор: $ dagger-версия" ... ... ...}

Взаимозаменяемост с Java

Когато обсъждате дали да използвате Kotlin или Java за разработка на Android, трябва да знаете, че има трета опция: използвайте и двете, Въпреки всички разлики между двата езика, Java и Kotlin са 100% оперативно съвместими. Можете да се обадите на Котлин код от Java и можете да се обадите на Java код от Kotlin, така че е възможно да имате класове Kotlin и Java едно до друго в рамките на един и същ проект и всичко пак ще се компилира.

Тази гъвкавост за придвижване между двата езика е полезна, когато започвате с Kotlin, тъй като ви позволява постепенно да въвеждате Kotlin в съществуващ проект, но можете също да предпочитате да използвате и двата езика за постоянно. Например, може да има определени функции, които предпочитате да пишете в Kotlin, както и определени функции, които ви е по-лесно да пишете на Java. Тъй като Kotlin и Java се компилират към байт код, вашите крайни потребители няма да могат да кажат къде свършва вашият Java код и започва Котлин кодът, така че няма причина да не можете да пуснете приложение, което се състои от Java и Котлин код.

Ако искате да опитате Kotlin за себе си, тогава докато имате инсталиран Android Studio 3.0 Preview или по-нова версия, има няколко начина, по които можете да започнете:

• Създайте нов проект за Android Studio. Най-лесният метод е да създадете нов проект и да поставите отметка в квадратчето „Включване на поддръжката на Котлин“ от съветника за създаване на проект.

• Добавете клас Kotlin към съществуваща директория. Щракнете върху контролния бутон върху въпросната директория, след което изберете „Файл> Нов> Файл / клас на Kotlin.“ Android Studio ще покаже банер с молба да конфигурирате проекта си, за да поддържа Kotlin; щракнете върху връзката „Конфигуриране“ и следвайте екранните инструкции.

• Конвертирайте съществуващи Java файлове в Kotlin. Можете да стартирате всеки Java файл чрез конвертор на Kotlin, като щракнете върху Control и щракнете върху файла и изберете „Code> Convert Java File to Kotlin File.“

Обобщавайки

Както можете да видите, има много добри причини да предпочитате Котлин пред Ява, но има няколко области, в които Java има горната ръка. Може би най-забележителното: много разработчици на Android са просто по-запознати с Java в този момент. Вероятно дебатът Котлин срещу Ява няма да се уреди скоро, като и двете имат своите заслуги. И така, ще преминете ли към Котлин или смятате, че Java все още е най-добрият вариант за разработка на Android?

Прочетете следващо: Въведение в синтаксиса на Java за разработка на Android