Java’da Veri Tipleri

Java, strongly-typed bir programlama dilidir. Yani her değişkenin mutlaka bir veri tipi olmak zorundadır. Bu veri tipi, değişkenin ne türde veri tutacağını belirler: sayı mı, karakter mi, metin mi, mantıksal ifade mi?
Bu yazıda Java’daki veri tiplerini (data types) detaylıca inceleyecek ve “primitive” ile “non-primitive” farklarını netleştireceğiz.

Java’da iki ana data type kategorisi bulunur:

1. Primitive Data Types (İlkel Veri Tipleri)
2. Non-Primitive Data Types (İlkel Olmayan Veri Tipleri / Referans Veri Tipleri)

Primitive Data Types

Primitive data types, Java’nın en temel data types’larıdır ve doğrudan bir değer tutarlar. Hafızada sabit bir boyutu vardır ve bu, onları diğer data types’a göre daha verimli hale getirir. Java’da 8 farklı primitive data type bulunur:

1. Tam Sayı Tipleri (Integer Types)

Bu tipler, ondalık kısmı olmayan tam sayıları depolamak için kullanılır. Farklı boyutlarda ve dolayısıyla farklı aralıklarda değer tutabilirler.

byte:

• Boyut: 1 byte (8 bit)
• Değer Aralığı: -128'den 127'ye
• Kullanım: Çok küçük sayılar veya diskte yer kazanmak istediğinizde idealdir.

byte b = 100; // byte smallNumber = 150; // Hata verir, çünkü 127'den büyük.

short:

• Boyut: 2 byte (16 bit)
• Değer Aralığı: -32,768'den 32,767'ye
• Kullanım: byte’dan daha geniş, ancak hala küçük sayılar için kullanılır.

short s = 20000;

int:

• Boyut: 4 byte (32 bit)
• Değer Aralığı: Yaklaşık -2 milyardan 2 milyara
• Kullanım: En yaygın kullanılan tam sayı tipidir. Çoğu zaman yeterlidir.

int i = 1500000; // 1.5 Milyon

long:

• Boyut: 8 byte (64 bit)
• Değer Aralığı: Çok büyük sayılar (yaklaşık -9 kentilyondan 9 kentilyona)
• Kullanım: int’in yetersiz kaldığı çok büyük tam sayı değerlerini depolamak için kullanılır. Bir long sabiti tanımlarken sayının sonuna L veya l eklemek yaygın bir uygulamadır.

long l = 1234567890123L; // Sonundaki 'L' önemli

2. Ondalıklı Sayı Tipleri (Floating-Point Types)

Bu tipler, ondalık kısmı olan sayıları (kesirli sayılar) depolamak için kullanılır.

float:

• Boyut: 4 byte (32 bit)
• Hassasiyet: Yaklaşık 6–7 ondalık basamak.
• Kullanım: Daha az hassasiyet gerektiren ve hafızadan tasarruf etmek istediğiniz durumlarda kullanılır. Bir float sabiti tanımlarken sayının sonuna F veya f eklemek zorunludur.

float f = 3.14f; // Sonundaki 'f' önemli

double:

• Boyut: 8 byte (64 bit)
• Hassasiyet: Yaklaşık 15 ondalık basamak.
• Kullanım: Çoğu bilimsel ve finansal hesaplama için varsayılan ve tercih edilen ondalıklı tip budur. Çok daha yüksek hassasiyet sunar.

double d = 19.99d; // 'd' isteğe bağlıdır, varsayılan double'dır 
double pi = 3.1415926535;

3. Karakter Tipi (Character Type)

char:

• Boyut: 2 byte (16 bit)
• Kullanım: Tek bir karakteri depolamak için kullanılır. Karakterler tek tırnak ( ' ' ) içine yazılır. Java'da char, Unicode karakter setini destekler, bu da dünya üzerindeki çoğu dili ve sembolü temsil edebilir anlamına gelir.

char initial = 'A'; 
char symbol = '$'; 
char unicodeChar = '\u0041'; // 'A' karakterinin Unicode değeri

4. Mantıksal Tip (Boolean Type)

boolean:

• Boyut: Belirli bir boyutu yoktur, ancak JVM tarafından genellikle 1 bit olarak düşünülür.
• Değer Aralığı: Sadece iki olası değer alabilir: true (doğru) veya false (yanlış).
• Kullanım: Koşullu ifadelerde (örneğin if deyimleri) ve mantıksal işlemlerde kullanılır.

boolean isJavaFun = true; 
boolean hasErrors = false;

Non-Primitive Data Types

Non-primitive data types, primitive veri tiplerinden farklı olarak doğrudan bir değer depolamazlar. Bunun yerine, bellekteki bir objeye veya verinin gerçekte bulunduğu konuma bir reference (referans) tutarlar. Bu nedenle, onlara genellikle reference types da denir. Non-primitive data types’ın boyutu sabit değildir ve programın çalışması sırasında değişebilir.

Get Mehmet Reşit Çağan’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

Java’da en yaygın non-primitive veri tipleri şunlardır:

1. String
2. Arrays
3. Classes
4. Interfaces

Non primitive veri tiplerinden bu makalede kısaca bahsedeceğiz.

1. String

String, Java’da metin dizilerini (karakter dizilerini) depolamak için kullanılan en yaygın non-primitive data type’tır. Tekil karakterler için char kullanırken, bir veya daha fazla karakterden oluşan metinler için String kullanırız.

• Tanımlama: String class'ından bir object oluşturularak tanımlanır. Metin değerleri çift tırnak ( " " ) içine alınır.
• Değişmezlik (Immutability): Java’daki String objects’leri immutable (değişmez) yapıdadır. Bu, bir String object oluşturulduktan sonra içeriğinin değiştirilemeyeceği anlamına gelir. Bir String üzerinde bir işlem yaptığınızda (örneğin birleştirme), aslında yeni bir String object oluşturulur.
• Metotlar: String class’ı, metin üzerinde birçok işlem yapmanızı sağlayan zengin bir metot kümesi sunar (örneğin, metin birleştirme, bölme, arama, büyük/küçük harfe dönüştürme vb.).

String greeting = "Merhaba Dünya!"; // Bir String object'i oluşturuldu
String name = "Ayşe";
String message = greeting + " Benim adım " + name + "."; // Yeni bir String oluşturulur


System.out.println(message); // Çıktı: Merhaba Dünya! Benim adım Ayşe.

2. Arrays: Veri Koleksiyonları

Array’ler, aynı data type’taki birden fazla değeri tek bir variable altında depolamak için kullanılır. Tıpkı bir rafın farklı bölmelerine aynı türden nesneleri dizmek gibi düşünebilirsiniz.

• Sabit Boyut: Bir array oluşturulduğunda boyutu belirlenir ve daha sonra değiştirilemez.
• İndeksleme: Array’deki her elemana bir index numarası atanır. Index’ler 0'dan başlar. Örneğin, 5 elemanlı bir array’in index’leri 0'dan 4'e kadardır.
• Syntax: Data type’ından sonra köşeli parantez [] kullanılarak declare edilir.

// Integer türünde 5 elemanlı bir array tanımlama ve başlatma
int[] numbers = {10, 20, 30, 40, 50};

// String türünde bir array tanımlama
String[] fruits = new String[3]; // 3 elemanlı boş bir String array'i oluşturur
// Array elemanlarına değer atama
fruits[0] = "Elma";
fruits[1] = "Muz";
fruits[2] = "Çilek";
// Array elemanlarına erişme
System.out.println(numbers[0]); // Çıktı: 10
System.out.println(fruits[1]);  // Çıktı: Muz
// int value = numbers[5]; // Hata verir! Index out of bounds, çünkü 5. index yok.

3. Class (Sınıf)

Java’nın object-oriented olmasının merkezinde sınıflar ve objeler bulunur. Bir class, kendi tanımladığınız bir data type gibidir. Birden fazla primitive ve/veya non-primitive data type’ı bir araya getirerek daha karmaşık bir yapıyı temsil etmenizi sağlar.

• Class: Bir class, objects oluşturmak için bir blueprint’tir. Bir object’in sahip olabileceği properties (özellikler/veriler) ve behaviors (davranışlar/metotlar) tanımlar.
• Object: Bir class’ın bir instance’ıdır. Bellekte yer kaplayan somut bir varlıktır. Non-primitive data types olarak, object variables aslında bellekteki object’in kendisine bir reference tutar.

Örnek Bir Class:

public class Car {
    String brand;  // String (non-primitive) property
    String model;  // String (non-primitive) property
    int year;      // int (primitive) property

public void startEngine() { // A method (behavior)
        System.out.println(brand + " " + model + " motor çalıştı.");
    }
}

Class’tan Obje Oluşturma ve Kullanma:

// Car class'ından bir object oluşturma
Car myCar = new Car(); // 'myCar' bir Car object'ine reference tutar

// Object'in özelliklerine değer atama
myCar.brand = "Toyota";
myCar.model = "Corolla";
myCar.year = 2020;
// Object'in metotlarını çağırma
myCar.startEngine(); // Çıktı: Toyota Corolla motor çalıştı.
// Başka bir Car object'i
Car yourCar = new Car();
yourCar.brand = "Honda";
yourCar.model = "Civic";
yourCar.year = 2022;
yourCar.startEngine(); // Çıktı: Honda Civic motor çalıştı.

Burada myCar ve yourCar birer non-primitive data type'tır (daha doğrusu Car class'ının reference variables'larıdır) çünkü bellekteki Car objects'lerine işaret ederler.

4. Interface (Arayüz)

Interface, Java’da bir class’ın sahip olması gereken belirli davranışları (metotları) tanımlayan bir soyutlamadır. Kendisi doğrudan bir obje oluşturmazsınız, ancak bir class’ın belirli bir interface’i uygulaması gerektiğinde o interface’i bir data type olarak kullanabilirsiniz. Bu konuyu ayrı bir makalede çok daha detaylı inceleyeceğiz çünkü interface, object-oriented programming’in önemli konularından biridir.

Neden Farklı Veri Tipleri Var?

Farklı veri tipleri olmasının temel nedenleri şunlardır:

• Hafıza Verimliliği: Her verinin ihtiyaç duyduğu kadar hafıza alanı ayırmak, genel sistem performansını artırır. Örneğin, sadece -128 ile 127 arasındaki bir sayıyı tutacaksanız, 1 byte’lık bir byte kullanmak, 8 byte'lık bir long kullanmaktan çok daha verimlidir.
• Veri Bütünlüğü: Her veri tipi, belirli bir türdeki veriyi depolamak için tasarlanmıştır. Bu, yanlış türde bir veriyi depolamaya çalışmaktan kaynaklanan hataları önlemeye yardımcı olur.
• İşlem Uyumluluğu: Her veri tipi üzerinde yapılabilecek belirli işlemler vardır. Örneğin, metin üzerinde aritmetik işlemler yapamazsınız. Veri tipleri, compiler’ın hangi işlemlerin geçerli olduğunu bilmesini sağlar.

Primitive Types vs Wrapper Classes

Primitive Type:

• Temel veri türüdür.
• Hafif, hızlı ve bellek dostudur.
• Metotları yoktur.
• null olamaz.

int sayi = 10;

Wrapper Class:

• Primitive türlerin nesne (object) karşılıklarıdır.
• Java’daki Object tabanlı yapılarda kullanılabilir (örneğin: ArrayList, HashMap, vb.).
• Metotlara sahiptir.
• null olabilir.
• Otomatik dönüştürme (autoboxing/unboxing) desteklenir.

Integer sayi = 10; // autoboxing
int x = sayi;      // unboxing

Sonuç: Veri Yönetiminde Doğru Seçimler

Primitive ve non-primitive veri tipleri arasındaki farkları anlamak, Java’da verimli ve hatasız kod yazmanın temelidir. Ne tür bir veriyle çalıştığınıza ve o veriyi nasıl kullanacağınıza bağlı olarak doğru veri tipini seçmek, programınızın performansını ve okunabilirliğini doğrudan etkiler.