5. Operatörler (Aritmetik, Karşılaştırma, Mantıksal, Bitwise, vb.)

Java, programlamanın temel yapı taşlarından biri olan operatörler konusunda oldukça zengin bir yelpaze sunar. Operatörler, değişkenler ve değerler üzerinde çeşitli işlemler gerçekleştirmek için kullanılır. Bu makalede, Java’daki farklı operatör türlerini ayrıntılı bir şekilde inceleyeceğiz: aritmetik operatörler, karşılaştırma operatörleri, mantıksal operatörler ve bitwise operatörler.

Aritmetik Operatörler

Aritmetik operatörler, matematiksel işlemleri gerçekleştirmek için kullanılır. Java’da yaygın olarak kullanılan aritmetik operatörler şunlardır:

• + (Toplama): İki değeri toplar. Örneğin: int toplam = 5 + 3; // toplam = 8
• – (Çıkarma): İki değer arasındaki farkı alır. Örneğin: int fark = 10 - 4; // fark = 6
• * (Çarpma): İki değeri çarpar. Örneğin: int carpim = 6 * 7; // carpim = 42
• / (Bölme): Bir değeri diğerine böler. Eğer her iki değer de tam sayı ise, sonuç da tam sayı olur (ondalık kısım atılır). Örneğin: int bolum = 15 / 2; // bolum = 7
• % (Mod Alma): Bir değerin diğerine bölümünden kalanı verir. Örneğin: int kalan = 16 % 5; // kalan = 1
• ++ (Artırma): Bir değişkenin değerini 1 artırır. Hem ön ek (++x) hem de son ek (x++) şeklinde kullanılabilir. Aralarındaki fark, ön ekte değişkenin değeri önce artırılır, sonra kullanılırken, son ekte değişkenin değeri önce kullanılır, sonra artırılır.
• — (Azaltma): Bir değişkenin değerini 1 azaltır. Artırma operatöründe olduğu gibi, hem ön ek (--x) hem de son ek (x--) şeklinde kullanılabilir.

Örnek:

public class AritmetikOperatörler {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;

        System.out.println("a + b = " + (a + b)); // 15
        System.out.println("a - b = " + (a - b)); // 5
        System.out.println("a * b = " + (a * b)); // 50
        System.out.println("a / b = " + (a / b)); // 2
        System.out.println("a % b = " + (a % b)); // 0

        a++;
        System.out.println("a++ = " + a); // 11

        b--;
        System.out.println("b-- = " + b); // 4
    }
}

Karşılaştırma Operatörleri

Karşılaştırma operatörleri, iki değeri karşılaştırmak için kullanılır. Sonuç her zaman bir boolean değeridir (true veya false).

• == (Eşittir): İki değerin eşit olup olmadığını kontrol eder. Örneğin: boolean esitMi = (5 == 5); // esitMi = true
• != (Eşit Değildir): İki değerin eşit olup olmadığını kontrol eder. Örneğin: boolean esitDegilMi = (5 != 6); // esitDegilMi = true
• > (Büyüktür): Bir değerin diğerinden büyük olup olmadığını kontrol eder. Örneğin: boolean buyukMu = (10 > 5); // buyukMu = true
• < (Küçüktür): Bir değerin diğerinden küçük olup olmadığını kontrol eder. Örneğin: boolean kucukMu = (3 < 7); // kucukMu = true
• >= (Büyük veya Eşittir): Bir değerin diğerinden büyük veya eşit olup olmadığını kontrol eder. Örneğin: boolean buyukVeyaEsitMi = (8 >= 8); // buyukVeyaEsitMi = true
• <= (Küçük veya Eşittir): Bir değerin diğerinden küçük veya eşit olup olmadığını kontrol eder. Örneğin: boolean kucukVeyaEsitMi = (4 <= 6); // kucukVeyaEsitMi = true

Örnek:

public class KarsilastirmaOperatorleri {
    public static void main(String[] args) {
        int x = 5;
        int y = 10;

        System.out.println("x == y: " + (x == y)); // false
        System.out.println("x != y: " + (x != y)); // true
        System.out.println("x > y: " + (x > y)); // false
        System.out.println("x < y: " + (x < y)); // true
        System.out.println("x >= y: " + (x >= y)); // false
        System.out.println("x <= y: " + (x <= y)); // true
    }
}

Mantıksal Operatörler

Mantıksal operatörler, boolean ifadeleri birleştirmek veya tersine çevirmek için kullanılır.

• && (VE): Her iki ifade de true ise sonuç true olur. Aksi takdirde false olur. Örneğin: boolean sonuc = (5 > 3) && (10 < 12); // sonuc = true
• || (VEYA): İfadelerden en az biri true ise sonuç true olur. Her iki ifade de false ise sonuç false olur. Örneğin: boolean sonuc = (2 > 4) || (7 < 9); // sonuc = true
• ! (DEĞİL): Bir boolean ifadenin değerini tersine çevirir. Örneğin: boolean sonuc = !(5 == 5); // sonuc = false

Örnek:

public class MantiksalOperatorler {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;

        System.out.println("a && b: " + (a && b)); // false
        System.out.println("a || b: " + (a || b)); // true
        System.out.println("!a: " + !a); // false
    }
}

Bitwise Operatörler

Bitwise operatörler, sayıların bit düzeyindeki gösterimleri üzerinde işlem yapar. Bu operatörler genellikle düşük seviyeli programlama ve performans kritik uygulamalarda kullanılır.

• & (Bitwise AND): İki sayının karşılık gelen bitleri 1 ise sonuç 1 olur, aksi takdirde 0 olur.
• | (Bitwise OR): İki sayının karşılık gelen bitlerinden en az biri 1 ise sonuç 1 olur, aksi takdirde 0 olur.
• ^ (Bitwise XOR): İki sayının karşılık gelen bitleri farklı ise sonuç 1 olur, aynı ise 0 olur.
• ~ (Bitwise NOT): Bir sayının tüm bitlerini tersine çevirir (1’ler 0 olur, 0’lar 1 olur).
• << (Sol Kaydırma): Bir sayının bitlerini sola kaydırır. Kaydırılan her bit, sayıyı 2 ile çarpmakla aynıdır.
• >> (Sağ Kaydırma): Bir sayının bitlerini sağa kaydırır. Kaydırılan her bit, sayıyı 2’ye bölmekle aynıdır.
• >>> (İşaretsiz Sağ Kaydırma): Bir sayının bitlerini sağa kaydırır, ancak işaret bitini korumaz. Bu operatör, sayının işaretini değiştirmeden bitleri sağa kaydırmak için kullanılır.

Örnek:

public class BitwiseOperatorler {
    public static void main(String[] args) {
        int a = 5;  // 0101
        int b = 3;  // 0011

        System.out.println("a & b: " + (a & b));  // 0001 = 1
        System.out.println("a | b: " + (a | b));  // 0111 = 7
        System.out.println("a ^ b: " + (a ^ b));  // 0110 = 6
        System.out.println("~a: " + (~a));    // ...1010 = -6 (işaretli tamsayı gösterimi)
        System.out.println("a << 2: " + (a << 2)); // 010100 = 20
        System.out.println("a >> 1: " + (a >> 1)); // 0010 = 2
        System.out.println("a >>> 1: " + (a >>> 1)); // 0010 = 2
    }
}

Önemli Not: Bitwise operatörlerin sonuçları, sayıların bit düzeyindeki gösterimine bağlıdır. Bu nedenle, bu operatörleri kullanırken sayıların bit yapısını anlamak önemlidir.

Atama Operatörleri

Atama operatörleri, bir değişkene değer atamak için kullanılır. En temel atama operatörü = işaretidir. Ancak, Java’da bileşik atama operatörleri de bulunur.

• = (Atama): Bir değişkene değer atar. Örneğin: int x = 10;
• += (Topla ve Ata): Bir değişkene bir değer ekler ve sonucu aynı değişkene atar. Örneğin: x += 5; // x = x + 5;
• -= (Çıkar ve Ata): Bir değişkenden bir değer çıkarır ve sonucu aynı değişkene atar. Örneğin: x -= 3; // x = x - 3;
• *= (Çarp ve Ata): Bir değişkeni bir değerle çarpar ve sonucu aynı değişkene atar. Örneğin: x *= 2; // x = x * 2;
• /= (Böl ve Ata): Bir değişkeni bir değere böler ve sonucu aynı değişkene atar. Örneğin: x /= 4; // x = x / 4;
• %= (Mod Al ve Ata): Bir değişkenin bir değere bölümünden kalanı alır ve sonucu aynı değişkene atar. Örneğin: x %= 3; // x = x % 3;
• &= (Bitwise AND ve Ata): Bir değişken ile bir değerin bitwise AND işlemini yapar ve sonucu aynı değişkene atar.
• |= (Bitwise OR ve Ata): Bir değişken ile bir değerin bitwise OR işlemini yapar ve sonucu aynı değişkene atar.
• ^= (Bitwise XOR ve Ata): Bir değişken ile bir değerin bitwise XOR işlemini yapar ve sonucu aynı değişkene atar.
• <<= (Sol Kaydır ve Ata): Bir değişkenin bitlerini sola kaydırır ve sonucu aynı değişkene atar.
• >>= (Sağ Kaydır ve Ata): Bir değişkenin bitlerini sağa kaydırır ve sonucu aynı değişkene atar.
• >>>= (İşaretsiz Sağ Kaydır ve Ata): Bir değişkenin bitlerini işaretsiz olarak sağa kaydırır ve sonucu aynı değişkene atar.

Örnek:

public class AtamaOperatorleri {
    public static void main(String[] args) {
        int x = 10;

        x += 5; // x = 15
        System.out.println("x += 5: " + x);

        x -= 3; // x = 12
        System.out.println("x -= 3: " + x);

        x *= 2; // x = 24
        System.out.println("x *= 2: " + x);

        x /= 4; // x = 6
        System.out.println("x /= 4: " + x);

        x %= 3; // x = 0
        System.out.println("x %= 3: " + x);
    }
}

Bu makalede, Java’daki temel operatör türlerini ve kullanımlarını ayrıntılı olarak inceledik. Operatörler, Java programlamanın temel yapı taşlarından biridir ve doğru kullanıldıklarında kodunuzun daha verimli ve okunabilir olmasını sağlarlar. Operatörlerin öncelik sıralamasını ve farklı operatör türlerinin etkileşimini anlamak, karmaşık ifadeleri doğru bir şekilde değerlendirebilmek için önemlidir.