Ders 7 - Scala Operatörler (Operators)

Operatörler, derleyiciye bilinen matematiksel veya mantıksal işlemleri aktarmamızı sağlayan sembollerdir. Scala, gömülü operatörlerin ve aşağıda listelenen operatörlerin kullanılmasına olanak sağlar:

• Aritmetik Operatörler
• İlişkisel Operatörler
• Mantıksal Operatörler
• Bitwise Operatörler
• Atama Operatörleri

Bu derste; aritmetik, ilişkisel, mantıksal, bitwise, atama ve diğer operatörleri tek tek inceleyeceğiz.

Aritmetik Operatörler:

Aşağıdaki operatörler Scala dili tarafından desteklenen aritmetik operatörler:

A ismindeki değişkenin 10 değerini, B ismindeki değişkenin ise 20 değerini tuttuğunu varsayın:

Aşağıdaki örneği inceleyerek Scala Dilinde kullanılan tüm aritmetik operatörleri anlamaya çalışın.

Aşağıdaki kodları kopyalayıp Test.Scala dosyasına yapıştırın ve derleyip çalıştırın:

object Test {
  def main(args: Array[String]) {
    var a = 10;
    var b = 20;
    var c = 25;
    var d = 25;
    println("a + b = " + (a + b) );
    println("a - b = " + (a - b) );
    println("a * b = " + (a * b) );
    println("b / a = " + (b / a) );
    println("b % a = " + (b % a) );
    println("c % a = " + (c % a) );
  }
}

Bu program aşağıdaki çıktıyı verecektir:

C:/>scalac Test.scala
C:/>scala Test
a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5

C:/>

İlişkisel Operatörler:

Aşağıdaki operatörler Scala dili tarafından desteklenen ilişkisel operatörler:

A ismindeki değişkenin 10 değerini, B ismindeki değişkenin ise 20 değerini tuttuğunu varsayın:

Aşağıdaki örnekte ilişkisel operatörler örneklendirilmiştir.

Aşağıdaki kodları kopyalayıp Test.Scala dosyasına yapıştırın ve derleyip çalıştırın:

object Test {
  def main(args: Array[String]) {
    var a = 10;
    var b = 20;
    println("a == b = " + (a == b) );
    println("a != b = " + (a != b) );
    println("a > b = " + (a > b) );
    println("a < b = " + (a < b) );
    println("b >= a = " + (b >= a) );
    println("b <= a = " + (b <= a) );
  }
}

Bu program aşağıdaki çıktıyı verecektir:

C:/>scalac Test.scala
C:/>scala Test
a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false

C:/>

Mantıksal Operatörler:

Aşağıdaki operatörler Scala dili tarafından desteklenen mantıksal operatörler:

A ismindeki değişkenin 1 değerini, B ismindeki değişkenin ise 0 değerini tuttuğunu varsayın:

Aşağıdaki örnekte mantıksal operatörler örneklendirilmiştir. Aşağıdaki kodları kopyalayıp Test.Scala dosyasına yapıştırın ve derleyip çalıştırın:

object Test {
  def main(args: Array[String]) {
    var a = true;
    var b = false;

    println("a && b = " + (a&&b) );
    println("a || b = " + (a||b) );
    println("!(a && b) = " + !(a && b) );
  }
}

Bu program aşağıdaki çıktıyı verecektir:

C:/>scalac Test.scala
C:/>scala Test
a && b = false
a || b = true
!(a && b) = true

C:/>

Bitwise Operatörler:

Bitwise operatörü bitler üzerinde çalışır ve bitler üzerinden işlem yapar. &, |, ve ^ sembolleri için doğruluk tablosu aşağıdaki gibidir:

A = 60; ve B = 13; olarak varsayın ve Binary(ikili) değer olarak karşılıkları aşağıdaki gibi olacaktır:

A = 0011 1100

B = 0000 1101

A&B = 0000 1100

A^B = 0011 0001

~A  = 1100 0011

Scala dili tarafından desteklenen Bitwise operatörleri aşağıdaki tabloda listelenmiştir. A’nın değerinin 60 ve B’nin değerinin 13 olduğunu varsayarak devam edersek:

Aşağıdaki örnekte Bitwise operatörler örneklendirilmiştir. Aşağıdaki kodları kopyalayıp Test.Scala dosyasına yapıştırın ve derleyip çalıştırın:

object Test {
  def main(args: Array[String]) {
    var a = 60; /_ 60 = 0011 1100 _/
    var b = 13; /_ 13 = 0000 1101 _/
    var c = 0;

    c = a & b;            /* 12 = 0000 1100 */
    println("a & b = " + c );

    c = a | b;            /* 61 = 0011 1101 */
    println("a | b = " + c );

    c = a ^ b;            /* 49 = 0011 0001 */
    println("a ^ b = " + c );

    c = ~a;               /* -61 = 1100 0011 */
    println("~a = " + c );

    c = a << 2;           /* 240 = 1111 0000 */
    println("a << 2 = " + c );

    c = a >> 2;           /* 215 = 1111 */
    println("a >> 2  = " + c );

    c = a >>> 2;          /* 215 = 0000 1111 */
    println("a >>> 2 = " + c );
  }
}

Bu program aşağıdaki çıktıyı verecektir:

C:/>scalac Test.scala
C:/>scala Test
a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 15
a >>> 15

C:/>

Atama Operatörleri:

Scala dili tarafından desteklenen atama operatörleri aşağıdaki tabloda listelenmiştir.

Aşağıdaki örnekte atama operatörleri örneklendirilmiştir. Aşağıdaki kodları kopyalayıp Test.Scala dosyasına yapıştırın ve derleyip çalıştırın:

object Test {
  def main(args: Array[String]) {
    var a = 10;
    var b = 20;
    var c = 0;

    c = a + b;
    println("c = a + b  = " + c );

    c += a ;
    println("c += a  = " + c );

    c -= a ;
    println("c -= a = " + c );

    c *= a ;
    println("c *= a = " + c );

    a = 10;
    c = 15;
    c /= a ;
    println("c /= a  = " + c );

    a = 10;
    c = 15;
    c %= a ;
    println("c %= a  = " + c );

    c <<= 2 ;
    println("c <<= 2  = " + c );

    c >>= 2 ;
    println("c >>= 2  = " + c );

    c >>= 2 ;
    println("c >>= a  = " + c );

    c &= a ;
    println("c &= 2  = " + c );

    c ^= a ;
    println("c ^= a  = " + c );

    c |= a ;
    println("c |= a  = " + c );
  }
}

Bu program aşağıdaki çıktıyı verecektir:

C:/>scalac Test.scala
C:/>scala Test
c = a + b = 30
c += a = 40
c -= a = 30
c \*= a = 300
c /= a = 1
c %= a = 5
c <<= 2 = 20
c >>= 2 = 5
c >>= 2 = 1
c &= a = 0
c ^= a = 10
c |= a = 10

C:/>

Scala Operatörlerin Önceliği:

Operatör önceliği ifadelerin işlem gruplandırmasını belirler. Bu ifadeye nasıl değer biçileceğini etkiler. Bazı operatörlerin diğerlerine göre yüksek öncelikleri vardır. Örneğin; çarpma operatörünün, toplama operatörüne göre önceliği daha yüksektir. Örneğin; x = 7 + 3 * 2; ifadesi 20 sayısına değil, 13 sayısına eşittir, çünkü çarpma işaretinin toplama işaretine göre daha yüksek önceliği vardır. Bu sebeple işlemde ilk olarak 3*2 ifadesi yapıldı ve çarpa ifadesinden gelen sonuç 7 ile toplandı. Aşağıdaki tabloda en yüksek önceliğe sahip operatörler tablonun üst kısmından, önceliği en düşük operatöre kadar aşağıya doğru sıralanmıştır. Önceliği yüksek olan operatörler ilk değerlendirmeye alınacak operatörlerdir.