Kotlin Dersleri #3 - Operatörler

Kotlin'de ve diğer dillerde kodlama sürecini kolaylaştırmak adına oluşturulmuş ve aslında farklı fonksiyonları temsil eden yapılar vardır. Bunlara operatör denir.

Örnek:

/**
 * www.emreakcadag.com
 */

fun main() {

   val a = 1
   val b = 2

   val result1 = a.plus(b)
   val result2 = a + b
}

result1 değişkeni ve result2 değişkeni birbirine eşittir. Yani + operatörü kullanarak kod yükünü hafifletmiş olduk. Şimdi gelelim operatör çeşitlerine.

Kotlin Operatörler

• Atama Operatörü
• Aritmetik Operatörler
• Arttırma ve Azaltma Operatörleri
• Aritmetik Atama Operatörleri
• İlişkisel Operatörler
• Mantıksal Operatörler
• ? ve !! Operatörleri

Atama Operatörü

En basit ifadeyle değişkenlere değer atamak için kullanılır ve = işareti ile simgelenir.

/**
 * www.emreakcadag.com
 */

fun main() {

   val a = 1
   val b = 2
}

Bu örnek kod bloğunda a ve b adında 2 değer oluşturduk ve bu değerlere sırasıyla 1 ve 2 değerlerini atadık.

Aritmektik Operatörler

Toplama - çıkarma - çarpma - bölme ve mod alma işlemleri için sırasıyla + - * / % işaretleri ile simgelenmiştir. Örnek kod bloğunu aşağıda görebilirsiniz.

/**
 * www.emreakcadag.com
 */

fun main() {

    val a = 1
    val b = 2

    // Toplama
    val toplam = a + b

    // Çıkarma
    val fark = a - b

    // Çarpma
    val carpim = a * b

    // Bölme
    val bolum = a / b

    // Mod Alma
    val mod = a % b
}

Arttırma ve Azaltma Operatörleri

Bir sayı değerini 1 arttırmak veya 1 azaltmak için kullanılan yapıdır. Tek bir şartı vardır o da kullanılacak sayısal değerin değiştirilebilir olmasıdır. Yani var kullanılarak tanımlanması gerekir.

Örneği inceleyelim.

/**
 * www.emreakcadag.com
 */

fun main() {

    var a = 10
    var b = 20
    var c = 30
    var d = 40
    var e = 50
    var f = 60

    //arttırma
    a++			                // println(a) = 11

    //azaltma
    b--			                // println(b) = 19

    //önce kullanıp sonra arttırma
    var yeniDeger1 = c++		// println(c) = 31 println(yeniDeger1) = 30

    //önce arttırıp sonra kullanma
    var yeniDeger2 = ++d		// println(d) = 41 println(yeniDeger2) = 41

    //önce kullanıp sonra azaltma
    var yeniDeger3 = e--		// println(e) = 49 println(yeniDeger3) = 50

    //önce azaltıp sonra kullanma
    var yeniDeger4 = --f		// println(d) = 59 println(yeniDeger4) = 59
}

Yukarda görüldüğü üzere kullanacağımız amaca göre ++ ve -- işaretlerini değişkenin soluna ve sağına getirerek gerekli atamaları sağlıyoruz.

Aritmetik Atama Operatörleri

• +=
• -=
• *=
• /=

/**
 * www.emreakcadag.com
 */

fun main() {

    var a = 10
    var b = 20
    var c = 30
    var d = 40
    var e = 50

    a += 9			        // println(a) = 19

    b -= 1			        // println(b) = 19

    c *= 10			        // println(c) = 300

    d /= 2			        // println(d) = 20

    e %= 3			        // println(e) = 2
}

Örnekte görüleceği üzere basit bir kullanımı vardır. Aritmetik ve atama operatörleri bir arada kullanılarak aynı değişkene yeniden değer ataması yapılır.

Mantıksal Operatörler

İki değer arasında kıyaslama yapılırken kullanılır.

• Eşittir operatörü: ==
• Eşit değildir operatörü: !=
• Büyüktür operatörü: >
• Küçüktür operatörü: <
• Büyük eşittir operatörü: >=
• Küçük eşittir operatörü: <=
• Ve: &&
• Veya: ||

İki değer arasında kıyaslama yapıldığında geriye true ya da false değerlerden biri döner.

/**
 * www.emreakcadag.com
 */

fun main() {

    var a = 19
    var b = 20
    var c = 19
    var d = 1919
    var x = true
    var y = false

    var comp = a != b			// println(comp) = true

    comp = a == b			// println(comp) = false

    comp = d > a			// println(comp) = true

    comp = a >= c			// println(comp) = true

    comp = d < b			// println(comp) = false

    comp = b <= d			// println(comp) = true

    comp = x && y			// println(comp) = false

    comp = x || y			// println(comp) = true
}

? ve !! Operatörleri

? operatörü, tipini belirlerdiğimz bir değişkene null değer atayabilmemize olanak sağlar.

/**
 * www.emreakcadag.com
 */

fun main() {

    var a:Int = 19

    var b:Int? = 1919

    a = null	 // bu satır hata verir.

    b = null	 // bu satır doğru çalışacaktır.

    a = b	 // bu satır hata verir.

    a = b!!	 // bu satır doğru çalışacaktır.
}

Hata aldığımız ilk satırda a değişkenine null değer atamaya çalıştık ancak a değişkeni nullable(null değer atanabilen) olmadığı için hata aldık. Bir değişkeni nullable yapabilmek için, o değişkenin türünün sonuna ? koymamız yeterlidir.

Hata aldığımız ikinci satırda ise yine nullable olmayan a değerine, nullable olan b değerini atamaya çalıştık. Program bize b'nin null gelebileceğini öngörerek hata verdi. Eğer b'nin null olmadığından eminsek; bu hatadan b değişkeninin sonuna !! ekleyerek kurtulabiliriz.

Dersimizin sonuna geldik, bir sonraki derste görüşmek dileğiyle!

Sorularınızı yorum bölümünden iletebilirsiniz.