Java Söz Dizimi Temelleri

Bir dili öğrenirken önce alfabeyi, sonra kelimeleri, sonra cümle yapısını öğrenirsin. Programlama dilleri de aynı — önce temel yapı taşlarını (söz dizimi kuralları) öğrenmen gerekiyor. Bu ders Java'nın gramer kitabı gibi düşünülebilir.

Değişkenleri, veri tiplerini, isimlendirme kurallarını ve operatörleri ele alacağız. Bunlar Java'da her şeyin üzerine inşa edildiği temel tuğlalar.

Değişkenler: Veriyi Saklama Kutuları

Değişken, bilgisayarın belleğinde veri sakladığın bir kutudur. Her kutunun bir adı, bir tipi ve bir değeri vardır.

Analoji: Değişkenleri mutfaktaki kavanozlar gibi düşün. Her kavanozun üstünde ne içerdiğini yazan bir etiket var (isim), ne tür şey koyabileceğin belirli (tip), ve içinde bir şey var (değer). Şeker kavanozuna tuz koyamazsın — Java da tipine uymayan değer atamana izin vermez.

Değişken Tanımlama

Java'da değişken tanımlamanın genel formatı:

tip isim = değer;

public class DegiskenOrnekleri {
    public static void main(String[] args) {
        int yas = 25;              // Tam sayı
        double boy = 1.75;         // Ondalıklı sayı
        String isim = "Ali";       // Metin
        boolean ogrenciMi = true;  // Doğru/Yanlış
        char harf = 'A';           // Tek karakter

        System.out.println("İsim: " + isim);
        System.out.println("Yaş: " + yas);
        System.out.println("Boy: " + boy);
        System.out.println("Öğrenci mi: " + ogrenciMi);
        System.out.println("İlk harf: " + harf);
    }
}

Değişkeni önce tanımlayıp sonra da değer atayabilirsin:

int sayi;        // Tanımlama (declaration)
sayi = 42;       // Değer atama (assignment)

// Veya tek satırda:
int sayi = 42;   // Tanımlama + ilk değer atama (initialization)

⚠️ Dikkat: Değer atamadan bir lokal değişkeni kullanmaya çalışırsan Java hata verir: variable might not have been initialized. C/C++'tan farklı olarak Java, başlatılmamış değişken kullanmana izin vermez.

Primitive (İlkel) Veri Tipleri

Java'da 8 tane primitive veri tipi var. Bunlar dilin en temel yapı taşları:

Tam Sayı Tipleri

public class TamSayilar {
    public static void main(String[] args) {
        byte kucukSayi = 100;
        short ortaSayi = 30000;
        int normalSayi = 2_000_000_000;    // _ ile okunabilirlik
        long buyukSayi = 9_000_000_000L;   // L soneki zorunlu!

        System.out.println("byte: " + kucukSayi);
        System.out.println("short: " + ortaSayi);
        System.out.println("int: " + normalSayi);
        System.out.println("long: " + buyukSayi);
    }
}

💡 İpucu: Sayıların içinde _ (alt çizgi) kullanarak okunabilirliği artırabilirsin. 2_000_000_000 ile 2000000000 aynı şey ama birincisi okumak çok daha kolay. long tipi değerlerinin sonuna L eklemeyi unutma.

Ondalıklı Sayı Tipleri

public class OndalikliSayilar {
    public static void main(String[] args) {
        float pi_float = 3.14159f;      // f soneki zorunlu!
        double pi_double = 3.141592653589793;  // Varsayılan, sonek gerek yok

        System.out.println("float pi: " + pi_float);
        System.out.println("double pi: " + pi_double);
    }
}

float kullanırken sonuna f eklemelisin. Eklemezsen Java onu double sayar ve float değişkenine double atayamazsın (daraltıcı dönüşüm hatası).

boolean ve char

public class BooleanVeChar {
    public static void main(String[] args) {
        boolean javaGüzelMi = true;
        boolean zor = false;
        char harf = 'J';
        char rakam = '7';       // Bu bir sayı değil, karakter!
        char unicode = '\u0041'; // Unicode ile 'A'

        System.out.println("Java güzel mi? " + javaGüzelMi);
        System.out.println("Harf: " + harf);
        System.out.println("Unicode: " + unicode);
    }
}

• `boolean`: Sadece true veya false alır. Koşul kontrollerinde kullanılır.

• `char`: Tek bir karakter saklar. Tek tırnak ile yazılır: 'A'. Çift tırnak String için kullanılır: "A".

String: Metin Tipi

String bir primitive tip değildir — bir sınıftır (class). Ama o kadar sık kullanılır ki, primitive tipler gibi kolayca oluşturulabilir:

public class StringOrnekleri {
    public static void main(String[] args) {
        // String oluşturma yolları
        String isim = "Ali";              // Literal (en yaygın)
        String soyisim = new String("Yılmaz"); // Constructor ile (gereksiz, kullanma)

        // String birleştirme
        String tamIsim = isim + " " + soyisim;
        System.out.println(tamIsim);  // Ali Yılmaz

        // String uzunluğu
        System.out.println("Uzunluk: " + tamIsim.length());  // 10

        // Büyük-küçük harf
        System.out.println(tamIsim.toUpperCase());  // ALI YILMAZ
        System.out.println(tamIsim.toLowerCase());  // ali yılmaz

        // Belirli karakteri alma (index 0'dan başlar)
        System.out.println("İlk harf: " + tamIsim.charAt(0));  // A
    }
}

String konusunu ileride çok daha detaylı işleyeceğiz. Şimdilik metin saklamak için String kullandığını bil.

Var Anahtar Kelimesi (Java 10+)

Java 10'dan itibaren lokal değişkenlerde var kullanabilirsin. Java tipi otomatik anlar:

public class VarOrnegi {
    public static void main(String[] args) {
        var isim = "Ali";       // Java anlar: bu String
        var yas = 25;           // Java anlar: bu int
        var boy = 1.75;         // Java anlar: bu double
        var aktif = true;       // Java anlar: bu boolean

        System.out.println(isim.getClass().getSimpleName());  // String
    }
}

var kullanınca Java, sağ taraftaki değere bakarak tipi kendisi belirler. Ama dikkat:

var x;          // HATA! Başlangıç değeri olmadan var kullanamassın
var y = null;   // HATA! null'dan tip çıkarılamaz

var dinamik tipleme değildir. Java hâlâ statik tipli. Sadece sen tipi yazmıyorsun, derleyici çıkarıyor. Tip belirlendikten sonra değiştirilemez.

İsimlendirme Kuralları ve Gelenekleri

Java'da isimlendirme hem kurallar (rules — ihlal edersen derleme hatası) hem gelenekler (conventions — ihlal edersen kötü karşılanır) içerir.

Zorunlu Kurallar

1. İsim harf, _ veya $ ile başlamalı (rakamla başlayamaz)

2. İsimde boşluk olamaz

3. Java'nın anahtar kelimeleri isim olarak kullanılamaz (int, class, public, if vb.)

4. Büyük-küçük harf duyarlı (yas ve Yas farklı değişkenlerdir)

// DOĞRU
int yasam = 25;
int _gecici = 100;
int $dolar = 50;
int sayi123 = 42;

// HATALI
int 123sayi = 42;     // Rakamla başlayamaz
int benim sayim = 5;  // Boşluk olamaz
int class = 10;       // Anahtar kelime kullanılamaz

Gelenekler (Convention)

Bu geleneklere uymak zorunda değilsin ama uymazsan diğer Java geliştiricileri kodunu okuduğunda kaşlarını çatacak.

public class IsimlendirmeOrnekleri {
    // Sabit — BÜYÜK HARF + alt çizgi
    static final double PI_DEGERI = 3.14159;
    static final int MAX_OGRENCI_SAYISI = 50;

    public static void main(String[] args) {
        // Değişken — camelCase
        String ogrenciAdi = "Ali";
        int toplamPuan = 85;
        boolean sinifiGectiMi = toplamPuan >= 50;

        System.out.println(ogrenciAdi + ": " + toplamPuan + " puan");
        System.out.println("Geçti mi? " + sinifiGectiMi);
    }
}

💡 İpucu: İsimlendirme konusunda en önemli kural: anlamlı isimler kullan. x, y, temp gibi kısaltmalar yerine ogrenciYasi, toplamFiyat, aktifKullaniciSayisi gibi açıklayıcı isimler tercih et. Kodu 6 ay sonra okuduğunda teşekkür edeceksin.

Java'nın Anahtar Kelimeleri

Java'da 50+ anahtar kelime (reserved word) var. Bunlar değişken, metot veya sınıf adı olarak kullanılamaz:

abstract  assert    boolean   break     byte
case      catch     char      class     const
continue  default   do        double    else
enum      extends   final     finally   float
for       goto      if        implements import
instanceof int      interface long      native
new       package   private   protected public
return    short     static    strictfp  super
switch    synchronized this   throw     throws
transient try       void      volatile  while

Bunların hepsini ezberleme. Zamanla hepsini öğreneceksin. Şimdilik IDE'n yanlış kullandığında seni uyaracak.

Operatörler

Operatörler, değerler üzerinde işlem yapmak için kullanılır. Java'nın operatörlerini kategorilere ayıralım.

Aritmetik Operatörler

public class AritmetikOperatorler {
    public static void main(String[] args) {
        int a = 17;
        int b = 5;

        System.out.println("a + b = " + (a + b));   // 22 (toplama)
        System.out.println("a - b = " + (a - b));   // 12 (çıkarma)
        System.out.println("a * b = " + (a * b));   // 85 (çarpma)
        System.out.println("a / b = " + (a / b));   // 3  (bölme — tam sayı!)
        System.out.println("a % b = " + (a % b));   // 2  (mod — kalan)
    }
}

⚠️ Dikkat: İki int bölünürse sonuç da int olur. 17 / 5 = 3, not 3.4! Ondalıklı sonuç istiyorsan en az bir taraf double olmalı:

System.out.println(17.0 / 5);   // 3.4
System.out.println((double) 17 / 5); // 3.4 (casting ile)

Atama Operatörleri

public class AtamaOperatorleri {
    public static void main(String[] args) {
        int x = 10;
        System.out.println("x = " + x);    // 10

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

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

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

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

        x %= 4;   // x = x % 4
        System.out.println("x %%= 4 → " + x); // 2
    }
}

Karşılaştırma Operatörleri

Sonuç her zaman boolean (true veya false) olur:

public class KarsilastirmaOperatorleri {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        System.out.println("a == b: " + (a == b));  // false (eşit mi?)
        System.out.println("a != b: " + (a != b));  // true  (eşit değil mi?)
        System.out.println("a > b:  " + (a > b));   // false (büyük mü?)
        System.out.println("a < b:  " + (a < b));   // true  (küçük mü?)
        System.out.println("a >= b: " + (a >= b));  // false (büyük eşit mi?)
        System.out.println("a <= b: " + (a <= b));  // true  (küçük eşit mi?)
    }
}

⚠️ Dikkat: Eşitlik kontrolü == (iki eşittir). Tek = atama operatörüdür. Bu en sık yapılan hatalardan biri:

if (x = 5) { ... }   // HATA! Bu atama, karşılaştırma değil.
if (x == 5) { ... }  // DOĞRU

Mantıksal Operatörler

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

        System.out.println("a && b: " + (a && b));   // false (VE)
        System.out.println("a || b: " + (a || b));   // true  (VEYA)
        System.out.println("!a: " + (!a));            // false (DEĞİL)

        // Pratik örnek
        int yas = 20;
        boolean ogrenci = true;

        boolean indirimVar = (yas < 25) && ogrenci;
        System.out.println("İndirim var mı? " + indirimVar);  // true
    }
}

&& (VE): İki taraf da true ise true. || (VEYA): En az bir taraf true ise true. ! (DEĞİL): true'yu false, false'u true yapar.

Artırma ve Azaltma Operatörleri

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

        x++;  // x = x + 1 → 6
        System.out.println("x++ → " + x);

        x--;  // x = x - 1 → 5
        System.out.println("x-- → " + x);

        // Prefix vs Postfix farkı
        int a = 10;
        System.out.println("a++: " + a++);  // 10 yazdırır, SONRA artırır
        System.out.println("a şimdi: " + a); // 11

        int b = 10;
        System.out.println("++b: " + (++b));  // ÖNCE artırır, 11 yazdırır
    }
}

a++ (postfix): Önce mevcut değeri kullan, sonra artır. ++a (prefix): Önce artır, sonra değeri kullan.

Operatör Önceliği

Matematikte çarpma toplamadan önce gelir. Java'da da benzer kurallar var:

public class OperatorOnceligi {
    public static void main(String[] args) {
        // Çarpma toplamadan önce gelir
        int sonuc1 = 2 + 3 * 4;
        System.out.println("2 + 3 * 4 = " + sonuc1);  // 14 (3*4=12, 2+12=14)

        // Parantezle değiştirebilirsin
        int sonuc2 = (2 + 3) * 4;
        System.out.println("(2 + 3) * 4 = " + sonuc2); // 20

        // Karmaşık ifade
        boolean sonuc3 = 5 > 3 && 10 < 20 || false;
        System.out.println("5 > 3 && 10 < 20 || false = " + sonuc3); // true
    }
}

💡 İpucu: Emin olmadığın yerde parantez kullan. Hem kodu daha okunabilir yapar hem de beklenmedik sonuçları önler. a + b * c yerine a + (b * c) yazmak açıklığı artırır.

Tip Dönüşümleri (Type Casting)

Bazen bir tipten diğerine dönüşüm gerekir. İki türü var:

Otomatik (Widening) Dönüşüm

Küçük tipten büyük tipe dönüşüm otomatik yapılır. Veri kaybı olmaz:

byte → short → int → long → float → double

public class OtomatikDonusum {
    public static void main(String[] args) {
        int tamSayi = 42;
        double ondalikli = tamSayi;  // Otomatik: int → double
        System.out.println(ondalikli);  // 42.0

        byte kucuk = 100;
        int buyuk = kucuk;  // Otomatik: byte → int
        System.out.println(buyuk);  // 100
    }
}

Manuel (Narrowing) Dönüşüm — Casting

Büyük tipten küçük tipe dönüşüm tehlikeli olabilir (veri kaybı), bu yüzden sen açıkça belirtmelisin:

public class ManuelDonusum {
    public static void main(String[] args) {
        double pi = 3.14159;
        int tamPi = (int) pi;  // Manuel casting: double → int
        System.out.println(tamPi);  // 3 (ondalık kısım kayboldu!)

        int buyukSayi = 300;
        byte kucukSayi = (byte) buyukSayi;  // Tehlikeli!
        System.out.println(kucukSayi);  // 44 (taşma — overflow!)
    }
}

300 değeri byte'ın aralığını (−128 ile 127) aştığı için garip bir sonuç çıkar. Bu taşma (overflow) hatalarına dikkat et.

Sabitler (Constants)

Değişmeyen değerler için final anahtar kelimesini kullan:

public class SabitOrnegi {
    public static void main(String[] args) {
        final double PI = 3.14159;
        final int MAX_DENEME = 3;

        double yaricap = 5.0;
        double alan = PI * yaricap * yaricap;
        System.out.println("Dairenin alanı: " + alan);

        // PI = 3.0;  // HATA! final değişken değiştirilemez
    }
}

final ile tanımlanan değişkenin değeri bir kere atandıktan sonra değiştirilemez. Sabitler BÜYÜK_HARF_VE_ALT_ÇİZGİ ile yazılır.

Noktalı Virgül ve Süslü Parantez

Java'da her ifade (statement) noktalı virgül ile biter:

int x = 5;                           // Noktalı virgül zorunlu
System.out.println("Merhaba");       // Burada da
String isim = "Java";                // Burada da

Süslü parantezler {} kod bloklarını tanımlar:

public class BlokOrnegi {                    // Sınıf bloğu başlıyor
    public static void main(String[] args) { // Metod bloğu başlıyor
        if (true) {                          // If bloğu başlıyor
            System.out.println("İç blok");
        }                                    // If bloğu bitiyor
    }                                        // Metod bloğu bitiyor
}                                            // Sınıf bloğu bitiyor

Her { için bir } olmalı. IDE'ler eşleşmeyen parantezleri gösterir ama terminalden yazıyorsan dikkatli ol.

Girintileme (Indentation)

Java derleyicisi girintilemeyi umursamaz ama insanlar umursar. Şu iki kod teknik olarak aynı:

// Okunabilir (DOĞRU)
public class Test {
    public static void main(String[] args) {
        int x = 5;
        if (x > 3) {
            System.out.println("Büyük");
        }
    }
}

// Okunaksız (TEKNİK OLARAK ÇALIŞIR AMA YAPMA)
public class Test{public static void main(String[]args){int x=5;if(x>3){System.out.println("Büyük");}}}

Her blok düzeyinde 4 boşluk veya 1 tab girinti kullan. Tutarlı ol — aynı projede karıştırma.

Pratik: Her Şeyi Birleştiren Örnek

public class OgrenciBilgi {
    public static void main(String[] args) {
        // Sabitler
        final int GECME_NOTU = 50;

        // Öğrenci bilgileri
        String ad = "Zeynep";
        String soyad = "Kaya";
        int yas = 21;
        double vize = 65.5;
        double finalNotu = 78.0;

        // Ortalama hesapla (vize %40, final %60)
        double ortalama = (vize * 0.4) + (finalNotu * 0.6);

        // Geçti mi?
        boolean gectiMi = ortalama >= GECME_NOTU;

        // Sonuçları yazdır
        System.out.println("=== Öğrenci Bilgi Kartı ===");
        System.out.printf("Ad Soyad: %s %s%n", ad, soyad);
        System.out.printf("Yaş: %d%n", yas);
        System.out.printf("Vize: %.1f | Final: %.1f%n", vize, finalNotu);
        System.out.printf("Ortalama: %.2f%n", ortalama);
        System.out.printf("Durum: %s%n", gectiMi ? "GEÇTİ ✓" : "KALDI ✗");
    }
}

Çıktı:

=== Öğrenci Bilgi Kartı ===
Ad Soyad: Zeynep Kaya
Yaş: 21
Vize: 65.5 | Final: 78.0
Ortalama: 73.00
Durum: GEÇTİ ✓

Bu örnekte değişkenler, sabitler, aritmetik operatörler, karşılaştırma ve formatlı yazdırma bir arada kullanıldı.

Scope (Kapsam): Değişken Nerede Geçerli?

Bir değişken sadece tanımlandığı blok içinde geçerlidir:

public class ScopeOrnegi {
    public static void main(String[] args) {
        int x = 10;  // main bloğunda tanımlı

        if (x > 5) {
            int y = 20;  // if bloğunda tanımlı
            System.out.println(x);  // OK — x burada erişilebilir
            System.out.println(y);  // OK — y burada tanımlı
        }

        System.out.println(x);  // OK — x hâlâ kapsamda
        // System.out.println(y);  // HATA! y sadece if bloğunda geçerli
    }
}

Değişkenin kapsamı, tanımlandığı { ile } arasıdır. Blok kapandığında değişken yok olur.

Özet

• Değişkenler, verileri bellekte saklamak için kullanılır: tip isim = değer; formatıyla tanımlanır.

• Java'da 8 primitive tip vardır: byte, short, int, long, float, double, boolean, char. En çok int, double, boolean ve String kullanılır.

• İsimlendirme: Değişkenler camelCase, sınıflar PascalCase, sabitler SCREAMING_SNAKE_CASE ile yazılır. Anlamlı isimler kullan.

• Operatörler: Aritmetik (+, -, *, /, %), karşılaştırma (==, !=, <, >), mantıksal (&&, ||, !) operatörleri temel yapı taşlarıdır.

• Tip dönüşümleri: Küçükten büyüğe otomatik (widening), büyükten küçüğe manuel casting (narrowing) gerekir.

• Her ifade noktalı virgül ile biter, kod blokları süslü parantez ile sarılır. Girintileme okunabilirlik için kritiktir.