Java’da Operatörler ve Koşullu İfadeler Nasıl Kullanılır?

Java’da operatörler; sayılar, değişkenler ve boolean değerler üzerinde işlem yaparak yeni bir değer üretir veya bir değişkenin değerini değiştirir. Koşullu ifadeler ise bu sonuçları kullanarak programın hangi durumda nasıl davranacağını belirler. Bu nedenle Java öğrenirken önce operatörlerin ne ürettiğini, ardından bu sonuçların koşullarda nasıl kullanıldığını anlamak gerekir.

Örneğin bir yaşın belirli aralıkta olup olmadığını karşılaştırma ve mantıksal operatörlerle test edebilir, bir puanı aritmetik operatörlerle hesaplayabilir veya sayaç değerini artırma operatörüyle güncelleyebilirsiniz.

Java operatörleri ne işe yarar?

Operatör, Java’da bir veya daha fazla değer üzerinde işlem yapan semboldür. İşlenen adı verilen değerler operatörün üzerinde işlem yaptığı değişken veya sabitlerdir. Örneğin 10 + 3 ifadesinde 10 ve 3 işlenen, + ise aritmetik operatördür.

Tamsayılarla bölme yaparken sonuçta yalnızca tamsayı kısmı tutulur. Bu nedenle 7 / 3 ifadesinin sonucu 2 olur. Bölme işleminden kalanı bulmak için mod alma operatörü % kullanılır: 7 % 3 sonucu 1 verir. Bu kullanım, bir sayının tek mi çift mi olduğunu kontrol etmek gibi durumlarda yararlıdır.

Bileşik atama operatörleri, aynı değişkeni tekrar tekrar yazmadan güncelleme sağlar. puan += 10 ifadesi, puan = puan + 10 ile aynı anlama gelir. Benzer şekilde stok -= 1, stok değerinden bir çıkartır.

++ ve -- operatörlerinde ön ek ve son ek kullanımı, değerin ne zaman güncelleneceğini etkiler:

int sayac = 5;
int once = ++sayac; // Önce artırır: sayac 6, once 6
int sonra = sayac++; // Önce kullanır: sonra 6, ardından sayac 7

Bu fark küçük görünse de karmaşık ifadelerde kodun okunmasını zorlaştırabilir. Artırma veya azaltma işlemi tek başına yazıldığında, örneğin sayac++;, davranış daha açıktır.

Karşılaştırma ve mantıksal operatörlerle koşul nasıl oluşturulur?

Karşılaştırma operatörleri, iki değeri karşılaştırır ve sonuç olarak boolean türünde, yani yalnızca true veya false olabilen bir değer üretir. Örneğin yas >= 18 ifadesi, yaş 18 veya daha büyükse true olur.

Birden fazla şartı bir araya getirmek için mantıksal operatörler kullanılır:

• && operatöründe bütün koşulların doğru olması gerekir.
• || operatöründe koşullardan en az birinin doğru olması yeterlidir.
• ! operatörü boolean sonucu tersine çevirir; true değeri false, false değeri true olur.

int yas =  twenty = 20;
boolean yetkili = true;
boolean gecerliGiris = true;

boolean yasUygun = yas >= 18 && yas <= 65;
boolean erisimVar = yetkili || gecerliGiris;
boolean girisReddedildi = !gecerliGiris;

System.out.println(yasUygun);       // true
System.out.println(erisimVar);      // true
System.out.println(girisReddedildi); // false

Yukarıdaki örnekte yaş aralığı için iki koşulun da sağlanması gerekir. Kullanıcı yetkiliyse veya geçerli bir giriş yaptıysa erişim mümkün kabul edilir. Girişin geçersiz olup olmadığını anlatmak içinse ! kullanılabilir. Kodun doğrudan derlenebilmesi için değişken tanımları geçerli olmalıdır; bu örnekte int yas = 20; biçimi kullanılmalıdır.

Koşullar uzadığında parantezler işlem amacını görünür kılar. Örneğin (yas >= 18 && yas <= 65) && aktif ifadesi, yaş aralığı kontrolünün ayrı bir grup olduğunu açıkça gösterir. Gereğinden uzun, iç içe ve art arda ! kullanılan koşullar takip edilmesi zor kodlar oluşturur. Böyle durumlarda koşulu daha küçük boolean değişkenlere ayırmak, hem hata ayıklamayı hem de kod incelemeyi kolaylaştırır.

Java’da == ile equals() arasındaki fark nedir?

== operatörü, kullanılan türe göre farklı davranır. Primitive türlerde, yani int, double, char ve boolean gibi temel veri türlerinde iki değeri doğrudan karşılaştırır. Örneğin 5 == 5 ifadesinin sonucu true olur.

Nesnelerde ise ==, nesnelerin içeriklerini değil, iki referansın bellekte aynı nesneyi gösterip göstermediğini sınar. Referans, bir nesnenin kendisini değil, o nesneye ulaşmayı sağlayan bağlantıyı ifade eder. Bu nedenle iki farklı String nesnesi aynı metni içerse bile == sonucu her zaman true olmayabilir.

String metinlerinin içeriğini karşılaştırmak için equals() yöntemi kullanılmalıdır. == sonucunun bazı durumlarda doğru görünebilmesi, String havuzu gibi çalışma ayrıntılarına bağlı olabilir. Bu davranışa güvenmek kodu kırılgan hâle getirir; amaç içerik karşılaştırmaksa tercih equals() olmalıdır. Java öğrenirken bu ayrımı uygulamalı biçimde pekiştirmek isteyenler, birebir Java özel ders içeriğinden yararlanabilir.

public class StringKarsilastirma {
    public static void main(String[] args) {
        String cevap = null;

        boolean guvenliSonuc = "EVET".equals(cevap);
        System.out.println(guvenliSonuc);
    }
}

Bu programın çıktısı false olur. Çünkü cevap değişkeni null değerindedir ve metin olarak EVET içermez. Sabit metni sola yazmak, yani "EVET".equals(cevap) kullanmak, cevap.equals("EVET") biçiminde oluşabilecek NullPointerException riskini azaltır. Değişken null olsa bile çağrı sabit ve null olmayan metin üzerinde yapıldığı için program hata vermez.

if, else if ve else ile program akışı nasıl kurulur?

if bloğu ilk kontrol edilecek koşulu temsil eder. Koşul doğruysa bu blok çalışır. else if, ilk koşul karşılanmadığında denenecek alternatif koşulları tanımlar. else ise önceki koşulların hiçbiri doğru olmadığında çalışacak varsayılan yolu belirtir.

Koşullar yukarıdan aşağıya değerlendirilir. Bir else if zincirinde ilk doğru dal çalıştıktan sonra kalan dallar atlanır. Bu yüzden sınır değerleri doğru sıraya koymak ve geçerli aralığı && ile açıkça belirtmek önemlidir.

public class NotDegerlendirici {
    public static void main(String[] args) {
        int not = 78;
        char harf;

        if (not < 0 || not > 100) {
            System.out.println("Geçersiz not");
        } else if (not >= 90 && not <= 100) {
            harf = 'A';
            System.out.println("Harf notu: " + harf);
        } else if (not >= 70 && not < 90) {
            harf = 'B';
            System.out.println("Harf notu: " + harf);
        } else {
            harf = 'C';
            System.out.println("Harf notu: " + harf);
        }
    }
}

Beklenen çıktı: Harf notu: B. Örnekte önce notun 0-100 aralığında olup olmadığı kontrol edilir. Ardından üst sınırdan alt sınıra doğru ilerlenir. 78 değeri 70 ile 89 arasındadır; bu nedenle B dalı çalışır ve else bloğuna geçilmez.

Sadece tek bir seçeneğin çalışması gerekiyorsa if ve else if zinciri uygundur. Birden fazla bağımsız kontrolün tamamının değerlendirilmesi gerekiyorsa ayrı if blokları tercih edilmelidir. Tek satırlık koşullarda bile süslü parantez kullanmak, sonradan eklenecek satırların yanlış bloğa bağlanmasını önler ve okunabilirliği korur.

switch ne zaman kullanılır ve if/else yerine nasıl seçilir?

switch, tek bir değerin sınırlı ve önceden bilinen seçeneklerden hangisine eşit olduğunu kontrol etmek için kullanılır. Örneğin bir menü komutunu, gün adını, işlem türünü veya enum değerini seçerken okunabilir bir yapı sunar. Buna karşılık aralık kontrolü, büyüklük-küçüklük karşılaştırması ya da birden fazla koşulun birlikte değerlendirilmesi gerekiyorsa if/else daha uygundur.

Switch yapısında parantez içindeki değer, case etiketleriyle karşılaştırılır. Eşleşen case bloğu çalışır. Klasik switch sözdiziminde break yazılmazsa program sonraki case bloklarına da devam eder. Bu davranışa fall-through denir ve bilinçli kullanılmadığında beklenmeyen sonuçlara yol açabilir. Hiçbir seçenek eşleşmezse default bloğu çalışır.

public class MenuOrnegi {
    public static void main(String[] args) {
        String komut = "listele";

        switch (komut) {
            case "listele":
                System.out.println("Kayıtlar listeleniyor.");
                break;
            case "sil":
                System.out.println("Kayıt siliniyor.");
                break;
            default:
                System.out.println("Geçersiz komut.");
        }
    }
}

Bu örnekte kullanılan değer türü String’dir ve değeri "listele" olduğu için yalnızca ilgili case çalışır. Beklenen çıktı şudur: Kayıtlar listeleniyor. İlk case içinde break bulunduğu için program sil ve default bloklarına geçmez.

Pratik karar kuralı şudur: “Elimde tek bir değer var ve bunu birkaç sabit seçenekle mi eşleştiriyorum?” sorusunun yanıtı evetse switch düşünülebilir. “Bir değer hangi aralıkta, başka bir koşulla birlikte sağlanıyor mu veya karşılaştırmanın yönü önemli mi?” sorularından biri evetse if/else daha okunaklıdır.

Switch’i karmaşık aralık kontrollerinde kullanmaya çalışmak, kodu yapay ve zor okunur hâle getirir. Benzer şekilde çok uzun sabit bir menüyü art arda else if bloklarıyla yazmak da seçeneklerin gözden kaçmasına ve bakımın zorlaşmasına neden olur. Seçim yalnızca kısa yazma amacıyla değil, kararın anlamını en açık biçimde göstermek için yapılmalıdır.

Okunabilir koşullar yazmak için hatalar ve kontrol listesi

Koşul yazarken amaç yalnızca programı çalıştırmak değil, farklı girdilerde doğru sonucu koruyan ve başkasının kolayca anlayabileceği bir akış kurmaktır. Kullanıcı girdisi içeren bir senaryoda önce geçersiz veriyi ayırmak, ardından özel durumları değerlendirmek, en sonunda varsayılan yolu belirlemek iyi bir başlangıçtır.

1. Karşılaştırılan değerleri belirleyin: Metin mi, sayı mı, boolean değer mi kontrol ediliyor?
2. Sınırları yazın: Örneğin 0, 18 veya 100 gibi değerlerde beklenen sonucu önceden belirleyin.
3. Operatörü seçin: Eşitlik için ==, içerik karşılaştırması için equals(), birlikte sağlanması gereken koşullar için && kullanın.
4. Dalların sırasını kontrol edin: Önce geçersiz ve daha özel durumları, sonra genel durumları değerlendirin.
5. Farklı girdilerle test edin: Normal, sınır ve geçersiz değerleri ayrı ayrı deneyin.

Yaygın hatalardan biri, String içeriklerini == ile karşılaştırmaktır. == nesnelerin referanslarını, yani aynı nesneyi gösterip göstermediklerini kontrol eder; equals() ise metin içeriklerini karşılaştırır. Kullanıcıdan gelen metin için null ihtimali varsa güvenli kullanım şöyledir: "admin".equals(kullaniciAdi). Böylece kullaniciAdi null olduğunda NullPointerException oluşmaz.

Bir diğer hata, atama operatörü olan = ile eşitlik kontrolü yapan == operatörünü karıştırmaktır. Ayrıca && yerine yanlışlıkla || kullanmak, “iki koşul da sağlanmalı” anlamını “koşullardan biri yeterli” anlamına dönüştürür. Uzun else if zincirlerinde önce geniş bir koşul yazılırsa sonraki özel dal erişilemez hâle gelebilir. Örneğin önce puan >= 0 kontrol edilirse, bunun altında yer alan puan >= 90 dalına ulaşılmaz.

Klasik switch yapısında break unutmak da sonraki case bloklarının istemeden çalışmasına neden olur. Tek satırlık olsa bile süslü parantezleri kullanmak, hangi komutun hangi koşula ait olduğunu açıkça gösterir ve sonradan eklenecek satırlarda hata riskini azaltır.

Çok fazla iç içe koşul varsa geçersiz durumu başta ele alıp metottan erken dönmek, anlamlı boolean değişkenler tanımlamak ve büyük kararı küçük metotlara bölmek yardımcı olur. Örneğin isValidAge veya hasPermission gibi isimler, uzun bir karşılaştırma grubunun amacını görünür kılar. Aynı koşulu farklı dallarda tekrar etmek yerine sonucu bir değişkende hesaplamak da bakım kolaylığı sağlar.

Bu konudaki bilginizi uygulamalı olarak ölçmek için Java bilgi testi üzerinden koşullar, operatörler ve karar yapılarıyla ilgili soruları çözebilirsiniz.

Sık Sorulan Sorular

Java’da birden fazla if kullanmak ile else if kullanmak arasındaki fark nedir?

Birden fazla bağımsız if kullanıldığında koşulların her biri ayrı ayrı kontrol edilir ve birden fazlası çalışabilir. else if zincirinde ise ilk doğru koşul bulunduğunda zincirin kalan bölümü atlanır. Birbirini dışlayan seçeneklerde else if daha uygundur.

String karşılaştırırken neden == yerine equals() kullanılmalıdır?

== String nesnelerinin referanslarını, equals() ise karakter içeriklerini karşılaştırır. Aynı metni taşıyan iki farklı String nesnesi farklı referanslara sahip olabileceği için içerik karşılaştırmasında equals() kullanılmalıdır.

Switch içinde default ve break kullanmak zorunlu mudur?

İkisi de her durumda zorunlu değildir. default eşleşmeyen değerler için güvenli bir varsayılan yol sağlar. break ise klasik switch akışının sonraki case bloklarına geçmesini engeller; kasıtlı geçiş yoksa genellikle yazılmalıdır.

&& ile & ve || ile | operatörleri aynı şekilde mi çalışır?

Hayır. && ve || mantıksal kısa devre operatörleridir; sonucun belli olduğu durumda sağ tarafı değerlendirmeyebilir. & ve | ise boolean ifadelerde iki tarafı da değerlendirebilir. Koşullarda genellikle kısa devre davranışı isteniyorsa && ve || tercih edilir.

Çok fazla iç içe if bloğu nasıl sadeleştirilir?

Geçersiz durumları erken kontrol edip metottan dönün, karmaşık ifadeleri açıklayıcı boolean değişkenlere ayırın ve farklı sorumlulukları küçük metotlara bölün. Böylece ana akış daha az girintili ve daha kolay test edilebilir hâle gelir.

Koşulları yazmadan önce değerleri, sınırları ve beklenen yolları netleştirmek; Java kodunun hem daha doğru hem de daha okunabilir olmasını sağlar.