Урок за Kotlin за начинаещи (примери)

История на Kotlin

Ето важни забележителности от историята на Котлин:

година	събитие
2016	Беше пуснат Kotlin v1.0
2017	Съобщение на Google за първокласната поддръжка на kotlin в android
2018	Kotlin v1.2 идва с добавка за разпространение на кодове между JVM и JavaСценарий
2019	Google обяви Kotlin за свой предпочитан програмен език за Android Разработчици на приложения
2021	На 20 септември 2021 г. стартира Kotlin v1.5.31.

Причини за използване на Kotlin

Ето някои важни причини, поради които Kotlin се използва широко:

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

Характеристики на Kotlin

Ето няколко функции на Kotlin, които ще ви направят сигурни в пътя на напредъка на езика за програмиране.

Съкратено кодиране:

Kotlin е базиран на OOPs език за програмиране, където кодовата линия може да бъде съкратена до 40%, което прави Kotlin идеален избор за софтуер или уеб разработка.

Отворен код:

Котлин за Android използва JVM и съчетава функциите на ООП и функционално-ориентирано програмиране.

Бърза компилация:

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

Функции за разширение:

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

Например:

Fun String.removeFirstLastChar():
String = this.substring(1, this.length -1)

Този код ще помогне при изрязването на първия и последния символ на низа, можем да го приложим като:

Val string1 = "Today is cloudy."
Val string2 = string1.removeFirstLastChar()

Нулева безопасност:

В Kotlin системата прави разлика между нулеви и ненулеви препратки, както е показано в примера на Kotlin по-долу.

Например, променлива String не може да съдържа нула:

Var string1: String = "Today is Sunday"
String1 = null  // compilation error
To permit null, we can adjoin the nullable variable :
Var string2: String? = "Today is Sunday"
String2 = null
print(string2)

Оперативно съвместим:

Кодът на Kotlin може да се използва от Java, и Java кодовете могат да се използват с Kotlin. Така че, ако имате познания за ООП програмиране, лесно е да преминете към разработката на Kotlin. Освен това, ако има написани приложения Java, тогава те могат да се използват със средата на Kotlin.

Здрави инструменти:

като Java, Кодът на Kotlin може също да бъде написан с помощта на IDE или с помощта на интерфейса на командния ред. Лесно се работи с IDE и синтактичните грешки също са намалени драстично. В същото време, когато работите с интерфейс на командния ред, кодът трябва първо да бъде компилиран.

Smart Cast:

Интелигентното предаване основно помага за намаляване на разходите за приложение и подобрява неговата скорост или производителност. Той работи върху управлението на ефективността на кода, използвайки преобразуване на типове или неизменни стойности.

Например, ако низът е идентифициран, това е неговата дължина и брой и може да бъде намерен с помощта на функцията Smart Cast:

Val string1: Any = "Today is Monday"
when(string1)
{
is String  -> string1.length
Is Int -> string1.inc()
}

Ниска цена на осиновяване:

Kotlin е предпочитан от предприятията поради загубените разходи за осиновяване. Най-важното е, че е лесно за научаване от разработчиците, особено ако имате опит в програмирането.

Настройка на средата на Kotlin

Следват стъпките, които ви помагат да настроите работна среда чрез инсталиране на Kotlin.

Стъпка 1) Инсталирайте Java

Както обсъдихме по-рано, на което се основава Kotlin Java, така че трябва да инсталирате Java първо, когато планирате да приемете Kotlin. Обърнете се към нашите Java Инструкция за инсталиране.

Стъпка 2) Инсталирайте Java ИДЕС

За щастие има множество Java ИДЕС да избирате от. Тук сме дали връзки за изтегляне, за да направим нещата малко по-лесни за вас.

• За да изтеглите Eclipse, Натисни тук.
• За да изтеглите NetBeans, Натисни тук.
• За да изтеглите IntelliJ, Натисни тук.

В този урок за Kotlin ще използваме Eclipse.

Стъпка 3) Инсталирайте Kotlin

За инсталиране на Kotlin в Eclipse, отидете в секцията Помощ в Eclipse и кликнете върху Eclipse Опция Marketplace.

Сега въведете ключовата дума Kotlin в полето за търсене. Щракнете върху опцията Go, за да видите приставката. Ще ви даде връзка към приставката Kotlin, трябва да инсталирате приставката от дадената връзка.

Моля, рестартирайте Eclipse IDE, след като инсталацията приключи. Можете да намерите икона за пряк път в горния десен ъгъл на Eclipse IDE. Това е метод за бърз достъп.

Друг начин за достъп до Kotlin Eclipse IDE е, отидете на Windows, Перспективи, Отворете перспективи, след което изберете опция Други. Тук можете да проверите списък с плъгини, инсталирани по-късно, както е дадено по-долу.

След като проверите инсталацията на Kotlin, нека създадем първата програма Kotlin в следващата стъпка.

Стъпка 4) Първа програма Kotlin

Започнете с първия си проект в Kotlin. От менюто Файл изберете опцията Нов, след това изберете други и започнете с нов проект на Kotlin от списъка.

Сега трябва да дефинирате име за проекта и сте готови да работите с Kotlin.

С тези прости стъпки изтеглянето е лесно Eclipse и Kotlin на вашата система и напишете първата си програма Kotlin веднага.

Archiструктура на Kotlin

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

Съчетанията и класовете на Kotlin проектират ядрото по такъв начин, че да произвеждат по-малко шаблонен код, да увеличат производителността и да засилят ефективността. Има различни сценарии, при които компилаторът на kotlin може да реагира по различен начин, особено когато е предназначен за различни видове езици.

В диаграмата на архитектурата е ясно, че изпълнението на кода се извършва в три лесни стъпки.

1. В първата стъпка „.kt“ или файлът kotlin се добавя към компилатора.
2. Във втората стъпка компилаторът на Kotlin преобразува кода в байт код.
3. В третата стъпка се въвежда байт код Java Виртуална машина и се изпълнява от JVM.

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

Проявяването на Kotlin към JavaСкриптът се случва, когато Kotlin се насочва JavaСценарий.

Когато JavaЦелта на скрипта е избрана, всеки код на Kotlin, който е част от библиотеката, която плава с Kotlin, се разлива с JavaСкрипт. Въпреки това, Java Комплектът за разработка (JDK) или която и да е използвана библиотека на Java е изключена.

Файл, различен от Kotlin, не се взема под внимание по време на такава операция. Докато се насочвате JavaФайлът .kt на скрипта се преобразува в ES5.1 от компилатора на Kotlin, за да генерира последователен код за JavaСкрипт. Компилаторът Kotlin се стреми към оптимален изходен размер, оперативна съвместимост със съществуващ модул, същата функционалност със стандартната библиотека и изход, който е JavaЧетим скрипт.

От дискусията става ясно, че компилаторите на Kotlin могат да създадат по-ефективен, компетентен и независим код, който допълнително води до високоефективен софтуерен продукт.

Котлинска променлива

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

В Kotlin всички променливи трябва да бъдат декларирани. Въпреки това, ако някоя променлива не е декларирана, тогава тя изскача като синтактична грешка. Освен това декларацията на променливата определя типа данни, които позволяваме да съхраняваме в променливата. В Kotlin променливите могат да бъдат дефинирани с помощта на ключови думи val и var. Ето синтаксиса за деклариране на променливи в Kotlin:

Var day = "Monday"
Var number = 3

Тук сме декларирали локалната променлива day, чиято стойност е "Monday' и чийто тип е String и друга локална променлива число, чиято стойност е 3 и чийто тип е Int, защото тук литерала е от тип цяло число, което е 3.

Локалните променливи обикновено се декларират и инициализират едновременно. Можем също да извършваме определени операции, докато инициализираме променливата Kotlin.

Можем да извършим операция върху променлива от същия тип данни, както тук num1 и num2 са от един и същ тип данни, който е Int, докато day е от тип данни за низ. Следователно, ще покаже грешка. Ето още една техника как можете да дефинирате променливи в Kotlin.

var day : String = "GURU99"
var num : Int = 100

Нека видим как ключовите думи var и val се различават една от друга.

Променлива:

Var е като обща променлива, използвана във всеки език за програмиране, която може да се използва многократно в една програма. Освен това можете да промените стойността му по всяко време в дадена програма. Следователно тя е известна като променливата променлива.

Ето пример за променлива променлива в Kotlin:

var num1 = 10
Var num2 = 20
Num1 = 20
print(num1 + num2) // output : 40

Тук стойността на num1, която е 20, се презаписва от предишната стойност на num1, която е 10. Следователно изходът на num1 + num2 е 40 вместо 30.

Стойност:

Val е като постоянна променлива и не можете да промените нейната стойност по-късно в програмата, която също не може да бъде присвоена многократно в една програма и може да се използва само веднъж в определена програма. Следователно, той е известен като неизменна променлива.

Ето примерна програма на Kotlin за неизменни променливи в Kotlin:

Val num1 = 10
Var num2 = 20

Тук стойността на num1, която е 10, не може да бъде презаписана от новата стойност на num1, която е 20, тъй като е от тип val, който е постоянен. Следователно изходът е 30 вместо 40.

Забележка: В Kotlin неизменните променливи се предпочитат пред променливите променливи.

Типове данни в Kotlin

Типовете данни са набор от относими стойности и описват операциите, които могат да бъдат оперирани с тях. Подобно на други езици за програмиране, Kotlin също има свой предварително дефиниран набор от типове данни като Int, Boolean, Char, DoubleИ др

В Kotlin всеки тип данни се счита за обект.

Сега в този основен урок за Kotlin, нека се потопим по-дълбоко в предварително дефинираните типове данни, използвани в Kotlin.

Numbers :

Kotlin обслужва набор от вградени типове данни, известни като числа, които са подкатегоризирани като цели числа и плаваща запетая Numbers.

Цели числа:

Целите числа са категория числа, която има четири вида:

Тип	Размер (бита)	Минимална стойност	Максимална стойност
Байт	8	-128	127
Къс	16	-32768	32767
Int	32	-2,147,483,648 (-231)	2,147,483,647 (231 - 1)
Дълга	64	-9,223,372,036,854,775,808 (-263)	9,223,372,036,854,775,807 (263 - 1)

Плаваща точка Numbers :

Плаваща точка Numbers са нецелите числа, които носят някои десетични стойности.

Float: Float е 32-битова стойност с плаваща запетая с единична точност.

Пример: var: Float x = 3.25600

Double: Double е 64-битова стойност с плаваща запетая с двойна точност.

Пример: var: Double у = 2456.345587

булеви стойности:

Типът данни Booleans в Kotlin е важен за представяне на логическите стойности. Има само две възможни стойности в Boolean, които са или true, или false.

Например: val ден = вярно

Вал ден2 = невярно

Характер:

Символите в Kotlin се представят с помощта на ключовата дума, наречена char. В Kotlin единичните кавички представляват декларацията на char. В java char понякога се използват като числа, което не е възможно в kotlin.

Например:

val onechar = 'x'
print(onechar) //  output : x
Val onedigit = '7'
print(onedigit) // output : 7

Преобразуване на тип Kotlin или преобразуване на тип Kotlin

Преобразуването на тип е процедура за преобразуване на един тип променлива от данни в друга променлива от тип данни. Той е огромен, известен също като Type Casting.

Изключително, в Java, се поддържа неявен тип преобразуване на тип или неявен тип преобразуване на по-малък тип данни към по-голям тип данни.

For Example : int abc = 15;
Long bcd = abc; // compiles successfully

Въпреки това, в kotlin неявното преобразуване на по-малък тип данни в по-голям тип данни изобщо не се поддържа, тъй като типът данни int не може да се преобразува имплицитно в дълъг тип данни.

For Example : var abc = 15
Val bcd : Long = abc // error

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

Има определени помощни функции, които са предварително притежавани за преобразуване на един тип данни в друг:

toInt()

toByte()

toShort()

toChar()

toLong()

toFloat()

да сеDouble()

For Example : var abc = 15
Val bcd : Long = abc.toLong() // compiles successfully

Kotlin Operaтори

Operator са важни и специални знаци или символи, които гарантират операциите в операндите, които имат променливи и стойности. В Kotlin има набор от оператори, които се използват в различни операции като аритметични операции, операции за присвояване, операции за сравнение и т.н.

аритметика OperaТорс:

Аритметичните оператори се използват за събиране, изваждане, умножение, деление и модул.

OperaTor	Значение
+	Добавяне (използвано също за конкатенация на низове)
-	Изваждане OperaTor
*	Умножение OperaTor
/	делене OperaTor
%	Модул OperaTor

Например:

var x = 10
var y = 20
var z = ( ( x + y ) * ( x + y ) ) / 2     

Тук резултатът от следния код е 45.

сравнение OperaТорс:

Операторът за сравнение се използва за сравняване на две стойности, две променливи или две числа. Използва се със символа по-голямо от ( > ), по-малко от символ ( < ) и равно на символ ( ==), не е равно на символ ( != ), по-голямо от равно на символ ( >= ), по-малко от равно на символ (<=). Винаги води до вярно или невярно.

Например:

var x = 10
Var y =20
Var z = x < y // Output : true
Var w = x > y // Output : false
Var m = x == y // Output : false

Задание OperaТорс:

Задание Operators се използват за присвояване на аритметично управляваните стойности. Използва се със символи като +=, -=, *=, /=, %=.

Например:

var x = 10
var y = 20
var x + = y // Output : 30
Var y - = x // Output : 10
Var x * = y // Output : 200

Увеличаване и намаляване OperaТорс:

Операторите за увеличаване и намаляване се използват за увеличаване и намаляване на стойностите на променливата или числото. Използва се с помощта на символи като ++ и —.

Има два вида увеличение и намаление, които са преди увеличение ++a, след увеличение a++, предварително намаление –b, след намаление b–.

Например:

var a = 10
var b = 20
var c = a++ // Output: 11
var d = b— //Output : 19     

Kotlin масиви

Масивът е хомогенен набор от типове данни и е един от най-фундаменталните типове данни, който се използва за съхраняване на едни и същи типове данни в местоположението на непрекъснатата памет. Масивът е важен за организирането на данни във всеки език за програмиране, така че множеството данни, съхранени на едно място, са лесни за търсене или сортиране.

В Kotlin масивите са променлива съвместна работа на едни и същи типове данни, а не са естествени типове данни.

Ето някои свойства на масив в Kotlin

• Размерът на масива не може да бъде променен, след като бъде деклариран.
• Масивите в Kotlin са променливи.
• Масивите се съхраняват в съседни места в паметта.
• Един масив може да бъде достъпен с помощта на индекси като a[1], a[2] и т.н.
• Индексът на масив започва с нула, която е [0].

В Kotlin един масив може да бъде дефиниран по два различни метода

Чрез използване на функцията arrayOf():

В Kotlin има широко използване на библиотечни функции. Една такава библиотечна функция е функцията arrayOf(), която се използва за дефиниране на масив чрез предаване на стойностите на променливите към функцията.

Например: Неявна декларация на тип на масив с помощта на функцията arrayOf().

val x = arrayOf(1,2,3,4,5,6,7,8,9)

Например: Изрично въведете декларация на масив с помощта на функцията arrayOf().

Val y = arrayOf<Int>(1,2,3,4,5,6,7,8,9)

Чрез използване на конструктор на масиви:

В Kotlin има клас с името Array. Следователно е възможно да се използва масив от конструктора за създаване на масив. Масивът в конструктора съдържа два основни параметъра.

Какво представлява индексът на масив в Kotlin?

Функцията, при която индексът на масив е приемлив за връщане на първоначалната стойност на индекса.

Например:

val abc = Array(7 , { i -> i*1})

Тук стойността на масива е 7 и ламбда изразът се използва за инициализиране на стойностите на елемента.

Съществуват и различни методи за достъп и модифициране на масивите с помощта на определени функции. Следователно има две членски функции get() и set(), които се използват за достъп до обектите на масива на класа.

Например:

val x = arrayOf(10,20,30,40,50,60,70,80,90)
val y = x.get(0) // Output 10

Тук изходът е 10, тъй като стойността при индекс 0 на масива е 10

Забележка: get() приема само единични стойности

Например:

val x = arrayOf(10,20,30,40,50,60,70.80.90)
val y = x.set(2, 3) //

Изход: 30 40

Тук изходът е 30 и 40, тъй като стойността при индекс 2 на масива е 30, а при индекс 3 е 40.

Забележка: set() приема множество стойности на масив.

Kotlin струни

Низът е основен тип данни във всеки език за програмиране. Низът не е нищо друго освен поредица от знаци. Класът String представлява символни низове. В Kotlin всички низове са обекти от класа String, което означава, че низовите литерали са имплементирани като екземпляри на класа.

Синтаксис:

 Val myString = "Hey there!"

Колекция Kotlin

Една колекция съдържа няколко обекта от подобен тип и тези обекти в колекцията се наричат ​​елементи или елементи. Събирането може да помогне за съхраняване, извличане, манипулиране и обобщаване на данни.

Видове колекции:

Неизменна колекция

Този тип колекция поддържа функции само за четене. Човек не може да променя елементите му.

Методите включват:

• Списък – listOf() и listOf ()
• Set – setOf()
• Карта – mapOf()

Променлива колекция

Поддържа функции както за четене, така и за запис.

Методите включват

• Списък – promenableListOf(),arrayListOf() и ArrayList
• Задайте – promenljivSetOf(), hashSetOf()
• Карта – mutableMapOf(), hashMapOf() и HashMap

Функции на Kotlin

Функциите във всеки език за програмиране са група от подобни оператори, които са предназначени да изпълняват конкретна задача. Функциите позволяват на програмата да го раздели на различни малки кодови блокове. Това разделяне на кода увеличава четливостта на кода, повторното използване на кода и прави програмата лесна за управление.

Тъй като Kotlin е известен като статично типизиран език. Тук ключовата дума 'fun' се използва за деклариране на функция. В Kotlin има два типа функции, които зависят единствено от тяхната наличност в стандартната библиотека или потребителска дефиниция. Те са:

• Стандартна библиотечна функция
• Дефинирана от потребителя функция

Сега нека ги обсъдим подробно с примери за код на Kotlin.

Стандартна библиотечна функция

Те са вградени библиотечни функции, които могат да бъдат дефинирани имплицитно и достъпни за използване.

За пример 2:

fun main(args: Array<String>){  
var number = 9  
var result = Math.sqrt(number.toDouble())  
print("$result")  
}  

Изход:

3.0

sqrt() е функция, дефинирана в библиотеката, която връща корен квадратен от число.

функцията print() отпечатва съобщение в стандартен изходен поток.

Дефинирана от потребителя функция

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

Тук функциите се декларират с помощта на ключовата дума „забавление“.

За пример 3:

fun functionName(){
//body of the code
}

Тук извикваме функцията за изпълнение на кодове вътре в тялото functionName()

Примери за функции на Kotlin:

fun main(args: Array<String>){  
    sum()  
    print("code after sum")  
}  
fun sum(){  
    var num1 =8  
    var num2 = 9  
    println("sum = "+(num1+num2))  
}  

Изход:

сума = 17

код след сума

Обработка на изключения в Kotlin

Изключението в програмирането се определя като проблем по време на изпълнение, който възниква в програмата, което води до нейното прекратяване. Този проблем може да възникне поради по-малко място в паметта, необвързан масив, условия като деление на нула. За ограничаване на тези видове проблеми при изпълнение на код се използва обработка на изключения.

Обработката на изключения се определя като техника, която се справя с проблемите по време на изпълнение и също така поддържа потока на програмата по време на изпълнение.

Kotlin използва израза 'throw', за да хвърли обект на изключение. Тук всички класове изключения са наследници на класа Throwable.

Throw MyException("хвърля изключение")

Има четири вида изключения при обработката на изключения. Те са:

• try – Този блок съдържа изрази, които могат да създадат изключение. Винаги е последвано от catch или finally или и двете.
• catch – улавя изключение, хвърлено от блока try.
• накрая – Винаги проверява дали изключението е обработено или не.
• хвърляне – Използва се за изрично хвърляне на изключение.

Опитайте да уловите:

В блока try-catch при обработка на изключения блокът try обхваща кода, който може да хвърли изключение, а блокът catch улавя израза и го обработва.

Синтаксис на блока try catch:

try{    
//code with exception    
}catch(e: SomeException){  
//code handling exception  
}    

Синтаксис на try с finally блок

try{    
//code with exception    
}finally{  
// code finally block  
}   

И накрая:

В Kolin finally block винаги проверява дали изключението е обработено или не, което го прави много важно изявление за обработка на изключение.

За пример 4:

В този кодов фрагмент възниква изключение и то се обработва.

fun main (args: Array<String>){  
    try {  	
        val data =  9/ 0  
        println(data)  
    } catch (e: ArithmeticException) {  
        println(e)  
    } finally {  
        println("finally block executes")  
    }  
    println("write next code")  
}  

Изход:

java.lang.ArithmeticException: / by zero
finally block executes
write next code

Хвърли:

Throw block хвърля изрично изключение. Освен това се използва за хвърляне на персонализирани изключения.

Синтаксис:

Throw SomeException()

Throw SomeException()

Пример:

fun main(args: Array<String>) {
    try{
        println("Exception is not thrown yet")
        throw Exception("Everything is not well")
        println("Exception is thrown")
    }
    catch(e: Exception){
        println(e)

    }
    finally{
        println("You can't ignore me")
    }
}

Изход:

Kotlin Null Safety

Типовете системи, които поддържат Kotlin, основно разграничават препратките, които могат да носят nullable препратки, и тези, които не могат да носят nullable препратки. Kotlin е нулев защитен език, чиято цел е да елиминира изключението за нулев указател или нулева препратка от кода, който умишлено е известен като A Billйонна грешка в долара.

Най-традиционният препъни камък от много програмни езици е, че докато осъществявате достъп до член на нулева препратка, това води до NullPointerException, което може да се дължи на !! оператор или този конструктор, използван някъде другаде и предаден в друга точка от кода. Свойството nullable изисква потвърждение за проверката null всеки път преди използването му.

В Kotlin системата прави разлика между нулеви и ненулеви препратки.

Например, променлива String не може да съдържа нула:

За пример 5:

fun main(args: Array<String>){
    var x: String = "GURU99 is the only place where you will get maximum technical content!" // Not Null by default
    println("x is : $x")
    // You cannot assign null variable to not-nullable variables 
    // a=null // it will give compilation error
    var y: String? = "Thanks for visiting GURU99" 
// Nullable Variable
    println("y is : $y")
    y = null
    println("y is : $y")
}

Изход:

Kotlin OOPs

Обектно-ориентираният програмен подход позволява сложен кодов фрагмент да се раздели на по-малки кодови блокове чрез създаване на обекти. Тези обекти взаимно споделят две характеристики: състояние и поведение.

Ето някои от OOP елементите, които ще обсъдим с примери за код на Kotlin:

• Клас и обекти
• конструкторите
• наследяване
• Абстрактен клас

Клас в Котлин

Първо, преди да създадем обект, трябва да дефинираме клас, който е известен също като план за обекта.

Синтаксис:

class ClassName {
    // property
    // member function
    ... .. ...
}

Обекти в Kotlin

Докато дефинираме клас, ние дефинираме само спецификациите за обекта, не се разпределя друг параметър като памет или съхранение.

Синтаксис:

var obj1 = ClassName()

Конструктори в Котлин

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

В Kotlin има два типа конструктори:

Основен конструктор: Оптимизиран начин за инициализиране на клас

Синтаксис:

class myClass(valname: String,varid: Int) {  
    // class body  
}  

Вторичен конструктор: Помага за добавяне на логика за инициализация

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

Наследяването възниква, когато някои свойства на родителския клас са придобити от дъщерния клас. Наследяването е разрешено, когато два или повече класа имат еднакви свойства.

Синтаксис:

open class ParentClass(primary_construct){
    // common code
  }class ChildClass(primary_construct): ParentClass(primary_construct_initializ){
    // ChildClass specific behaviours
  }

Абстрактен клас в Kotlin

Абстрактен клас е клас, който не може да бъде създаден, но можем да наследим подкласове от тях. Ключовата дума 'abstract' се използва за деклариране на абстрактен клас.

За пример 6:

  open class humanbeings { 
    open fun Eat() { 
        println("All Human being Eat") 
    } 
} 
abstract class Animal : humanbeings() { 
    override abstract fun Eat() 
} 
class Cat: Animal(){ 
    override fun Eat() { 
        println("Cats also loves eating") 
    } 
} 
fun main(args: Array<String>){ 
    val lt = humanbeings() 
    lt.Eat() 
    val d = Cat() 
    d.Eat() 
} 

Изход:

Настоящето и бъдещето на Kotlin

Настоящето:

• Много компании харесват Netflix, Pinterest и Corda използват Kotlin, за да създават мощни Android Приложения.
• За кратък период от една година, от 2016 до 2017 г., Kotlin стана изключително популярен с невероятни функции за програмиране.
• През 2017 г. Google обяви Kotlin като официален език за програмиране за разработка на Android.
• Можете бързо да замените Java код с Kotlin, тъй като е 100% оперативно съвместим с Java намлява Android.

Бъдещето:

• Разработка на игри на различни платформи
• Разработка на различни платформи за мобилни приложения
• Скриптове от страна на услугата и микроуслуги
• машина обучение & Анализ на данни

Oбобщение

• Kotlin е език за програмиране, предложен от JetBrains през 2010 г. за мултиплатформени приложения под лиценза Apache 2.0.
• Името Kotlin произлиза от името на остров Kotlin в подобна кореспонденция на Java по името на остров, наречен Ява.
• През 2016 г. беше пусната първата версия v1.0 на Kotlin
• Програмите на Kotlin не изискват точка и запетая в програмата си. Това прави кода лесен и по-четим.
• Котлин за Android developers е базиран на OOPs език за програмиране, където кодовата линия може да бъде съкратена до 40%, което прави Kotlin идеален избор за софтуер или уеб разработка.
• В Kotlin всички променливи трябва да бъдат декларирани с помощта на ключови думи var и val.
• Подобно на други езици за програмиране, Kotlin също има свой предварително дефиниран набор от типове данни като Int, Boolean, Char, DoubleИ др
• В Kotlin има набор от оператори, които се използват в различни операции като аритметични операции, операции за присвояване, операции за сравнение и т.н.
• В Kotlin масивите са променлива съвместна работа на едни и същи типове данни, а не са естествени типове данни.
• В Kotlin масивите се дефинират с помощта на два метода – ArrayOF () и Constructors.
• Kotlin е език за нулева безопасност, който помага да се премахне изключението за нулев указател или нулева препратка от кода, който умишлено се нарича A Billйонна грешка в долара.