Bölüm 3: Tip Dönüşümleri, Sayısal İşlemler ve Operatörler

Programlama dünyasında veriler farklı türlerde karşımıza çıkar: tam sayılar, ondalıklı sayılar, metinler, mantıksal değerler… Çoğu zaman bu farklı türler arasında geçiş yapmamız gerekir. Örneğin, bir kullanıcıdan alınan metni sayıya çevirmek veya bir hesaplama sonucunu metin olarak göstermek. İşte bu noktada tip dönüşümü (type conversion) devreye girer.

Bu bölümde, Java’da veri tipleri arasındaki dönüşümleri, matematiksel operatörleri ve işlem önceliği kurallarını detaylı bir şekilde inceleyeceğiz. Amacımız, farklı veri türleriyle güvenli ve doğru bir şekilde çalışabilmenizi sağlamaktır.

Pedagojik Not: Bu bölümdeki örneklerin çoğu, Python ve Java arasındaki farkları vurgulayacak şekilde tasarlanmıştır. Java, statik tipli bir dil olduğu için tip dönüşümleri Python’a göre daha katı kurallara tabidir.

3.1 Veri Tipleri ve Temel Dönüşüm Kavramları

3.2 Sayısal ve Metinsel Veri Tipleri

Java’da temel (primitive) veri tipleri şunlardır:

Tip	Boyut	Açıklama	Örnek
`byte`	8 bit	Küçük tam sayılar	-128 ile 127
`short`	16 bit	Orta boy tam sayılar	-32,768 ile 32,767
`int`	32 bit	Standart tam sayı	-2³¹ ile 2³¹-1
`long`	64 bit	Büyük tam sayılar	-2⁶³ ile 2⁶³-1
`float`	32 bit	Tek duyarlıklı ondalık	±3.4E-38 ile ±3.4E+38
`double`	64 bit	Çift duyarlıklı ondalık	±1.7E-308 ile ±1.7E+308
`char`	16 bit	Tek karakter	‘A’, ‘5’, ‘’
`boolean`	1 bit	Mantıksal değer	true, false

Metinsel veriler için String sınıfı kullanılır (primitive tip değildir).

3.3 Tip Dönüşümünün Temel İlkeleri

Java’da tip dönüşümü iki şekilde gerçekleşir:

Otomatik (Örtük) Dönüşüm (Widening Casting)

Küçük kapasiteli bir tip, daha büyük kapasiteli bir tipe otomatik olarak dönüştürülür. Bu işlemde veri kaybı olmaz.

Dönüşüm zinciri: byte → short → int → long → float → double

int sayi = 100;
long buyukSayi = sayi;  // Otomatik dönüşüm
double ondalik = sayi;  // Otomatik dönüşüm

Açık (Explicit) Dönüşüm (Narrowing Casting)

Büyük kapasiteli bir tip, daha küçük kapasiteli bir tipe dönüştürülürken veri kaybı riski olduğu için açık dönüşüm (cast) operatörü kullanılmalıdır.

double ondalik = 9.78;
int tamSayi = (int) ondalik;  // Açık dönüşüm, sonuç: 9

Uyarı: Açık dönüşümlerde veri kaybı yaşanabilir. Ondalıklı kısım atılır (truncation), büyük sayılar taşabilir (overflow).

3.4 Dönüşüm Fonksiyonları

Java’da tip dönüşümleri için çeşitli sınıf metotları bulunur:

Integer.parseInt(String) - Metni int’e çevirir
Double.parseDouble(String) - Metni double’a çevirir
String.valueOf(sayi) - Sayıyı metne çevirir
Integer.valueOf(String) - Metni Integer nesnesine çevirir

public class TipDonusumOrnekleri {
    public static void main(String[] args) {
        // Metinden sayıya dönüşüm
        String metinSayi = "123";
        int sayi = Integer.parseInt(metinSayi);
        System.out.println("Metinden sayıya: " + sayi);
        
        // Sayıdan metne dönüşüm
        double pi = 3.14159;
        String piMetin = String.valueOf(pi);
        System.out.println("Sayıdan metne: " + piMetin);
        
        // Farklı tabanlardan dönüşüm
        String binary = "1010";
        int binaryDeger = Integer.parseInt(binary, 2);
        System.out.println("İkili taban: " + binary + " -> " + binaryDeger);
        
        String hex = "FF";
        int hexDeger = Integer.parseInt(hex, 16);
        System.out.println("Onaltılı taban: " + hex + " -> " + hexDeger);
    }
}

Çıktı:

Metinden sayıya: 123
Sayıdan metne: 3.14159
İkili taban: 1010 -> 10
Onaltılı taban: FF -> 255

3.5 Sayısal Tipler Arası Dönüşümler

3.6 Tam Sayı ve Ondalıklı Sayı Dönüşümleri

int → float/double (Otomatik Genişleme)

int tamSayi = 42;
double ondalik = tamSayi;  // Otomatik, veri kaybı yok
System.out.println(ondalik);  // 42.0

float/double → int (Veri Kaybı Riski)

double ondalik = 3.14159;
int tamSayi = (int) ondalik;  // Açık dönüşüm
System.out.println(tamSayi);  // 3 (ondalık kısım atılır)

Yuvarlama İşlemleri

Java’da yuvarlama için Math sınıfı kullanılır:

double sayi = 3.7;

long asagiYuvarla = (long) Math.floor(sayi);  // 3
long yukariYuvarla = (long) Math.ceil(sayi);  // 4
long enYakin = Math.round(sayi);              // 4

İpucu: Math.round() metodu, .5 ve üzerini yukarı yuvarlar. Bu, bankacılık uygulamaları için uygun olmayabilir.

3.7 Metin ve Sayı Dönüşümleri

Sayısal İçerikli Metinlerin Dönüşümü

String dogruMetin = "123";
int dogruSayi = Integer.parseInt(dogruMetin);  // Başarılı

String hataliMetin = "abc";
// int hataliSayi = Integer.parseInt(hataliMetin);  // NumberFormatException!

Hata Yönetimi (Try-Catch)

public static int guvenliDonusum(String metin) {
    try {
        return Integer.parseInt(metin);
    } catch (NumberFormatException e) {
        System.out.println("Hata: Geçersiz sayı formatı!");
        return 0;  // Varsayılan değer
    }
}

3.8 Mantıksal Değerlerin Sayısal Dönüşümü

Java’da boolean tipleri doğrudan sayısal tiplere dönüştürülemez. Ancak mantıksal işlemlerde kullanılabilir:

boolean dogru = true;
boolean yanlis = false;

// Java'da boolean -> int otomatik dönüşümü yoktur!
// int sayi = dogru;  // HATA!

// Mantıksal değerleri sayısal olarak kullanma
int sonuc = dogru ? 1 : 0;  // Ternary operatörü ile

Önemli Not: Python’dan farklı olarak, Java’da true değeri 1’e, false değeri 0’a otomatik olarak dönüşmez. Bu, tip güvenliği için bilinçli bir tasarım tercihidir.

public class SayisalDonusumUygulamalari {
    public static void main(String[] args) {
        // 1. Ondalıklı sayıdan tam sayıya (veri kaybı)
        double maas = 5750.75;
        int maasTam = (int) maas;
        System.out.println("Maaş (double): " + maas);
        System.out.println("Maaş (int): " + maasTam + " (kayıp: " + (maas - maasTam) + ")");
        
        // 2. Yuvarlama örnekleri
        double[] degerler = {2.3, 2.7, 3.5, 4.5};
        for (double d : degerler) {
            System.out.printf("%.1f -> floor: %.0f, ceil: %.0f, round: %d%n", 
                d, Math.floor(d), Math.ceil(d), Math.round(d));
        }
        
        // 3. Metin dönüşümü ve hata yönetimi
        String[] testMetinler = {"123", "45.67", "abc", "0xFF"};
        for (String m : testMetinler) {
            try {
                if (m.contains(".")) {
                    double d = Double.parseDouble(m);
                    System.out.println(m + " -> " + d);
                } else {
                    int i = Integer.parseInt(m);
                    System.out.println(m + " -> " + i);
                }
            } catch (NumberFormatException e) {
                System.out.println(m + " -> HATA: Geçersiz format!");
            }
        }
    }
}

Çıktı:

Maaş (double): 5750.75
Maaş (int): 5750 (kayıp: 0.75)
2.3 -> floor: 2, ceil: 3, round: 2
2.7 -> floor: 2, ceil: 3, round: 3
3.5 -> floor: 3, ceil: 4, round: 4
4.5 -> floor: 4, ceil: 5, round: 5
123 -> 123
45.67 -> 45.67
abc -> HATA: Geçersiz format!
0xFF -> HATA: Geçersiz format!

3.9 Matematiksel Operatörler

3.10 Temel Aritmetik Operatörler

Java’da temel aritmetik operatörler şunlardır:

Operatör	İşlem	Örnek	Sonuç
`+`	Toplama	`5 + 3`	`8`
`-`	Çıkarma	`5 - 3`	`2`
`*`	Çarpma	`5 * 3`	`15`
`/`	Bölme	`5 / 3`	`1` (int) / `1.666...` (double)
`%`	Mod (Kalan)	`5 % 3`	`2`
`++`	Artırma	`++x` veya `x++`	`x+1`
`--`	Azaltma	`--x` veya `x--`	`x-1`

Tam Bölme ve Ondalıklı Bölme

Java’da bölme işlemi, operandların tiplerine göre farklı sonuç verir:

int a = 10;
int b = 3;

int tamBolme = a / b;        // 3 (int / int = int)
double ondalikBolme = (double) a / b;  // 3.333... (double / int = double)

Dikkat: İki tam sayının bölümü her zaman tam sayıdır! Ondalıklı sonuç istiyorsanız en az bir operandı double’a dönüştürmelisiniz.

Mod Alma İşlemi

Mod operatörü, bölme işleminden kalanı verir:

System.out.println(10 % 3);   // 1
System.out.println(15 % 5);   // 0 (tam bölünür)
System.out.println(7 % 10);   // 7 (bölünemez)
System.out.println(-7 % 3);   // -1 (negatif sayılarda dikkat!)

Pratik Kullanım: Mod operatörü, bir sayının çift/tek olduğunu kontrol etmek için idealdir: sayi % 2 == 0 → çift, sayi % 2 == 1 → tek.

3.11 İleri Düzey Matematiksel İşlemler

Atama Operatörleri

Kısa yazım şekilleri:

int x = 10;
x += 5;   // x = x + 5 → 15
x -= 3;   // x = x - 3 → 12
x *= 2;   // x = x * 2 → 24
x /= 4;   // x = x / 4 → 6
x %= 4;   // x = x % 4 → 2

Math Sınıfı Metotları

Math.sqrt(16);     // 4.0 (karekök)
Math.pow(2, 3);    // 8.0 (üs alma)
Math.abs(-5);      // 5 (mutlak değer)
Math.max(10, 20);  // 20 (büyük olan)
Math.min(10, 20);  // 10 (küçük olan)
Math.random();     // 0.0 ile 1.0 arasında rastgele sayı

Üs Alma ve Karekök

// Math.pow ile üs alma
double kare = Math.pow(5, 2);     // 25.0
double kup = Math.pow(5, 3);      // 125.0
double kok = Math.pow(16, 0.5);   // 4.0

// Math.sqrt ile karekök
double kareKok = Math.sqrt(25);   // 5.0

3.12 Farklı Veri Tiplerinde Operatör Davranışları

String Birleştirme

String selam = "Merhaba, ";
String isim = "Ahmet";
String mesaj = selam + isim;  // "Merhaba, Ahmet"

// Sayı + String = String
String yasMetin = "Yaş: " + 25;  // "Yaş: 25"

String Tekrarlama

Java’da String’ler için * operatörü yoktur. Bunun

3. Operatorler