|
|
|
Java 5.0 (Tiger) ile Gelen Dil Yenilikleri 2 : Autoboxing/Unboxing |
|
| Gönderiliyor lütfen bekleyin... |
|
|
Merhaba, bir önceki yazımda Java 5.0 ile gelen yeni dil özelliklerinden biri olan Generic yapılardan bahsetmiştim.İkinci olarak Autoboxing ve Unboxing konusunda bilgi vermeye çalışacağım.
Öncelikle Java 5.0 ile gelen yeni dil özellikleri nelerdir tekrar hatırlayalım;
- Generic yapılar
- Autoboxing/Unboxing
- Gelişmiş for döngüsü
- Typesafe Enum (Güvenli sıralama yapıları)
- Varargs (Değişken sayıda argüman)
- Static Import
- Metadata (Annotations)
Java programlama dilinde iki tür değişken tipi vardır, İlkel tipler (Primitive Types) ve referans tipleri (Reference Types). Java programlama dilinde, C# dilinde var olan struct yapısi gibi değer tipi (Value Type ) olarak bildiğimiz yapılar yoktur.
İlkel Tipler
İlkel tipleri hepimiz biliyoruz, sayısal veya boolean değerler tutuğumuz en temel tiplerimizdir (byte, int, short, long, char, float ve double gibi ).İlkel tipler hafızanın stack bölümünde yar alırlar.Bir metoda değişken olarak geçildiğinde bir kopyası alınıp kopyası üzerinden işlem yapılır, dolayısı ile mevcut değer değişmemiş olur.
Aşağıdaki kodu denediğinizde x değerinin değişmediğini göreceksiniz;
public class PrimitiveType
{
public static void main(String[] args)
{
int x = 100;
System.out.println("Deger Arttir Methodundan Once = " + x);
degerArttir(x);
System.out.println("Deger Arttir Methodundan Sonra = " + x);
}
public static void degerArttir(int deger)
{
deger += 20;
}
}
|
Referans Tipleri
Referans tipleri sınıflar ve arraylar dir. Referans tipleri değer tiplerinin aksine metodlara geçtiğimizde kopyaları üzerinden işlem yapılmazlar, mevcut nesneler üzerinden işlem yapılırlar.Bu yüzden yukarıdaki kodu x değerini kendi yazdığımız bir referans tipi (DenemeSinifi) içerisinde koyup bir metot aracılığı ile değerini arttırdıktan sonra tekrar ekrana yazdırırsak x değerinin değişmiş olduğunu göreceğiz;
public class MainProgram
{
public static void main(String[] args)
{
DenemeSinifi d = new DenemeSinifi();
d.x = 100;
System.out.println("Deger Arttir Methodundan Once = " + d.x);
degerArttir(d);
System.out.println("Deger Arttir Methodundan Sonra = " + d.x);
}
public static void degerArttir(DenemeSinifi d)
{
d.x += 20;
}
}
class DenemeSinifi
{
public int x;
}
|
Yukarıdaki kodda yaptığımız işleme sarmalama (wrapping) işlemi denilmektedir.
Java da program yazarken bazen ilkel tiplerin yukarıdaki gibi başka bir sınıf tarafından sarmalanmasına ihtiyaç duyarız. Özellikle kolleksiyon (collections) sınıfları ile çalışıyorsak bu kaçınılmazdır.
Bunun sebebi kolleksiyon nesneleri içerlerinde sadece nesne (object) tutabilirler. Eğer biz bir kolleksiyon nesnesinin içerisinde bir ilkel tip tutmak istiyorsak mecburen o ilkel tipi başka bir sınıf ile sarmalamamız gerekecek. Bu yüzden Java da java.lang paketinin (package) altında her ilkel tip için bir sarmalayıcı (wrapper classes) sınıf vardır.
Bir ilkel tipi bir sarmalayıcı (wrapper class) sınıf içerisine koyma işlemine Boxing (kutulama), sarmalıyıcı sınıfın içerisinden ilkel tipi geri alma işleminede Unboxing (kutudan çıkarma) işlemi denilmektedir.
int x = 100;
Integer box = new Integer (x); //BOXING
int y = box.intValue(); //UNBOXING
Aşağıdaki kod örneğinde bir vektör içerisinde int değerleri ekliyoruz.
import java.util.Vector;
public class VektorDeneme
{
public static void main(String[] args)
{
Vector v = new Vector();
int x = 100;
int y = 200;
int z = 300;
Integer xwrap = new Integer(x); //Boxing
Integer ywrap = new Integer(y); //Boxing
Integer zwrap = new Integer(z); //Boxing
v.add(xwrap);
v.add(ywrap);
v.add(zwrap);
}
}
|
Java 5.0 dan önce her sarmalayıcı (wrapper) sınıf kullandığımızda mecburen boxing ve unboxing işlemi yapmak zorundaydık.Fakat Java 5.0 ile artık bunu yapmak zorunda değiliz.Çünkü bu işlem Java 5.0 tarafından otomatik olarak yapılıyor.
Yani ilkel tipleri nesne gibi , sarmalayıcı sınıfından yaratılan nesneleride ilkel tipler gibi kullanabiliyoruz. Birbirleri arasındaki dönüşümler otomatik olarak yapılıyor.
Aşağıdaki kod örnekleri Java 5.0 dan önce hangi durumlarda hatalarla karşılaşacağımızı göstermektedir.
import java.util.Vector;
public class Ornekler
{
public static void main(String[] args)
{
Integer i = new Integer(100);
i++;
//ERROR 1
Integer x = new Integer(12);
Integer y = new Integer(13);
Integer z = x + y;
//ERROR 2
int a = new Integer(99);
//ERROR 3
Integer b = 555;
//ERROR 4
int w = 100;
Vector v = new Vector();
v.add(w);
//ERROR 5
int k = 777;
Integer l = new Integer(333);
int m = k + l;
//ERROR 6
}
}
|
Yukarıdaki kodu kopyalayıp Java 1.4 ile derlemeye çalışırsanız ERROR satırlarında boxing ve unboxing işlemlerini yapmadığınız için çeşitli hatalar alırsınız.
Hataların sebeplerini kısaca açıklayacak olursak;
ERROR 1 : Bir nesnenin değerini arttırmak için ++ operatörünü kullanamayız, bunu yapabilmek için i nesnesini int dönüştürmemiz (unboxing) gerekir.
ERROR 2 : İkin nesneyi + operatörü ile toplayamayız önce unboxing işlemi yapmamız gerekir.
ERROR 3 : İlkel bir tipe nesne ataması yapamayız.
ERROR 4 : Bir nesneye ilkel değer atayamayız. New anahtar kelimesi ile nesne yaratmamız gerekir.
ERROR 5 : Kolleksiyon nesnelerinin içerisinde ilkel tipler tutamayız.
ERROR 6 : Bir ilkel tiple nesneyi toplayamayız.
Fakat aynı kodu Java 5.0 ile
derlerseniz hiçbir hata ile karşılaşmazsınız, sebebi Boxing veya Unboxing işlemlerinin gereken yerlerde Java 5.0 ile gelen Autoboxing/Unboxing özelliği sayesinde otomatik olarak yapılıyor olmasıdır.
Önemli Nokta;
Wrapper
sınıflar immutable (değişmez) özelliğe sahiptirler, sıradan nesneler gibi davranmazlar.
Mesela; yukarıda ikinci yazmış olduğumuz kodda eğer DenemeSinifi yerine bir Integer wrapper sınıfını kullansaydık yine değerimiz ilkel tiplerde olduğu gibi değişmeyecekti. Çünkü immutable nesneler metotlara değişken olarak geçildiğinde kopyalarıı üzerinden işlem yapılır.
public class MainProgram
{
public static void main(String[] args)
{
Integer d = new Integer();
d = 100;
System.out.println("Değer Arttır Methodundan Once = " + d);
degerArttir(d);
System.out.println("Değer Arttır Methodundan Sonra = " + d); //d değeri değişmez
}
}
|
Yukarıdaki kodun son satrırında d bir referans tipi olduğu için değerinin ikinci örnekte olduğu gibi değişmiş olmasını bekliyoruz fakat sarmalıyıcı (wrapper) sınıflar immutable (değişmez değerli) oldukları için d nesnesinin değeri değişmemektedir.
Bu makale serisinin üçüncüsünde Gelişmiş for döngüsü konusundan bahsedeceğim. Görüşmek üzere.
Bilgiyi paylaşalım....
iyi çalışmalar
[email protected]
Makale:
Java 5.0 (Tiger) ile Gelen Dil Yenilikleri 2 : Autoboxing/Unboxing J# ve Java dili Ahmet Demirelli
|
|
|
|
|
-
-
Eklenen Son 10
-
Bu Konuda Geçmiş 10
Bu Konuda Yazılmış Yazılmış 10 Makale Yükleniyor
Son Eklenen 10 Makale Yükleniyor
Bu Konuda Yazılmış Geçmiş Makaleler Yükleniyor
|
|
|