Java'da Tür Dönüşümü: Genişletme, Daraltma ve Dönüşümler

Tür Dönüşümü Ne Demektir

Java statik olarak türlenmiştir: her değerin bir türü vardır ve derleyici uyumsuz türleri sessizce karıştırmanıza izin vermez. Tür dönüşümü, bir değeri bir türden başka bir türe çevirme şeklinizdir — bazen Java bunu sizin için yapar, bazen de bunu açıkça istemeniz gerekir.

İki yön vardır. Daha küçük bir türden daha büyük bir türe geçmek (bir int'i bir double'a) güvenlidir ve otomatik gerçekleşir. Daha büyük bir türden daha küçük bir türe geçmek (bir double'ı bir int'e) veri kaybına yol açabilir, bu yüzden Java bunu bir dönüşümle açıkça belirtmenizi zorunlu kılar.

Genişletme: Otomatik Dönüşüm

Bir genişletme dönüşümü, bir değeri daha fazla yeri olan bir türe taşır. Hiçbir şey kaybolamaz, bu yüzden Java bunu dönüşüm gerektirmeden sizin için yapar:

public class Main {
    public static void main(String[] args) {
        int count = 7;
        double price = count;   // int -> double, otomatik

        System.out.println(price);   // 7.0
    }
}

int 7, bir double'a yerleşir ve 7.0 olur. Sayılar için genişletme sırası byte -> short -> int -> long -> float -> double şeklindedir; bu zincir boyunca soldan sağa atama yapmak asla dönüşüm gerektirmez. Aritmetikte türleri karıştırmanın çoğunlukla "kendiliğinden çalışmasının" nedeni budur — Java önce daha küçük işleneni genişletir.

Daraltma: Açık Dönüşüm

Diğer yöne — bir daraltma dönüşümüne — geçmek veri kaybına yol açabilir, bu yüzden hedef türü değerin önüne parantez içinde koymazsanız derleyici reddeder:

public class Main {
    public static void main(String[] args) {
        double pi = 3.9;
        int whole = (int) pi;   // açık daraltma dönüşümü

        System.out.println(whole);   // 3, 4 değil
    }
}

(int) pi dönüşümdür. Ne yaptığına dikkat edin: sıfıra doğru kırpar, yani ondalık kısmı basitçe atar. 3.9, 3 olur ve -3.9, -3 olur. Yuvarlamaz. Yuvarlamak istiyorsanız, bu farklı bir araçtır:

public class Main {
    public static void main(String[] args) {
        double value = 3.9;

        System.out.println((int) value);          // 3  (kırpar)
        System.out.println(Math.round(value));    // 4  (yuvarlar)
    }
}

Bir dönüşümün kırptığını unutmak, yeni başlayanların en sık yaptığı hatalardan biridir — "yuvarlanmış" sayınız her zaman bir eksik çıkıyorsa, genellikle nedeni budur.

Tam Sayı Bölmesi Tuzağı

Bu tuzak herkesi bir kez yakalar. Her iki işlenen de int olduğunda, / operatörü tam sayı bölmesi yapar ve kalanı atar — bir double'a herhangi bir atama yapılmadan önce:

public class Main {
    public static void main(String[] args) {
        int a = 7;
        int b = 2;

        double wrong = a / b;          // 3.0  - bölme önce int olarak yapılır!
        double right = (double) a / b; // 3.5  - önce bir işleneni dönüştür

        System.out.println(wrong);
        System.out.println(right);
    }
}

a / b, 7 / 2'dir, tamamen int aritmetiğiyle hesaplanır ve 3 verir. Sonradan double'a genişletmek yalnızca 3'ü 3.0'a çevirir — .5 zaten gitmiştir. Önce bir işleneni double'a dönüştürmek ((double) a / b) tüm ifadeyi kayan noktaya zorlar ve istediğiniz 3.5'i verir. Yalnızca bir tarafı dönüştürmeniz yeterli; Java diğerini eşleşecek şekilde genişletir.

Daraltma Taştığında

Bir dönüşüm, değerin sığıp sığmadığını kontrol etmez. Sığmazsa, bitler basitçe kesilir ve şaşırtıcı bir sonuç elde edersiniz — hata yok, uyarı yok:

public class Main {
    public static void main(String[] args) {
        int big = 300;
        byte small = (byte) big;   // byte yalnızca -128..127 tutar

        System.out.println(small);   // 44, 300 değil
    }
}

300 bir byte'a sığmaz, bu yüzden üst bitler atılır ve 44 elde edersiniz. Bu "sessiz" veri kaybıdır — program sorunsuz çalışır ve yanlış bir cevap verir. Yalnızca değerin daha küçük türe sığdığından emin olduğunuzda daraltın.

Sayılarla Metinler Arasında Dönüşüm

Bir String bir nesnedir, sayı değildir, bu yüzden onu (int) ile dönüştüremezsiniz — bu bir derleme hatasıdır. Dönüşüm bunun yerine özel metotlar kullanır:

public class Main {
    public static void main(String[] args) {
        String text = "42";
        int n = Integer.parseInt(text);       // String -> int
        double d = Double.parseDouble("3.14"); // String -> double

        System.out.println(n + 1);   // 43

        String back = String.valueOf(n);       // int -> String
        System.out.println(back + "!");         // 42!
    }
}

Metinden sayıya geçmek için Integer.parseInt / Double.parseDouble kullanılır. Metin geçerli bir sayı değilse (örneğin "hello"), bu metotlar bir NumberFormatException fırlatır. Sayıdan metne geçmek için String.valueOf(n) kullanın ya da basitçe "" ile birleştirin — çünkü n + "", int'i bir String'e zorlar. "5" + 1 (string "51" verir) ile 5 + 1 (6 verir) arasındaki farka dikkat edin; bir String işin içine girdiği an +, birleştirme anlamına gelir.

Nesneleri Dönüştürme

Dönüşüm yalnızca ilkel türlere değil, nesne referanslarına da uygulanır. Bir referansı, bir kalıtım zinciri boyunca ilişkili bir türe dönüştürebilirsiniz — bir üst türe genişletmek otomatiktir, geri daraltmak ise açık bir dönüşüm gerektirir ve yalnızca nesne gerçekten o türse güvenlidir:

Object o = "hello";
String s = (String) o;        // OK: o gerçekten bir String'e işaret ediyor
Integer bad = (Integer) o;    // derlenir, ancak çalışma zamanında ClassCastException fırlatır

İkinci dönüşüm derlenir ama çalışma zamanında bir ClassCastException ile patlar, çünkü nesne bir String'dir, Integer değil. Kalıtım ve çok biçimliliğe ulaştığınızda bununla gerçek anlamda tanışacaksınız; şimdilik, (Type) söz diziminin nesnelere uygulanan aynı fikir olduğunu bilmeniz yeterli.

Sonraki: if-else

Dönüşüm, değerleri yeniden şekillendirmenizi sağlar; bir sonraki adım, programınızın bu değerlere göre yollar arasında seçim yapmasını sağlamaktır. if-else deyimi, bir koşul doğru olduğunda bir bloğu, yanlış olduğunda başka bir bloğu çalıştırır — kodunuzun verdiği her kararın temelidir. Bir sonraki sayfa budur.