Java Dilinde İfadeler ve İşlem Operatörleri
Java Dilinde İfadeler ve İşlem Operatörleri
Yazdığınız program bir veri üzerinde işlem görecekse, öncelikle o verilerin tanımlanması gerekir. Bu tanımlanma bilgisayarın o verileri nasıl ve hangi şekilde kullanacağının önceden belirlenmesi olarak da nitelendirilebilir. Java dilinde kullanılacak ifadeler ve işlem operatörleri de bu başlıkta anlatılmıştır.
Sabitlerden Oluşan İfadeler
Sabitler; değişkenler gibi veri tutan sınıf öğeleridir. Ancak C dilinde olduğu gibi sabit öğe kavramı da yoktur. Java'da sabitler bir değişken bildirimi yaparak hareket ederler. Sabitlere atanan değerler değiştirilemez ve sabit bildirimi yapıldığı anda değeri atanmalıdır.
Sabitlerden (constants) oluşan ifadeler, sadece sabit ve operatör içerirler. Örneğin;
17 + 2
3
'b' – 200 / 3
3
'b' – 200 / 3
Burada ilk ifadenin sonucu 19 sabitidir. İkinci ifade zaten sadece 3 sabitinden oluşuyor. Üçüncü ifadenin sonucu ise, b karakterinin ASCII kodu 98 olduğu için:
98–200/3
şeklinde hesaplanacaktır. Önce bölme yapılacağı için 200/3’ün sonucunu 66 olarak buluruz; çünkü iki tam sayı arasındaki işlemin sonucu daima bir tam sayıdır. Bu durumda sonuç;
'b'–200/3=98-66=32
olarak hesaplanacaktır.
Bu sonucu elde eden ve yazdıran Java programını Eclipse IDE'si üzerinden deneyebilirsiniz.
Bu sonucu elde eden ve yazdıran Java programını Eclipse IDE'si üzerinden deneyebilirsiniz.
int Türü İfadeler
int türünde tamsayı sabit ya da değişken içeren ifadeler, sonuçta tamsayı (int) değer üretecektir.
Bir örnek üzerinden int tipinde değişkenler ile işlemler yapalım. Örneğin; elimizde int tipinde a,b,c adında üç değişkenimiz olsun. Biz bu değişkenlere sırasıyla 9,12,13 değerlerini atayalım.
Bir örnek üzerinden int tipinde değişkenler ile işlemler yapalım. Örneğin; elimizde int tipinde a,b,c adında üç değişkenimiz olsun. Biz bu değişkenlere sırasıyla 9,12,13 değerlerini atayalım.
int a,b,c;
a=9;
b=12;
c=13;
Şimdi de bu değişkenler üzerinden
a + b / c ifadesinin sonucunu hesaplayalım.
Bu ifade matematiksel olarak bize
9+12/13=9+0=9
sonucunu verecektir.
Şimdi bu hesaplamaları yapan Java kodumuzu yazalım.
public class Hesapla {
public static void main(String[] args) {
int a, b, c;
a = 9;
b = 12;
c = 13;
System.out.println("a=" + a);
System.out.println("b=" + b);
System.out.println("c=" + c);
System.out.println("a + b / c=" + (a + b / c));
}
}
Programın çıktısı ise şöyle:
float Türündeki İfadeler
Programlamada özellikle hesaplama aşamasındayken, sadece tamsayılar üzerinden gitmek sizi sınırlayabilir. Rasyonel sayıları kullanmak istediğinizde, yeni değişken türlerini de kullanmalısınız. Java dilinde float ve double türündeki değişkenler ile rasyonel sayıları tutabilirsiniz.
Float ve double türünden değişkenlerin adını kayan noktalı (floating point) değişkenler olarak da duyabilirsiniz. Buradaki nokta kısmı, tam sayı kısmı ile ondalıklı sayı kısmını bölen virgül oluyor. Float ve double türlerinin arasındaki fark, virgülden sonraki ondalık kısımda tutabildikleri hane sayısıdır. Bu yüzden bir float değişken sanal bellekte 32 bitlik yer tutarken, double türündeki bir değişken 64 bit yer tutacaktır.
Kayan noktalı bir tip yerine tamsayı tipini kullandığınızda olacakları daha iyi anlamak için aşağıdaki örneği inceleyiniz:
public class FloatDeneme1 {
public static void main(String[] args) {
int sinav1=50;
int sinav2=55;
int ortalama_yaklasik =(sinav1+sinav2)/2;
float ortalama_tam =(float) (sinav1+sinav2)/2;
System.out.println("Sinav ort. (yaklasik): "+ortalama_yaklasik);
System.out.println("Sinav ort. (tam olrk): "+ortalama_tam);
}
}
Bu programın çıktısı şu şekilde olacaktır:
Gördüğünüz gibi int tipindeki ortalama_yaklasik değişkenin 52,5 çıkan sonucu, tamsayı tipinde olduğu için 52'ye yuvarladı. float tipindeki ortalama_tam değişkeni ise olması gerektiği gibi 52,5 olarak kaldı.
NOT: float ortalama = (float) (sinav1+sinav2)/2; satırındaki (float) ifadesi ile "(sinav1+sinav2)/2" işleminden gelen sonucun float olarak tutulmasını sağlıyoruz.
Gördüğünüz gibi kayan noktalı değişkenleri tanımlarken bazı ifadelere dikkat etmek gerekiyor.
Şimdi de float ile double türlerinin hassasiyetleri üzerine bir örneğe göz atalım:
public class FloatDeneme2 {
public static void main(String[] args) {
//Math.PI, bize PI sayısını döndürür
float PI_float =(float) Math.PI;
double PI_double=Math.PI;
System.out.println("PI sayisi: "+PI_float);
System.out.println("PI sayisi: "+PI_double);
}
}
Çıktısı şöyle olacaktır:
NOT: Math.PI ifadesi, PI sayısını tutan bir ifadedir.
Gördüğünüz üzere double türündeki PI_double değişkeni, PI sayısına ilişkin daha fazla ondalık değeri tutabiliyor. Bu yüzden double değişkenler, daha hassas hesaplama gereken yerlerde kullanılır.
Tekli Operatörler
Bu bölümde negatifini alma (–), pozitifini alma (+), artım (++) ve azaltım (––) operatörlerini inceleyeceğiz. Negatifini alma operatörü (–) tek bir operand üzerinde etkili olduğu için, iki operand ile işleme giren (––) sembolü ile karıştırılmamalıdır.
ÖRNEK:
public class Uyg5 {
public static void main(String[] args){
int x, y=-5;
x=16- -y;
System.out.println("x="+x);
}
}
Bu programda x’in değeri 11 olarak bulunacaktır. –y – (–5)= +5 olarak hesaplanır. 16’yı izleyen çıkarma operatörü (–) ile y’nin önündeki negatifini alma (–) operatörü arasında mutlaka bir boşluk olmalıdır. Aksi halde (–) ifadesi azaltım operatörü olarak algılanacaktır.
operatör
|
sembolü
|
kullanlışı
|
işlem sonucu
|
|---|---|---|---|
| tekli negatif alma | – | –a | a’nın negatifini alır |
| son artım | ++ | a++ |
önce a’nın değerini al, kullan, sonra 1
artır.
|
| ön artım | ++ | ++a | önce a’nın değerini 1 artır, sonra kullan. |
| son azaltım | –– | a–– | önce a’nın değerini al, kullan, sonra 1
son azaltım azalt.
|
| ön azaltım | –– | ––a | önce a’nın değerini 1 azalt, sonra kullan. |
Son artım ve son azaltım operatörlerinde derleyici, değişkenin o andaki değerini bellekte geçici bir değişkene atayarak saklar. Sonra değişkenin değerini 1 artırır (son artım) veya 1 azaltır (son azaltım). Geçici değişkendeki değer ise ifade içinde kullanılır.
ÖRNEK PROJE:
public class Uyg6 {
public static void main(String[] args){
int x=4, y=8, z;
z= x++ + y--;
System.out.println("z="+z);
System.out.println("x="+x);
System.out.println("y="+y);
}
}
PROJENİN ÇIKTISI:
AÇIKLAMA:
Önce x ve y’nin o andaki değerleri geçici bellek alanlarına atanmış (4 ve 8), bu değerlerle ifade hesaplanmış (z=12) sonra x’in değeri 1 arttırılmış ve y’nin değeri 1 azaltılmıştır. İfadeyi z= x+++y--; şeklinde boşluksuz yazsak da sonuç değişmezdi. Derleyici bu durumda +++’nın mevcut operatörler içinde mümkün olan en uzununu (++) alır ve ifadeyi şu şekilde yorumlardı:
z=(x++) + y–– ;
Aynı ifadeyi z=x+++ veya y––- şeklinde yazsak da aynı sonucu elde ederdik. Ön artım ve ön azaltım operatörleri kullanıldığında ise, önce artım (mevcut değere 1 ekleme) veya azaltım (mevcut değerden 1 çıkarma) gerçekleşecek, sonra ifade hesaplanacaktır.
ÖRNEK UYGULAMA:
public class Uyg7 {
public static void main(String[] args){
int x, y, z, m;
x=10;
y=5;
z=16;
m=++x - --y + z++;
System.out.println("z="+z);
System.out.println("x="+x);
System.out.println("y="+y);
System.out.println("m="+m);
}
}
UYGULAMANIN ÇIKTISI:
ARTIM VE AZALIM OPERATÖRLERİ İÇİN BİR DİĞER ÖRNEK UYGULAMA
public class Uyg8 {
public static void main(String[] args){
int m, n, p, q;
m=4;
n=2;
p=10;
q=8;
m= -m++;
n= n--;
p= --p;
q= -++q;
System.out.println("m="+m);
System.out.println("n="+n);
System.out.println("p="+p);
System.out.println("q="+q);
}
}
UYGULAMANIN ÇIKTISI
İkili Aritmetiksel Operatörler
Aritmetik Operatörler için bilmemiz gereken en önemli kural operatörlerin öncelik sırasıdır. İşlemlerimiz bu öncelik sırasına göre yapılmaktadır.
| Operatör | Sembolü | Kullanılışı | İşlem Sonucu |
|---|---|---|---|
| çarpma | * | a*b | a ile b’nin çarpımı |
| bölme | / | a/b | a’nın b’ye bölümü |
| kalan | % | a%b | a’nın b’ye bölümünden kalan |
| toplama | + | a+b | a’nın b ile toplanması |
| çıkarma | – | a-b | b’nin a’dan çıkarılması |
*, / ve % operatörleri, + ve –'ye göre önceliklidir.
*, /, + ve – operatörlerinin int veya float (double) türde operand kabul etmelerine karşılık kalan operandları sadece int türde operand olarak kabul eder. % operandı bölmede kalanı hesaplar.
Örnek:
17 % 3 işleminin sonucunda 2 değeri (17’nin 3 ile bölümünden kalan) elde edilir. ANSI standardı, kalan ve bölme operatörleri arasında aşağıdaki bağıntının bulunmasını zorunlu kılar:
a = a % b + (a /b) *b (a ve b tamsayı)
ÖRNEK UYGULAMA:
public class Uyg9 {
public static void main(String[] args){
int a, b, c;
double p, q, r, x, y, z, k;
a=7; b=4; c=15;
p=2.7;
q=13.8;
r=12.45;
x= a % b * 15 - c / b * a;
y= a * 2 % (b + 1) - c / (a +b);
z=x / y * a - b ++ * --c;
k=p -q / (r +z) * (q -r) + b++ * z;
System.out.println("x="+x);
System.out.println("y="+y);
System.out.println("z="+z);
System.out.println("k="+k);
}
}
ÖRNEK UYGULAMANIN ÇIKTISI:
x değeri
7 % 4 * 15 – 15 / 4 * 7
3 * 15 – 3 * 7
45 – 21
24
7 % 4 * 15 – 15 / 4 * 7
3 * 15 – 3 * 7
45 – 21
24
y değeri
7 * 2 % (4 + 1 ) – 15 / (7 + 4)
14 % 5 – 15 / 11
4 – 1
3
z değeri
24 / 3 * 7 – 4++ * 15 ,
8 * 7 – 4 * 14
56 – 56
0
olarak hesaplanır.
k’nın değerini siz kontrol edebilirsiniz.
Aritmetiksel Atama Operatörleri
| Operatör | Sembolü | Kullanılışı | İşlem Sonucu |
|---|---|---|---|
| Atama | = | x = y | y’nin değerini x’e ata |
| Topla-ata | + = | x + = y | x + y’nin değerini x’e ata |
| Çıkar-ata | – = | x – = y | x – y’nin değerini x’e ata |
| Çarp-ata | * = | x * = y | x * y’nin değerini x’e ata |
| Böl-ata | / = | x / = y | x / y’nin değerini x’e ata |
| Kalanını ata | % = | x % = y | x % y’nin değerini x’e ata |
Tablodan kolayca anlayacağımız üzere, x + = y ifadesi x = x + y ifadesine, x % = y ifadesi de x = x % y ifadesine denktir.
= operatörünün atama amacı ile kullanıldığını biliyoruz. Sembolün sol tarafındaki operand bir sol taraf operandı (left hand operand, Lvalue) olmalıdır.
Sol taraftaki operand (değişken, dizi elemanı, yapı elemanı vb.) sağ taraftaki operandın değerini bellekte saklar.
Sol taraftaki operand (değişken, dizi elemanı, yapı elemanı vb.) sağ taraftaki operandın değerini bellekte saklar.
ÖRNEK:
int k;
double l;
l = k = 13.72;
double l;
l = k = 13.72;
Yukardaki komutlar ile (=) sembolünün birleşme özelliği sağdan sola olduğu için,
( l = (k = 13.72));
sırasıyla atamalar yapılacaktır. Java hassasiyetin kaybolmasına izin vermeyeceği için k=13.72 atamasında,
“possible loss of precision” veya Eclipse'te "cannot convert from double to int"
şeklinde bir hata mesajı verilecektir. Java’da sadece programcının açıkça cast ifadeleri ile,
(int) 13.72
gibi, hassasiyetin kaybolmasına özellikle izin verdiğini belirtmesi halinde bu tür atamalar yapılır.
ATAMA OPERATÖRLERİ: ÖRNEK PROGRAM
public class Uyg10{
public static void main(String[ ] args){
int k;
double l;
l = k =13.72;
System.out.println("l="+l);
System.out.println("k="+k);
}
}
ÖRNEK PROGRAMIN ÇIKTISI
ÖRNEK PROGRAM: CAST İFADESİNİN KULLANIMI
public class Uyg10{
public static void main(String[ ] args){
int k;
double l;
l = k =(int)13.72;
System.out.println("l="+l);
System.out.println("k="+k);
}
}
CAST İFADESİNİ KULLANAN ÖRNEK PROGRAMIN ÇIKTISI:
Tek kelime ile muhteşem ellerinize sağlık
YanıtlaSil