Kotlin’e Giriş

Herkese merhaba ilk yazımda sizlerle birlikte Kotlin’e giriş yapacağız. Çok fazla detaya girmeden yüzeysel olarak:

· Functions

· Variables

· Null Safety

· Classes

· Generics

· Inheritance

kavramlarından bahsedeceğim. Kotlin, yaygın kod hatalarını azaltan ve mevcut uygulamalara kolayca entegre olan etkileyici bir programlama dilidir.

Hazırsak başlayalım 😀

Functions

Kotlin’de basitçe bir fonksiyon tanımlamayı anlatmadan bu işlemin Java’da nasıl olduğunu bir hatırlayalım. Örnek olarak bir toplama fonksiyonunu ele alalım.

int sum(int x,int y){
    return (x+y);
}

Şimdide Kotlin ile aynı işi yapan fonksiyonun nasıl yazıldığını görelim.

fun sum(x: Int, y: Int): Int {
    return x + y                                                           }

Kotlin’de değişken tipi Java’nın aksine değişkenden hemen sonra x : Int veya isim: String şeklinde belirtilir ve fonksiyon isminin başına fun anahtar kelimesi gelir. Burada parametreler ve fonksiyonun geri dönüş tipi int değerindedir ve “:Int” şeklinde belirtilmiştir.

Bu arada her ne kadar eliniz alışmış olsada Kotlin’de ; ’ e gerek olmadan da kodunuzu çalıştırabiliyorsunuz. Yani Error: Expected ‘;’ hatalarına son 😍

Named Arguments(Adlandırılmış Parametreler) ile bir fonksiyonu çağırırken fonksiyonun parametre sıralamasına bağlı kalmadan değişken adlarını belirterek çağırabiliyoruz. Hemen bir örnek ile somutlaştıralım.

fun Person(isim: String, soyisim: String) { 
    println("$isim $soyisim")
}
fun main() {
    Person(soyisim="nur",isim="eda")
}

Output: eda nur

Person fonksiyonu kişi bilgilerini yazdıran parametreleri sırası ile isim ve soyisim olan bir fonksiyon. Main methodumuzun içerisinde bu fonksiyonumuzu çağırırken parametrelerin adlarını belirtip farklı sıralamada da çağırabiliyoruz.

Sırada Infix fonksiyonlar var. Fakat daha önce Extension fonksiyonlardan kısaca bahsetmek istiyorum.

Extension fonksiyonlar kod yazarken bize oldukça kolaylık sağlar. Bir sınıfa yeni bir özellik kazandırmamıza yardım eder. Hemen bir örnek:

fun Int.pow2(): Int {
    return this * this
}
fun main(){
    7.pow2()
}

Output: 49

Buradaki gibi bir extension fonk tanımlarsak main methodu içerisinde bu fonksiyona int bir değerden hemen sonra . koyarak ulaşabiliriz. Artık int classına pow2 adında bir fonksiyon ile int bir sayının karesini alma özelliği kazandırdık.

Infix fonksiyonları tanımlarken de infix anahtar kelimesini ekleriz, oluşturduğumuz infix fonksiyonunu main classında çağırırken ise ortadaki noktaları hayatımızdan çıkartırız 😄

infix fun Int.pow(sayi: Int) : Int{
    return this*sayi
}
fun main(){
    2 pow 3
}

Output: 8

Yazması ve okunabilirliği daha açık ve anlaşılır olan infix fonksiyonları bu örnek ile bitirmiş olalım ve şimdi vararg fonksiyonlarına göz atalım.

Vararg (Variable number of arguments) değişken sayılı parametreye sahip fonksiyona denir. Farklı tiplerde yada değişken sayıda parametre yollayacağımız fonksiyonları bu şekilde yazabiliriz.

fun sum(vararg input: Int): Int {
     var _sum = 0
     for (i in input) {
         _sum += i
     }
     return _sum
 }
 
fun main(){
    println(sum(2,3))
    print(sum(2,3,4,5))
}

Görüldüğü üzre aynı fonksiyona hem 2 hemde 4 değişkenli olacak şekilde çağırım yaptık.

Variables

Kotlinde değişken “var” veya “val” kullanarak tanımlanır. Burada var mutable val ise immutable dır. Yani “var” değişkenine istediğimiz yerde tekrar atama yapabiliyorken “val” tipindeki bir değişkene ilk atamadan sonra tekrar atama yapamayız, değerini değiştiremeyiz.

var isim = "Eda"
val plaka = 34

Burada isim değişkenine yeniden bir atama yapılabilir fakat plaka değişkenine tekrar bir atama yapılamaz.

Değişkenleri bu şekilde tanımlarsak hangi tipde olduğunu bulma işini derleyiciye bırakmış oluruz.Tipini belirterek tanımlama işlemi ise şu şekildedir:

var isim: String =”Eda”
val plaka: Int =34

Yukarıdaki değişkenlerin aynılarını bu kez değişken tipini belirterek tanımladık.

Null Safety

NullPointerException (NPE) hatasını bilen bilir. Belkide en sık aldığımız hatalardan biri bu. Kotlin’in type sistemi, kodumuzdan NullPointerException’ı ortadan kaldırmayı amaçlamaktadır.

Öncelikle NullPointerException’ın bir object referansının null olması durumunda o object referansına ulaşmaya çalışırsak karşımıza çıkan hata olduğunu söyleyelim.

String değisken=null;
if (degisken.equals("string")) {
    ////
}

Bu java kodunda NPE hatasını alırız.

Peki Kotlin’de bu durum nasıl? 👀

Kotlin’de tür sistemi, null tutabilen referanslar ve tutamayanlar arasında ayrım yapar. Örneğin:

var a: String = "text"
a = null  // error

Kotlin’de buradaki a değişkenine null değerini atayamayız. Bu durumda olası bir NPE almamızı önler.

Bu değişkenin null olabilmesine izin vermek için ise null yapılabilir olarak bildirmemiz gerekir. Bunu değişken tipinin yanına “?” koyarak yaparız.

var b: String? = "abc" // null olabilir
b = null 
print(b)

Artık a nın uzunluğunu bulmak istediğimiz zaman a null olamayan bir değişken olduğu için hata almayız fakat aynı kodu b için yazarsak b null olabilir hatası alırız.

val length = a.length  // ok
val length = b.length  // error

Classes

Kotlinde bir class basitçe aşağıdaki gibi tanımlanır.

class Araba{
}

Bu classtan bir nesne üretmek için main fonksiyonuna şu satırı yazabiliriz.

var Araba = Araba()

Burada dikkat etmemiz gereken yer new anahtar kelimesinin olmamasıdır. Kotlin’de primary ve secondary olmak üzere 2 tür constructor(yapıcı) method vardır. Primary constructor şu şekildedir

class Araba constructor(model: String,km: Int) {}

Araba sınıfından nesne üretirken bizden model ve km değerlerini girmemizi bekler.

Secondary constructorın eğer primary constructor varsa ona yetki vermesi gerekir. Bu yetki verme işlemi aşağıdaki gibi this ile yapılır.

class Person(val name: String) {
    var children: MutableList<Person> = mutableListOf<>()
    constructor(name: String, parent: Person) : this(name) {
        parent.children.add(this)
    }
}

Generics

Generics farklı veri türleri kullanılarak erişilebilen sınıfları, yöntemleri ve özellikleri tanımlamamıza izin veren güçlü özelliklerdir. Böylece kod farklı türler boyunca kullanılabilmektedir.

Şimdi öncelikle generic classlara bakalım.

class Araba<T>(var Araba: T){
   ////
}
fun main(){
    val araba: Araba<Int> = Araba<Int>(1)
}

Burada T yerine farklı veri tipleri gelebilir. Bu sınıftan bir nesne oluştururken bunu belirtiriz .

Şimdi de generic fonksiyonlara bakalım. Aynı generic class gibi fonksiyonda da farklı veri tiplerinde çalışması üzere fonksiyon yazmak için kullanırız.

fun <T> myfunction(item: T){
    ///
}

Bu fonksiyonu artık hem int hemde String için kullanabiliriz.

Inheritance

Kotlin nesne yönelimli kalıtım mekanizmasını tam olarak destekler ✔️

open class Ogrenci {    
    open fun hello() {    
        print("hi!")
    }
}

Student classının miras alınabilmesi için class’ın önüne open anahtar kelimesini getiririz. Artık herhangi bir sınıf Student’ı miras alabilir. Aynı şekilde içerisinde bulunan fonksiyonları miras alınan classda override edebilmek içinde fun kelimesinden önce open eklemeliyiz.

class SonSinifOgrencileri: Ogrenci() {  
    override fun hello() {   
        print("hi!!")
    }
}

Student’ dan türeyen bir sınıfı yukarıdaki gibi oluştururuz. Miras aldığı sınıfta hello() metodunu tekrar yazmak için yukarıdaki gibi override ederiz.

fun main() {
    val ayse: Ogrenci = SonSinifOgrencileri()
    ayse.hello()
}

Main methodu içerisinden SonSinifOgrencileri nesnesi ise yukarıdaki gibi oluşturulur.

Parametre içeren bir class’ı nasıl miras alabileceğimize bakalım.

open class Person(val age: Int) {
    fun say() {
        print("I am $age years old.")
    }
}

Yukarıda parametre alan, mirasa açık bir fonksiyon görmekteyiz. Şimdi başka bir class oluşturup Person’ı miras alacak olursak bu sınıfın parametrelerini girmemiz gerek.

class person1 : Person(24)

Kotlin’e giriş yazımı burada sonlandırıyorum. Umarım beğenmişsinizdir ve faydalı olmuştur 😊