Bölüm 6: Değişkenler, Veri Tipleri ve İşleçler

Bilgisayar ve Programlamaya Giriş

DeğişkenTipDönüşümİşleçGirdi/Çıktı

Sercan KÜLCÜ · Giresun Üniversitesi

Giriş

Öğrenme Çıktıları

Değişken

Değişken bildirmek, ilk değer vermek ve güncellemek.

Tip

İlkel tipleri ve değer aralıklarını seçmek.

İfadeler

Atama, dönüşüm ve işleçleri doğru kullanmak.

Girdi/Çıktı

Scanner ile girdi almak, printf ile biçimli çıktı üretmek.

Veri

Değişkenler

Değişken, belirli tipteki bir değere bellekte ayrılmış adlı bir kutudur.
Bildirim tip ve adı; ilk değer verme başlangıç değerini belirtir.
Tip, kutunun boyutunu ve içine konabilecek değerleri belirler.
Yerel değişken kullanılmadan önce kesin olarak değer almış olmalıdır.

Veri

Temel Tip Grupları

Grup	Örnek	Kullanım
Tam sayı	byte, short, int, long	Sayma ve ayrık değer
Kayan noktalı	float, double	Ölçüm ve yaklaşık hesap
Karakter	char	Tek UTF-16 kod birimi
Mantıksal	boolean	true / false
Referans	String, dizi, sınıf	Nesneye referans

Veri Tipleri

İlkel Veri Tipleri

Tip	Yaklaşık kullanım	Örnek
byte / short	Küçük tam sayılar	byte seviye = 7;
int	Genel tam sayı	int adet = 42;
long	Büyük tam sayı	long nufus = 8_000_000L;
float	Kayan noktalı, düşük hassasiyet	float oran = 1.5F;
double	Genel kayan noktalı sayı	double fiyat = 19.90;
char / boolean	Karakter ve mantık	char not='A';

Veri Tipleri

Tip Boyutları (bit)

Vurgulu: varsayılan seçimler (int, double). 1 bayt = 8 bit; boyutlar her platformda aynıdır.

Veri Tipleri

Tam Sayı Tipi Seçimi

int çoğu tam sayı hesabı için varsayılan seçimdir; long sabitleri L sonekiyle yazılır.
Aralığı aşan tam sayı işlemi taşar: Java hata vermez, değer sessizce öbür uca sarar.
Integer.MAX_VALUE + 1 → -2147483648.
Büyük değerler bekleniyorsa baştan long seçilir.

Veri · Kodu adım adım çalıştır

Taşma: `Integer.MAX_VALUE + 1`

Integer.MAX_VALUE: işaret biti 0, diğer 31 bitin hepsi 1. int için ulaşılabilecek en büyük sayı.

x++ ile 1 eklenir: bitler taşar ve işaret biti 1 olur. Sonuç hata değil, −2147483648: sayı çember gibi başa sarar.

byte 8 bitliktir: en büyük değeri 127 (0111 1111).

b++ ile 127 + 1: bitler 1000 0000 olur → −128. Aynı sarma, sadece daha küçük kutuda.

Çıktı: -2147483648 -128. İki değişken de en büyük değerden en küçüğe sardı.

Taşma ne derleme hatası ne de çalışma zamanı hatasıdır. Taşma istenmiyorsa Math.addExact gibi metotlar istisna fırlatır.

int x = Integer.MAX_VALUE;
x++;
byte b = 127;
b++;
System.out.println(x + " " + b);

Veri

Sınır Sabitleri ve Math.addExact

Sabit	Değer
`Integer.MIN_VALUE`	`-2147483648`
`Integer.MAX_VALUE`	`2147483647`
`Long.MIN_VALUE`	`-9223372036854775808`
`Long.MAX_VALUE`	`9223372036854775807`

int x = Integer.MAX_VALUE;
System.out.println(x + 1);
// -2147483648 (sessiz taşma)
System.out.println(
    Math.addExact(x, 1));
// ArithmeticException:
// integer overflow

Sabitler elle yazılmaz: Integer.MAX_VALUE hem okunaklıdır hem hatasızdır.
Math.addExact taşmayı yakalar: int için integer overflow, long için long overflow iletisiyle istisna fırlatır.
Math.abs(Integer.MIN_VALUE) de taşar ve yine -2147483648 verir.

Veri Tipleri

Kayan Noktalı Sayılar

double çoğu yaklaşık hesap için varsayılan tiptir; float sabiti F soneki ister.
İkili kayan nokta bazı ondalık değerleri (0.1 gibi) tam temsil edemez.
Para gibi kesin ondalık hesaplarda uygun sınıf (BigDecimal) ve yuvarlama kuralı seçilmelidir.

Veri Tipleri · Kodu adım adım çalıştır

Kayan Noktalı Sayı Karşılaştırma

0.1 ve 0.2 ikili tabanda tam gösterilemez; toplam 0.3 değil, ona çok yakın bir değerdir.

Yazdırınca küçük hata görünür: 0.30000000000000004.

a == 0.3 → false. Aynı sonuç 0.1 + 0.2 == 0.3 için de geçerlidir. Kayan noktalı sayılar == ile karşılaştırılmaz.

Fark yaklaşık 5.55E-17 olduğu için Math.abs(a - 0.3) < 1e-9 → true. Fark küçük bir eşikle (epsilon) sınanır.

double a = 0.1 + 0.2;
System.out.println(a);
System.out.println(a == 0.3);
System.out.println(Math.abs(a - 0.3) < 1e-9);

Veri Tipleri

char ve boolean

char tek tırnakla yazılır; bir UTF-16 kod birimini (sayı olarak) saklar: 'A' = 65.
String çift tırnakla yazılan bir nesnedir; değişken nesneye referans tutar. char ile aynı tip değildir.
boolean yalnızca true veya false değerini alır; 0/1 ile yer değiştirmez.

Veri · Kodu adım adım çalıştır

char Aritmetiği: Harfler Sayıdır

c = 'A'. char aslında bir sayıdır: 'A' için Unicode kod noktası 65.

c++ kod noktasını 1 artırır: 65 → 66, yani c = 'B'. Tip hâlâ char.

c + 1 ifadesi int olur (66 + 1 = 67). k bir int olduğundan 67 sayısını tutar, harf değil.

Sonucu harf olarak saklamak için (char) dönüşümü gerekir: d = 'C'. Dönüşüm olmazsa char d = c + 1; derlenmez.

Çıktı: B 67 C. char yazdırılırken harf, int yazdırılırken sayı görünür.

char c = 'A';
c++;
int k = c + 1;
char d = (char)(c + 1);
System.out.println(c + " " + k + " " + d);

Değişkenler

Tanımlayıcı Kuralları

Kural	Geçerli	Geçersiz
Harf, _ veya $ ile başlar	ogrenci1	1ogrenci
Boşluk içermez	toplamPuan	toplam puan
Anahtar sözcük değildir	sinifNo	class
Tek alt çizgi ad olamaz	_deger	_
Büyük-küçük harfe duyarlı	puan ve Puan	Aynı değişken sanmak

Değişkenler

Adlandırma

Değişken ve metot adlarında lowerCamelCase kullanılır.
Sınıf adları UpperCamelCase biçimindedir.
Sabitler genellikle BÜYÜK_HARF_VE_ALT_ÇİZGİ ile adlandırılır.
Ad, değerin rolünü açıklamalıdır: x yerine toplamPuan.

Değişkenler

Bildirim ve İlk Değer

int yas;          // bildirim
yas = 20;        // atama
double ortalama = 82.5; // birlikte
final int MAKSIMUM = 100; // sabit

Yerel değişken okunmadan önce değer almalıdır.
final değişkene yalnızca bir kez atama yapılır.

Değişkenler · Kodu adım adım çalıştır

Değişkenler Bellekte Adım Adım

Bildirim: int tipinde yas kutusu ayrılır ama değeri yok. Bu hâliyle okunursa derleyici hata verir.

İlk atama: sağdaki 20 değeri yas kutusuna yazılır.

Önce sağ taraf hesaplanır: yas + 1 → 20 + 1 → 21. Kutu henüz değişmedi.

Sonuç aynı kutuya yazılır: eski 20 silinir, yas = 21.

double tipinde ortalama bildirilir ve aynı deyimde 82.5 atanır.

ortalama += 5, ortalama = ortalama + 5 demektir: 82.5 + 5 → 87.5.

Kutu güncellenir: ortalama = 87.5.

final sabit: 100 bir kez atanır. MAKSIMUM = 200; yazılsaydı derleme hatası olurdu.

yas kutusu okunur ve 21 yazdırılır. Okuma değeri değiştirmez.

ortalama okunur: 87.5. Son durum: 3 kutu, 2 satır çıktı.

int yas;                  // bildirim
yas = 20;                 // ilk atama
yas = yas + 1;            // güncelleme
double ortalama = 82.5;   // bildirim + ilk değer
ortalama += 5;            // bileşik atama
final int MAKSIMUM = 100; // sabit
System.out.println(yas);
System.out.println(ortalama);

Veri

Atama ve Güncelleme

Atama işleci = önce sağ tarafı hesaplar, sonra değeri soldaki değişkene yazar.
Yeni değer değişkenin tipiyle uyumlu olmalıdır.
Bileşik atama mevcut değeri kullanarak günceller: toplam += fiyat ≡ toplam = toplam + fiyat.

Başlangıç: toplam = 50, fiyat = 20.

Önce iki kutu okunur ve sağ taraf hesaplanır.

Sonuç soldaki kutuya yazılır: toplam = 70. fiyat değişmez.

Dönüşüm

Atama Uyumluluğu

Dar tipten geniş tipe dönüşüm (genişletme) otomatik yapılır: double d = 7;
Daraltma bilgi kaybı riski taşıdığı için açık dönüşüm (cast) ister.
Dönüşüm kaynak değişkeni değiştirmez; yalnızca üretilen sonucu etkiler.

Dönüşüm

Tip Dönüşümü

int adet = 7;
double genis = adet;       // 7.0
double oran = 9.8;
int dar = (int) oran;      // 9
int bolum = 5 / 2;         // 2
double dogru = 5.0 / 2;    // 2.5

double değerini int'e çevirmek kesir bölümünü atar.
İşlemden sonra yapılan dönüşüm kaybolan kesri geri getirmez.

Dönüşüm · Kodu adım adım çalıştır

Tip Dönüşümü Adım Adım

adet: int kutusu (32 bit), değer 7.

Genişletme: int değer double kutuya otomatik dönüşür: 7 → 7.0. Bilgi kaybı yok.

oran: double kutusu (64 bit), değer 9.8.

Daraltma: (int) açıkça yazılmalı. Kesir atılır (yuvarlanmaz): 9.8 → 9. oran hâlâ 9.8.

5 ve 2 ikisi de int → tam sayı bölmesi: 5 / 2 = 2, kalan atılır.

5.0 double olduğu için 2 de 2.0'a genişler: 5.0 / 2.0 = 2.5.

int adet = 7;
double genis = adet;       // 7.0
double oran = 9.8;
int dar = (int) oran;      // 9
int bolum = 5 / 2;         // 2
double dogru = 5.0 / 2;    // 2.5

Dönüşüm

Dönüşümlerde Taşma ve Kesme

İfade	Sonuç	Neden
`(byte) 200`	`-56`	sadece alt 8 bit kalır: 200 - 256
`(int) 3000000000L`	`-1294967296`	long → int: üst bitler atılır
`(int) 3.9`	`3`	ondalık kısım kesilir, yuvarlanmaz
`(int) -2.7`	`-2`	sıfıra doğru kesilir
`(int) 3.9e10`	`2147483647`	double → int: int sınırında sıkışır
`Math.round(3.9)`	`4`	en yakın tam sayı (long döner)
`Math.round(-2.7)`	`-3`	en yakın tam sayı
`Math.round(3.9e10)`	`39000000000`	long olduğu için sığar

Yuvarlamak için Math.round, int istiyorsan (int) Math.round(x). Daraltma dönüşümü hata vermez; veri sessizce kaybolur.

Dönüşüm · Kodu adım adım çalıştır

`5 / 2` ile `5.0 / 2`

İki işlenen de int → tam sayı bölmesi: bölüm alınır, kesir atılır.

Sonuç 2 (int) yazdırılır.

Bir işlenen double → diğeri de double'a yükseltilir (2 → 2.0). Kayan noktalı bölme yapılır.

Sonuç 2.5 (double) yazdırılır.

Bir işlenen double → diğeri de double'a yükseltilir (5 → 5.0). Kayan noktalı bölme yapılır.

Sonuç 2.5 (double) yazdırılır.

Tip dönüşümü /'dan önce gelir: (double) 5 → 5.0.

Bir işlenen double → diğeri de double'a yükseltilir (2 → 2.0). Kayan noktalı bölme yapılır.

Sonuç 2.5 (double) yazdırılır.

Parantez içi önce: 5 / 2, ikisi de int → tam sayı bölmesi = 2. Kesir burada kaybolur.

Sonra (double) 2 → 2.0. Kaybolan .5 geri gelmez.

2.0 yazdırılır: işlemden sonra yapılan dönüşüm kesri kurtarmaz.

İki işlenen de int → kalan: 5 = 2·2 + 1.

Sonuç 1 (int) yazdırılır.

System.out.println(5 / 2);
System.out.println(5.0 / 2);
System.out.println(5 / 2.0);
System.out.println((double) 5 / 2);
System.out.println((double) (5 / 2));
System.out.println(5 % 2);

Dönüşüm

Tip Yükseltme Sırası

Karma ifadede küçük tip, büyük tipe otomatik yükselir: int + double → double.
byte, short, char işlemde önce int olur; bu yüzden b + 1 bir int'tir.
Okun tersi (daraltma) için açık (tür) dönüşümü gerekir.

İşleçler

Aritmetik İşleçler

İşleç	Anlam	Örnek
+ -	Toplama / çıkarma	a + b
* /	Çarpma / bölme	a * b
%	Kalan	sayi % 2
++ --	Bir artır / azalt	i++
+= -=	Bileşik atama	toplam += değer

İşleçler

Sıfıra Bölme ve Özel Değerler

İfade	Sonuç	Açıklama
`1 / 0`	`ArithmeticException: / by zero`	tam sayı bölmesinde sıfıra bölme çalışma zamanı hatasıdır
`1.0 / 0`	`Infinity`	ondalıkta hata yok: sonsuz
`-1.0 / 0`	`-Infinity`	eksi sonsuz
`0.0 / 0`	`NaN`	Not a Number: tanımsız sonuç
`NaN == NaN`	`false`	NaN kendine bile eşit değildir
`NaN != NaN`	`true`	NaN kontrolü için `Double.isNaN(x)`
`-7 % 3`	`-1`	kalanın işareti bölünenin işaretidir
`5.5 % 2`	`1.5`	% kayan noktalı sayılarda da çalışır

Tam sayıda 1 / 0 programı durdurur; ondalıkta Infinity ve NaN sessizce üretilir ve sonraki işlemlere taşınır.

İşleçler · Kodu adım adım çalıştır

Artırma ve Azaltma: `i++` ile `++i`

i = 5.

Sonek i++: ifadenin değeri i'nin eski değeridir → a = 5.

Ardından i artırılır: i = 6.

Önek ++i: önce i artırılır → i = 7.

İfadenin değeri yeni değerdir → b = 7.

i-- tek başına bir deyim: önek/sonek farkı önemsiz → i = 6.

Çıktı: 6 5 7. ++ ve -- tek başına bir deyim olarak kullanıldığında kod daha kolay okunur.

int i = 5;
int a = i++;   // önce kullan, sonra artır
int b = ++i;   // önce artır, sonra kullan
i--;
System.out.println(i + " " + a + " " + b);

İşleçler · Kodu adım adım çalıştır

Bileşik Atama Örtük Dönüşüm Yapar

b = 10: 8 bitlik byte kutusu.

b += 5 derleyicide b = (byte)(b + 5) olur: toplama int ile yapılır, sonuç otomatik byte'a daraltılır → b = 15.

i = 5 (int).

i += 3.7 de örtük bir dönüşüm yapar: 8.7 hesaplanır, (int) ile kesir atılır → i = 8 (yuvarlama yok).

Bileşik atama olmadan b = b + 5; derlenmez: b + 5 int olur ve int → byte dönüşümü örtük yapılmaz. Bu satır yorum olarak duruyor.

Çıktı: 15 8.

byte b = 10;
b += 5;
int i = 5;
i += 3.7;
// b = b + 5;   // derlenmez: int → byte
System.out.println(b + " " + i);

İşleçler

Karşılaştırma ve Mantık

İşleç	Anlam	Örnek
`== !=`	Eşit / farklı	`a == b`
`< <= > >=`	Sıra karşılaştırması	`not >= 60`
`&&`	İki koşul da doğru	`yas >= 18 && belgeVar`
`\|\|`	En az biri doğru	`haftaSonu \|\| tatil`
`!`	Mantıksal değil	`!aktif`

p	q	p && q	p \|\| q
false	false	false	false
false	true	false	true
true	false	false	true
true	true	true	true

Karşılaştırma işleçlerinin sonucu her zaman boolean'dır.

İşleçler

İşleç Önceliği

Parantez içi önce değerlendirilir; tekli ! ve tip dönüşümü de önce gelir.
Çarpma, bölme ve kalan; toplama ve çıkarmadan önce gelir.
Karşılaştırmalar aritmetikten, && / || karşılaştırmadan sonra değerlendirilir.
Aynı düzeyde soldan sağa gidilir (atama hariç). Parantez niyeti görünür kılar.

İşleçler · Adım adım

İfade Ağacı: `2 + 3 * 4 > 10 && 7 % 2 == 1`

Derleyici ifadeyi önceliğe göre bir ağaca dönüştürür: en alttaki işlem en önce, kök (&&) en son hesaplanır.

*, +'dan önce gelir: 3 * 4 = 12.

sonra toplama: 2 + 12 = 14.

Karşılaştırma: 14 > 10 → true (boolean). Sol taraf true: && sağ tarafa geçer.

sağ tarafta önce kalan: 7 % 2 = 1.

Karşılaştırma: 1 == 1 → true (boolean).

Kök: true && true → true. Sol taraf true olduğu için sağ taraf da hesaplanmak zorundaydı.

İşleçler · Kodu adım adım çalıştır

Karma İfade: `a / b * 2.0 + a % b`

a = 7, b = 2 (int).

/, *, % aynı öncelikte ve soldan sağa işlenir; + hepsinden sonra gelir.

İlk: a / b iki int olduğundan tam sayı bölmesi: 7 / 2 = 3 (0.5 kesri atılır).

Sonra 3 * 2.0: 3, double'a yükselir → 6.0.

+'nın sağ tarafı: 7 % 2 = 1 (kalan).

Son: 6.0 + 1: int, double'a yükselir → 7.0; r = 7.0 (double).

Çıktı: 7.0. Tam sayı bölmesi yüzünden 3 × 2.0 = 6.0 çıktı; a / 2.0 olsaydı 3.5 × 2.0 + 1 = 8.0 olurdu. Sıra ve tipler sonucu belirler.

int a = 7, b = 2;
double r = a / b * 2.0 + a % b;
System.out.println(r);

İşleçler

Kısa Devre Değerlendirme

int a = 10, b = 0;
if (b != 0 && a / b > 2) {
    System.out.println("Oran büyük");
}

&& ilk koşul false ise ikinci koşulu çalıştırmaz: sonuç zaten false.
b = 0 iken a / b çalışsaydı ArithmeticException (sıfıra bölme) oluşurdu; kısa devre bunu önler.
|| ilk koşul true ise ikincisine bakmaz. Bu yüzden koşulların sırası önemlidir.

İşleçler · Kodu adım adım çalıştır

Kısa Devre Adım Adım: b = 0 ve b = 2

a = 10, b = 0.

Sol koşul: b != 0 → 0 != 0 → false.

Kısa devre: false && (herhangi) → false. Sağ taraf hiç çalışmaz; a / b yapılmadığı için sıfıra bölme hatası da olmaz.

Koşul false → blok atlanır, hiçbir şey yazılmaz.

b = 2 yapılır ve aynı if yeniden denenir.

Sol koşul: 2 != 0 → true. Sonuç henüz belli değil, sağ taraf da hesaplanmalı.

Sağ koşul: a / b → 10 / 2 = 5; 5 > 2 → true. true && true → true.

Bloğa girilir: Oran büyük. Koşullar ters yazılsaydı (a / b > 2 && b != 0) b = 0 iken program çökerdi.

int a = 10, b = 0;
if (b != 0 && a / b > 2) {
    System.out.println("Oran büyük");
}
b = 2;
if (b != 0 && a / b > 2) {
    System.out.println("Oran büyük");
}

Veri

Tipler Farklı Davranır

System.out.println(2 + 3);       // 5
System.out.println("2" + "3");   // 23
System.out.println("Sonuç: " + 2 + 3); // Sonuç: 23
System.out.println("Sonuç: " + (2 + 3)); // Sonuç: 5

İşleç davranışı işlenen tiplerine bağlıdır.
Parantez değerlendirme sırasını açıklaştırır.

Veri · Kodu adım adım çalıştır

`"Sonuç: " + 2 + 3` Adım Adım

2 + 3: iki int → sayısal toplama.

Çıktı: 5.

"2" + "3": işlenenlerden biri String → birleştirme: 3 metne eklenir.

Çıktı: 23.

"Sonuç: " + 2: işlenenlerden biri String → birleştirme: 2 metne eklenir. + soldan sağa değerlendirilir: önce ilk ikisi.

"Sonuç: 2" + 3: işlenenlerden biri String → birleştirme: 3 metne eklenir.

Çıktı: Sonuç: 23. 3 de metne eklendi; 2 + 3 hiç toplanmadı.

Parantez önce: 2 + 3, iki int → toplama = 5.

Sonra "Sonuç: " + 5 → String varsa birleştirme → "Sonuç: 5".

Çıktı: Sonuç: 5. Parantez, toplamanın önce yapılmasını sağladı.

System.out.println(2 + 3);
System.out.println("2" + "3");
System.out.println("Sonuç: " + 2 + 3);
System.out.println("Sonuç: " + (2 + 3));

Girdi

Scanner ile Girdi

Scanner klavye = new Scanner(System.in);
System.out.print("Yaş: ");
int yas = klavye.nextInt();
klavye.nextLine(); // satır sonunu tüket
System.out.print("Ad: ");
String ad = klavye.nextLine();

Dosyanın başında import java.util.Scanner; gerekir.
nextInt sayıyı, nextLine tüm satırı okur.
Farklı okuma metotları birlikte kullanılırken kalan satır sonuna dikkat edilir.

Girdi · Kodu adım adım çalıştır

Scanner Girdi Akışı Adım Adım

Scanner nesnesi klavyeye (System.in) bağlanır. Tampon boş.

print istemi yazar; satır sonu yok, imleç "Yaş: " arkasında.

nextInt() tampon boş olduğu için bekler. Kullanıcı 20 yazıp Enter'a basar: tampona "20⏎" girer.

nextInt yalnızca sayıyı (20) okur; ⏎ tamponda kalır.

nextLine() ⏎'e kadar okur: boş dizgi ("") döner ve ⏎ tüketilir. Tampon temizlendi.

İstem "Ad: " yazılır.

nextLine tampon boş olduğu için bekler; kullanıcı Ada Yılmaz yazar ve Enter'a basar.

nextLine tüm satırı (boşluk dahil) okur: ad = "Ada Yılmaz". ⏎ tüketilir, satıra dahil edilmez.

Scanner klavye = new Scanner(System.in);
System.out.print("Yaş: ");
int yas = klavye.nextInt();
klavye.nextLine(); // satır sonunu tüket
System.out.print("Ad: ");
String ad = klavye.nextLine();

Girdi · Kodu adım adım çalıştır

Satır Sonu Tüketilmezse

Scanner nesnesi klavyeye (System.in) bağlanır. Tampon boş.

print istemi yazar; satır sonu yok, imleç "Yaş: " arkasında.

nextInt() tampon boş olduğu için bekler. Kullanıcı 20 yazıp Enter'a basar: tampona "20⏎" girer.

nextInt yalnızca sayıyı (20) okur; ⏎ tamponda kalır.

İstem "Ad: " yazılır.

Tamponda hâlâ ⏎ var: nextLine beklemeden boş dizgi döner. ad = "". Kullanıcıya ad sorulamadı!

Çıktı []: ad boş. Çözüm: nextInt'ten sonra bir klavye.nextLine(); ile ⏎'i tüketmek.

Scanner klavye = new Scanner(System.in);
System.out.print("Yaş: ");
int yas = klavye.nextInt();
System.out.print("Ad: ");
String ad = klavye.nextLine();
System.out.println("[" + ad + "]");

Girdi

Girdi Doğrulama

Kullanıcının her zaman beklenen tipte değer gireceği varsayılmamalıdır.
Aralık ve iş kuralı doğrulaması tip kontrolünden sonra yapılır.
Hata iletisi beklenen biçimi açıkça söylemeli ve yeniden deneme yolu sunmalıdır.

Çıktı

Biçimli Çıktı: `printf`

String ad = "Ada";
double ortalama = 87.456;
System.out.printf("%-10s %6.2f%n", ad, ortalama);

%s dizgi · %d tam sayı · %f kayan noktalı · %n satır sonu. Türkçe yerel ayarda ondalık ayırıcı virgüldür (87,46); derste nokta (Locale.US) kullanılır. Türkçe ayarda nextDouble() “37,5” bekler, “37.5” InputMismatchException verir.

Çıktı · Kodu adım adım çalıştır

printf Biçimini Adım Adım Çözümle

Biçim dizgisi soldan sağa taranır: %... biçim belirteçleri sırayla argümanlarla doldurulur, diğer karakterler olduğu gibi yazılır.

%-8s: dizgi, 8 karakter genişliğinde; - sola yaslar → "Ada " (3 harf + 5 boşluk).

| aynen yazılır. %6.2f: 3.14159 → 2 basamağa yuvarlanır (3.14), 6 karaktere sağa yaslanır (2 boşluk). Türkçe yerel ayarda 3,14 yazılır.

%05d: tam sayı, 5 karakter genişliğinde; 0 bayrağı boşluk yerine sıfır koyar → 00042.

%n satır sonu ekler. Çıktı: Ada | 3.14|00042. Ondalık ayırıcı yerel ayara bağlıdır; nokta için Locale.US verilir.

System.out.printf("%-8s|%6.2f|%05d%n",
                  "Ada", 3.14159, 42);

Örnekler

Math Sınıfı

İfade	Sonuç	Açıklama
`Math.PI`	`3.141592653589793`	π sabiti
`Math.sqrt(16)`	`4.0`	karekök (double)
`Math.pow(2, 10)`	`1024.0`	üs alma (double)
`Math.abs(-7)`	`7`	mutlak değer
`Math.max(3, 8)`	`8`	büyük olan (min: küçük)
`Math.round(2.5)`	`3`	en yakın tam sayı (long)
`Math.round(-2.5)`	`-2`	yarım değer yukarı yuvarlanır

Math, java.lang paketindedir: import gerekmez. sqrt ve pow her zaman double döndürür.

Örnek · Kodu adım adım çalıştır

İki Değişkeni Takas Etme

a = 5, b = 8. Hedef: değerleri takas etmek (a = 8, b = 5).

a = b → a = 8. a'nın eski değeri 5 silindi!

b = a → b = 8. 5 artık hiçbir kutuda yok.

Çıktı 8 8: takas başarısız. Bir değeri korumak için üçüncü bir kutu gerekir.

Değerler yeniden 5 ve 8 yapıldı.

gecici = a → gecici = 5: a'nın değeri güvende.

a = b → a = 8.

b = gecici → b = 5.

Çıktı 8 5: takas tamam. 3 atama ve 1 geçici değişken gerekti.

int a = 5, b = 8;
a = b;                // yanlış deneme
b = a;
System.out.println(a + " " + b);
a = 5; b = 8;         // baştan
int gecici = a;       // doğru yöntem
a = b;
b = gecici;
System.out.println(a + " " + b);

Örnek · Kodu adım adım çalıştır

Celsius → Fahrenheit: 100, 37, −40

1. çalıştırma: kullanıcı 100 girer; nextDouble → c = 100.0.

Soldan sağa: c * 9 = 900.0, / 5 = 180.0, + 32 = 212.0.

printf %.1f ile bir ondalık basamak: 100.0 C = 212.0 F. 9 / 5 * c yazılsaydı 9 / 5 = 1 (tam sayı bölmesi) olurdu!

2. çalıştırma: kullanıcı 37 girer; nextDouble → c = 37.0.

Soldan sağa: c * 9 = 333.0, / 5 = 66.6, + 32 = 98.6.

printf %.1f ile bir ondalık basamak: 37.0 C = 98.6 F.

3. çalıştırma: kullanıcı -40 girer; nextDouble → c = -40.0.

Soldan sağa: c * 9 = -360.0, / 5 = -72.0, + 32 = -40.0.

printf %.1f ile bir ondalık basamak: -40.0 C = -40.0 F. −40 iki ölçekte aynıdır.

Scanner klavye = new Scanner(System.in);
double c = klavye.nextDouble();
double f = c * 9 / 5 + 32;
System.out.printf("%.1f C = %.1f F%n", c, f);

Örnek · Kodu adım adım çalıştır

Daire Alanı ve Çevresi: r = 2.5

Yarıçap r = 2.5.

Alan = π · r · r = 3.14159… · 2.5 · 2.5 = 19.634954084936208. Math.PI hazır sabittir.

Çevre = 2 · π · r = 15.707963267948966.

%.2f iki basamağa yuvarlar: 19.63. Değişkendeki değer değişmez.

Çevre: 15.71 (15.7079… → 15.71).

double r = 2.5;
double alan = Math.PI * r * r;
double cevre = 2 * Math.PI * r;
System.out.printf("Alan: %.2f%n", alan);
System.out.printf("Çevre: %.2f%n", cevre);

Örnek · Kodu adım adım çalıştır

Saniye → saat:dakika:saniye (3725)

toplam = 3725 saniye.

saat = toplam / 3600 → 3725 / 3600 = 1 (tam sayı bölmesi: kaç tane tam saat).

kalan = toplam % 3600 → 3725 % 3600 = 125 (kalan: artan kısım saat).

dakika = kalan / 60 → 125 / 60 = 2 (tam sayı bölmesi: kaç tane tam dakika).

saniye = kalan % 60 → 125 % 60 = 5 (kalan: artan kısım dakika).

%02d: en az 2 hane, boşluk yerine 0 ile doldur → 1:02:05. Sağlama: 1·3600 + 2·60 + 5 = 3725.

int toplam = 3725;
int saat = toplam / 3600;
int kalan = toplam % 3600;
int dakika = kalan / 60;
int saniye = kalan % 60;
System.out.printf("%d:%02d:%02d%n",
                  saat, dakika, saniye);

Hata Ayıklama

Yaygın Hatalar

Hata	Örnek	Ne olur?
= ile == karışır	`if (x = 5)`	Derleme hatası: int, boolean değil
Tam sayı bölmesi	`double o = 7 / 2;`	o = 3.0, 3.5 değil
Kapsam dışı kullanım	`{ int k = 1; } k++;`	k blok dışında tanımsız
Yanlış noktalı virgül	`if (x > 0);`	Boş deyim: koşul hiçbir şeyi kontrol etmez
String ve ==	`s1 == s2`	İçeriği değil, referansı karşılaştırır → `s1.equals(s2)`

Özet

Bölüm Özeti

Değişken, belirli tipteki bir değere anlamlı bir ad verir ve okunmadan önce değer almalıdır.
İlkel tipler farklı değer kümeleri ve bellek gereksinimleri taşır.
Genişletme otomatik yapılır; daraltma açık dönüşüm ister ve bilgi kaybettirebilir.
İşleç önceliği ve işlenen tipleri ifadenin sonucunu doğrudan belirler.
Kullanıcı girdisi hem tip hem iş kuralı açısından doğrulanmalıdır.

Özet

Kontrol Soruları

int ve double bölmesi nasıl farklı sonuç verir?
Daraltıcı dönüşüm neden açıkça yazılır?
"Sonuç: " + 2 + 3 ifadesi neden Sonuç: 23 yazdırır?
&& işleci kısa devreyi nasıl kullanır?
nextInt sonrasında nextLine kullanırken neye dikkat edilir?

Özet

Alıştırmalar

Kenarları klavyeden okunan dikdörtgenin alanını ve çevresini yazdırın.
Kilometreyi mile çevirin (1 mil = 1,609 km); sonucu %.2f ile yazdırın.
Üç notun ortalamasını hesaplayın. (n1 + n2 + n3) / 3 neden hatalı olabilir? Düzeltin.
Dört basamaklı bir sayının basamakları toplamını % ve / ile bulun (1234 → 10).
Kuruş cinsinden bir tutarı lira ve kuruşa ayırın (1575 → 15 lira 75 kuruş).
Takası geçici değişken olmadan a = a + b; b = a - b; a = a - b; ile izleyin. Taşma riski var mı?

Özet

Kaynaklar

Deitel ve Deitel, Java: How to Program, Early Objects, 11. baskı, Pearson, 2018.
Liang, Introduction to Java Programming and Data Structures, 13. baskı, Pearson, 2024.
Oracle, The Java Tutorials: Variables, Operators.
Oracle, Java Language Specification SE 21: Bölüm 4, Types, Values, and Variables; Bölüm 15, Expressions.
Oracle, Java SE 21 API: Scanner, Math.
Sedgewick ve Wayne, Computer Science: An Interdisciplinary Approach, Addison-Wesley, 2016: 1.2 Built-in Types of Data.

Son

Değişkenler, Veri Tipleri ve İşleçler

Sonraki sunum: Koşullu İfadeler · Çalışma soruları · Simülatör: İfade Değerlendirici · Terim sözlüğü

Bölüm 6: Değişkenler, Veri Tipleri ve İşleçler

Öğrenme Çıktıları

Değişkenler

Temel Tip Grupları

İlkel Veri Tipleri

Tip Boyutları (bit)

Tam Sayı Tipi Seçimi

Taşma: Integer.MAX_VALUE + 1

Sınır Sabitleri ve Math.addExact

Kayan Noktalı Sayılar

Kayan Noktalı Sayı Karşılaştırma

char ve boolean

char Aritmetiği: Harfler Sayıdır

Tanımlayıcı Kuralları

Adlandırma

Bildirim ve İlk Değer

Değişkenler Bellekte Adım Adım

Atama ve Güncelleme

Atama Uyumluluğu

Tip Dönüşümü

Tip Dönüşümü Adım Adım

Dönüşümlerde Taşma ve Kesme

5 / 2 ile 5.0 / 2

Tip Yükseltme Sırası

Aritmetik İşleçler

Sıfıra Bölme ve Özel Değerler

Artırma ve Azaltma: i++ ile ++i

Bileşik Atama Örtük Dönüşüm Yapar

Karşılaştırma ve Mantık

İşleç Önceliği

İfade Ağacı: 2 + 3 * 4 > 10 && 7 % 2 == 1

Karma İfade: a / b * 2.0 + a % b

Kısa Devre Değerlendirme

Kısa Devre Adım Adım: b = 0 ve b = 2

Tipler Farklı Davranır

"Sonuç: " + 2 + 3 Adım Adım

Scanner ile Girdi

Scanner Girdi Akışı Adım Adım

Satır Sonu Tüketilmezse

Girdi Doğrulama

Biçimli Çıktı: printf

printf Biçimini Adım Adım Çözümle

Math Sınıfı

İki Değişkeni Takas Etme

Celsius → Fahrenheit: 100, 37, −40

Daire Alanı ve Çevresi: r = 2.5

Saniye → saat:dakika:saniye (3725)

Yaygın Hatalar

Bölüm Özeti

Kontrol Soruları

Alıştırmalar

Kaynaklar

Son

Taşma: `Integer.MAX_VALUE + 1`

`5 / 2` ile `5.0 / 2`

Artırma ve Azaltma: `i++` ile `++i`

İfade Ağacı: `2 + 3 * 4 > 10 && 7 % 2 == 1`

Karma İfade: `a / b * 2.0 + a % b`

`"Sonuç: " + 2 + 3` Adım Adım

Biçimli Çıktı: `printf`