Java Deger Atama ve Oparatörler

Uygulamanın akışını nasıl yönlendirebilirim ?

Javada oluşturulan ilkel tipleri , objeleri yönlendirmek veya değiştirmek için operatörleri kullanırız. Java , bu operatörleri C ve C++ dan miras almışdır ama bu miras üzerine kendiside birçok şey katmıştır.

Atamalar

Değer atamalar sağ tarafdaki değerin -ki bu değer bir sabit değer olabilir veya değişken olabilir , sol tarafdaki değişkene atanması ile gercekleşir . Sağ tarafdaki değişkenin bir fiziksel bir boşluğa sahip olması gerekir .

gösterim-1

int a ; a=4 ; // dogru bir atama 4=a ; // yanlış bir atama

İlkel tiplerde atama

Atama işlemi ilkel (primitive) tipler için basittir . ilkel (primitive) tipler değerleri direk kendileri tuttukları (herhangi bir objeyi referans etmediklerinden) için , bir ilkel tipi diğerine atadığımız zaman değişen sadece içelikler olur .

gösterim-2

int a ; int b ; a=4 ; b=5 ; a=b ;

Sonuc olarak a ve b değişkenlerinin değerleri aşağıdaki gibi olur.

a=5 , b=5

Objelerde atama

Objelerde atamalar biraz daha karmaşıktır.Sonuç olarak objeleri yönetmek için referansları kullanırız ve eğer bir atama işlemi olacaksa bu referansların ayni objeyi göstermesi anlamına gelir.Objelerin birbirleri üzerlerine kopyalanması gibi bişey söz konusu değildir.

ör-obje-atama

class Sayi { int i; } public class ObjelerdeAtama { public static void main(String[] args) { Sayi s1 = new Sayi(); Sayi s2 = new Sayi(); s1.i = 9; s2.i = 47; System.out.println("1: s1.i: " + s1.i +", s2.i: " + s2.i); s1 = s2; // referanslar kopyalaniyor .. objeler değil System.out.println("2: s1.i: " + s1.i +", s2.i: " + s2.i); s1.i = 27; System.out.println("3: s1.i: " + s1.i +", s2.i: " + s2.i); } }

Baştan sırayla açıklıyalım ; ilk önce 2 adet Sayi objesi oluşturduk ve bu objelere Sayi sınıfı türünden 2 adet referans(veya değişken diyin fark etmez) bağlandık , s1 ve s2. Bu referanslar artık 2 ayrı Sayi objesini göstermektedirler.
Daha sonra s1 referansının işaret ettği Sayi objesinin i değişkenine 9 sayısını atadık.Aynı şekilde s2 referansının işeret ettiği Sayi objesinin i değişkenine 47 sayısını atadık.Yaptığımız işlemlerin düzgün olup olmadıklarını görmek için bunları ekrana bastırdığımızda aşağıdaki görüntü ile karşılaşıyoruz.

1: s1.i: 9, s2.i: 47

Şu ana kadar bir sorun olmadığı anlayıp , rahatladıktan sonra önemli hamleyi yapıyoruz .

gösterim-3

s1 = s2 ; // referanslar kopyalaniyor .. objeler değil

Burada gerçekte olan şudur, s1 artık s2 nin işaret etiği objeyi göstermektedir. Aşağıdaki şekil, örneğin anlanmasında yardımcı olabilir. Kısım-1 durumun , s2'nin s1'e atanmadan önceki halini göstermektedir. Kısım-2 ise s2'nin s1'e atandıktan sonraki halini göstermektedir.

şekil -1

Kaldığımız yerden devam edelim , şimdi s1 ve s2 nin değerlerini ekrana bastırdığımızda , s1.i ve s2.i değişkenlerinin aynı değerleri taşıdığını görürüz,

2: s1.i: 47, s2.i: 47

sebebi ise bu iki referansın (s1 ve s2 ) aynı objeyi göstermeleridir. Son olarakta s1 in işaret ettiği objenin i değişkenin değerini değiştirip sonrada değerleri ekrana bastıralım. Görüldüğü üzere s2.i değişkeninde değeri değişmiş oldu. Sebebi ise yine s1 ve s2 referanlarının aynı objeyi göstermeleridir.

3: s1.i: 27, s2.i: 27

Soru , s1 referansının daha evvelden işaret etmiş olduğu Sayi objesine ne olacaktır ? Cevap vermek için henüz erken ama yinede söyliyelim , bu obje kullanılmayacağından dolayı çöp haline gelecektir ve çöp toplayıcısı (Garbage Collector) tarafından temizlenecektir . Görüldüğü üzere kodu yazan kişinin objelerin temizliği konusunda yersiz bir endişeye kapılmasına gerek yoktur. Çöp toplayıcısını (Garbage Collector) ilerleyen bölümlerde daha detaylı bir şekilde inceliyeceğiz.

Bu örneğimizde s1 referansının s2'nin işaret etmiş olduğu objeyi göstermesini istemeyip ,sadece s2.i değişken değerinin s1.i değişken değerine atanmasını istemiş olsaydık , aşağıdaki gösterimi yazmış olmamız yetecekti.

gösterim-4

s1.i = s2.i;

Böylece her iki referansımızda ayrı ayrı Sayi objelerini göstermiş olacaklardır. Bu durumda ortada kullanılmayan obje olmayacaktır.

Deyinmek istediğim diğer bir husus ise bir fiziksel dosya içersinde iki sınıf (class) tanımını yazabilmiş olmamızdır.Peki bu fiziksel dosyanın ismi Sayi.java mi olmasi gerekli yoksa ObjelerdeAtama.java mı olması gerekli ? Cevap fiziksel dosyanın ismimin ObjelerdeAtama.java olacağıdır , sebebi ise javada fiziksel dosyaların ismi her zaman public sınıf (class) isimleri ile bire bir (küçük büyük harf ayrımı olduğunu unutmayın - Case Sensitive) aynı olma gerekliliğidir.

Metod Cağrımları

Metodların parametere kabul ettiklerini ve bu parameteri alaraktan işlemler gerçekleştirdiğini biliyoruz . Peki metodlara parametre olarak ne gitmekte , objenin kendisi mi ? yoksa objenin referansı mı ?

ör-referans-1

class Harf { char c; } public class ObjePaslama { static void f(Harf h) { h.c = 'z'; } public static void main(String[] args) { Harf x = new Harf(); // Harf objesini yaratiyoruz x.c = 'a'; // Harf objesinin c degiskenine deger atadik System.out.println("1: x.c: " + x.c); f(x); /* Harf objesinin referansini f() methoduna gecirdik Burada objenin methoda gonderilmesi soz konusu degildir Method a gonderilen Harf objesinin referansidir. */ System.out.println("2: x.c: " + x.c); } }

Yukarıdaki örneğimizde , iki adet sınıfımız bulunmakta , Harf Sınıfı ve ObjePaslama Sınıfımız. ObjePaslama sınıfımız public olduğu için fiziksel dosyanın ismi ObjePaslama.java dır. Bu ön bilgiden sonra programımızı açıklıyalım ; ilk olarak Harf objemizi oluşturuyoruz ve Harf objemizin char tipinde olan c değişkenine 'a' krakterini atıyoruz. Yaptığımız işlemi bir güzel ekrana bastırdıktan sonra Harf objesini işaret eden x referansını f() metoduna gönderiyoruz. İşler biraz karıştı gibi,devam edelim, sonra f() metodunun içersinde daha evvelden oluşturduğumuz Harf objesinin char tipinde olan c değişkenine 'z' krakterini atıyoruz.Bilgileri tekraradan ekrana bastırdığımızda görüyoruz ki Harf objesinin char tipinde olan c değişkeni değişmiş. Burada olan kesinlikle Harf objesinin yer değiştirmesi değildir. Harf objesinin bellekteki yeri her zaman sabittir. Olan olay sadece f() metodunun içersinde Harf objesine kısa süreli olarak başka bir Harf tipindeki bir referansın işaret etmiş olmasıdır (böylece Harf Objesine toplam iki referans işaret etmiş olmaktadır biri x diğeri ise h ). Metodun sonuna gelindiğinde ise bu referansın( h referansı) geçerlilik alanı bitmiştir ama bu kısa süreli işlemde Harf objesinin char tipinde olan c değişkeni değişmiştir.Bu konuyu ilerleyen bölümlerde daha detaylı bir şekilde inceliyeceğiz.

Matematiksel operatörler

Operatörler bir veya daha fazla değişken üzerinden işlemler gercekleştirirler.İşlem gerçekleştirmek için tek bir değişkene ihtiyaç duyan operatörlere tekli operatör (unary operator) , çift değişkene ihtiyac duyan operatörlere ikili operatör (binary operator) ve son olarakta işlem gerçekleştirmek için üç adet değişkene ihtiyaç duyan operatörlere ise üçlü operatör (ternary operator) denir.

Tekli operatörler hem ön ek(prefix) hemde son ek(postfix) işlemlerini desteklerler.

Ön ek dediğimizden kasıt operatörün değişkenden önce gelmesi anlamındadır.

operatör değişken //ön ek ifadesi

Son ek işlemlerine örnek olarak

değişken operatör // son ek ifadesi

Tüm ikili operatörler ara ek (infix) işlemlerinde kullanılırlar .

değişken1 operatör değişken2 //ara ek

Üçlü operatörlerde ara ek (infix) işlemlerde kullanılır. Javada üçlü operatörler tek bir tanedir.

değişken1 ? değişken2 : değişken3 //ara ek

Aritmetik Operatörler

Aritmetik operatörler değişkenlerdeki değeri alır ve bu değerin sonucunda yeni değerler üretirler. Java programlama dili kayan-noktalı ve tam sayılar için birçok aritmetik işlemi destekler. Bu işlemler (+) toplama operatörü , (-) çıkartma operatörü, (*) çarpma operatörü , (/) bölme operatörü ve son olarakta (%) modülo dur.

Operatör	Kullanılış	Açıklama
+	değişken1 + değişken2	değişken1 ile değişken2 yi toplar
-	değişken1 - değişken2	değişken1 ile değişken2 yi çıkarır
*	değişken1 * değişken2	değişken1 ile değişken2 yi çarpar
/	değişken1 / değişken2	değişken1 ,değişken2 tarafından bölünür
%	değişken1 % değişken2	değişken1 in değişken2 tarafından bölümünden kalan hesaplanır.

tablo-1

İsterseniz anlattıklarımızı bir java uygulaması üzerinde görelim.

ör-aritmatik-1

public class AritmetikOrnek { public static void main(String[] args) { //Degisken degerleri int a = 57; int b = 42; double c = 27.475; double d = 7.22; System.out.println("Degisken Degerleri..."); System.out.println(" a = " + a); System.out.println(" b = " + b); System.out.println(" c = " + c); System.out.println(" d = " + d); //Sayilari topluyoruz System.out.println("Toplama..."); System.out.println(" a + b = " + (a + b)); System.out.println(" c + d = " + (c + d)); //Sayilari cikartiyoruz System.out.println("Cikartma..."); System.out.println(" a - b = " + (a - b)); System.out.println(" c - d = " + (c - d)); //Sayilari Carpiyoruz System.out.println("Carpma..."); System.out.println(" a * b = " + (a * b)); System.out.println(" c * d = " + (c * d)); //Sayilari boluyoruz System.out.println("Bolme..."); System.out.println(" a / b = " + (a / b)); System.out.println(" c / d = " + (c / d)); //Bolme islemlerinden kalan sayiyi hesapliyoruz System.out.println("Kalan sayiyi hesaplama ..."); System.out.println(" a % b = " + (a % b)); System.out.println(" c % d = " + (c % d)); //double ve int tiplerini karisik sekilde kullaniyoruz System.out.println("Karisik tipler..."); System.out.println(" b + d = " + (b + d)); System.out.println(" a * c = " + (a * c)); } }

Uygulamamızın çıktısı aşağıdaki gibidir .

Degisken Degerleri... a = 57 b = 42 c = 27.475 d = 7.22 Toplama... a + b = 99 c + d = 34.695 Cikartma... a - b = 15 c - d = 20.255000000000003 Carpma... a * b = 2394 c * d = 198.36950000000002 Bolme... a / b = 1 c / d = 3.805401662049862 Kalan sayiyi hesaplama ... a % b = 15 c % d = 5.815000000000002 Karisik tipler... b + d = 49.22 a * c = 1566.075

Yukarıdaki örnekte dikkat edilecek olursa , tamsayı ile kayan noktalı sayıları tekli operatörden geçirirsek sonuç yine kayan noktalı sayı olmaktadır. Bu işlemde tamsayı , otomatik olarak kayan noktalı sayıya çevrilmiş olmaktadır.Aşağıdaki tablo bu otomatik çevrim işlemlerinin tümünü göstermektedir.

Sonuç Veri Tipi	Değişkenlerin Veri Tipleri
long	Değişkelerin float veya double tipinden farklı olması ve en az bir değişkenin long tipinde olması
int	Değişkelerin float veya double tipinden farklı olması ve değişkenlerin long tipinden farklı olması
double	En az bir değişkenin double tipinde olması
float	Değişkenlerin hiçbirinin double tipinde olmaması ve değişkenlerden en az birinin float tipinde olması

tablo-2

+ ve - operatörlerin ikilik(binary) formuna dönüştürme misyonlari da vardir.

Operatör	Kullanılış Şekli	Açıklama
+	+değişken	Eğer değişken char, byte veya short tipinde ise int tipine dönüştürür
-	-değişken	Değişkenin değerini negatif yapar (-1 ile çarpar).

tablo-3

Anlaşılması açısından ufak bir uygulama örneği verelim

ör-binary-form

public class OperatorTest { public static void main(String args[] ) { char a = 'a' ; int b = +a ; //otomatik olarak int ilkel tipine cevrildi int c = -b ; // degeri negatif yapti System.out.println("a = " + a ); System.out.println("b = " + b ); System.out.println("c = " + c ); } }

char tipleri ilkel(primitive) tipdir , ve bu tiplere değer atarken tek tırnak içersinde veri atamamız gerekmektedir.Bu örneğimizde bizim girdiğimiz char 'a' dır. Daha sonra + operatörünü kullanarak char değerini int tipine dönüştürüyoruz ve en son olarakta bu int değerini - operatörü ile negatif yapıyoruz . Uygulamanın çıktısı aşağıdaki gibidir .

a = a b = 97 c = -97

Dönüştürme(Casting) işlemi

Bir ilkel (primitive) tipi diğer bir ilkel tipe dönüştürebilirsiniz, fakat oluşacak değer kayıplarından kodu yazan kişi sorumludur

ör-ilkel-dönüşüm

public class IlkelDonusum { public static void main(String args[]) { int a = 5 ; double b = (double) a ; double x = 4.15 ; int y = (int) x ; long z = (long) y ; System.out.println("b = " + b + " y = " + y + " z = " + z); } }

Uygulamanın çıktısı

b = 5.0 y = 4 z = 4

String (+) Operatörü

“+” operatörü String tiplerde birleştirme görevi görür. Eğer ifade String ile başlarsa , onu takip eden tiplerde otomatik olarak String objesine dönüştürülür. Otomatik olarak String objesine dönüştürülme sırrını ilerleyen bölümlerde göreceğiz.

ör-otomatik-cevrim

public class OtamatikCevirim { public static void main(String args[]) { int x = 0, y = 1, z = 2; System.out.println("Sonuc =" + x + y + z); } }

uygulamanın çıktısı

Sonuc =012

String bir ifadeden sonra gelen tamsayılar görüldüğü üzere toplanmadı, direk String objesine çevrilip ekrana çıktı olarak gönderildiler .

Otomatik arttırım ve azaltım

Java dilinde C dilinde olduğu gibi birçok kısaltmalar vardır . Bu kısaltmalar hayatı bazen daha güzel bazen ise çekilmez kılar. En iyi kısaltmalardan ikisi ise arttırma ve azaltma operatörleridir.

Operatör	Kullanılış Şekli	Açıklama
++	değişken++	Önce değişkenin değerini hesaplar sonra değişkenin değerini bir arttırır.
++	++değişken	Önce değişkenin değerini arttırır sonra değişkenin değerini hesaplar.
--	değişken--	Önce değişkenin değerini hesaplar sonra değişkenin değerini bir azaltır.
--	--değişken	Önce değişkenin değerini azaltır sonra değişkenin değerini hesaplar.

tablo-4

Bu operatörlerin kullanımının iki çeşit yöntemi vardir . Birincisi ön ek(prefix) -ki bu (--) veya (++) operatörünün , kullanılan değişkenin önüne gelmesi anlamını taşır , diğeri ise son ek'dir (postfix) , bu da (--) veya (++) operatörünün değişkenin sonuna gelmesi anlamına gelir. Peki bu operatörlerin değişkenin başına gelmesi ile sonuna gelmesi arasında ne farklar vardır ?

Mesela (++a veya --a) örneğinde , önce matematiksel toplama veya çıkartma işlemi gerçekleşir daha sonra değer üretilir.Ama (a++ veya a--) durumunda ise önce değer üretilir daha sonra matematiksel toplama veya çıkartma işlemi gerçekleşir. Aşagıdaki ufak program bunu güzel bir şekilde ifade etmektedir.

ör-otomatik-art-azal

public class OtomatikArtveAz { static void ekranaYaz(String s) { System.out.println(s); } public static void main(String[] args) { int i = 1; ekranaYaz("i : " + i); ekranaYaz("++i : " + ++i); // onek arttirim ekranaYaz("i++ : " + i++); // sonek -arttirim ekranaYaz("i : " + i); ekranaYaz("--i : " + --i); // onek-azaltim ekranaYaz("i-- : " + i--); // sonek-azaltim ekranaYaz("i : " + i); } }

Uygulamamız çıktısı aşağıdaki gibidir :

i : 1 ++i : 2 i++ : 2 i : 3 --i : 2 i-- : 2 i : 1

İlişkişel Operatörler

İlişkisel operatörler iki değeri karşılaştırarak bu değerler arasındaki mantıksal ilişkiyi hesaplarlar. Örneğin iki değer birbirine eşit değilse ; "==" bu ilişki çercevesinde hesaplanan değer false olacaktır. Aşağıdaki tabloda bu hesaplamalar verilmiştir.

Operatör	Kullanılılş Şekli	true değeri döner eğer ki........
>	değişken1 > değişken2	değişken1 , değişken2'den büyükse
>=	değişken1 >= değişken2	değişken1 , değişken2'den büyükse veya eşitse
<	değişken1 < değişken2	değişken1 , değişken2'den küçükse
<=	değişken1 <= değişken2	değişken1 , değişken2'den küçükse veya eşitse
==	değişken1 == değişken2	değişken1 , değişken2'ye eşitse
!=	değişken1 != değişken2	değişken1 , değişken2'ye eşit değilse

tablo-5

Yukarıda açıklanan ifadeleri java uygulaması üzerinde anlatırsak ;

ör-iliskisel

public class IliskiselDeneme { public static void main(String[] args) {

//bir kac sayi

int i = 37;

int j = 42;

int k = 42;

System.out.println("Degisken degerleri...");

System.out.println(" i = " + i);

System.out.println(" j = " + j);

System.out.println(" k = " + k);

//Buyuktur

System.out.println("Buyuktur...");

System.out.println(" i > j = " + (i > j)); //false - i , j den kucuktur

System.out.println(" j > i = " + (j > i)); //true - j , i den buyuktur

System.out.println(" k > j = " + (k > j)); //false - k , j 'ye esit

//Buyuktur veya esittir

System.out.println("Buyuktur veya esittir...");

System.out.println(" i >= j = " + (i >= j)); //false - i , j den kucuktur

System.out.println(" j >= i = " + (j >= i)); //true - j , i den buyuktur

System.out.println(" k >= j = " + (k >= j)); //true - k , j 'ye esit

//Kucuktur

System.out.println("Kucuktur...");

System.out.println(" i < j = " + (i < j)); //true - i , j den kucuktur

System.out.println(" j < i = " + (j < i)); //false - j , i den buyuktur

System.out.println(" k < j = " + (k < j)); //false - k , j 'ye esit

//Kucuktur veya esittir

System.out.println("Kucuktur veya esittir...");

System.out.println(" i <= j = " + (i <= j)); //true - i , j den kucuktur

System.out.println(" j <= i = " + (j <= i)); //false - j , i den buyuktur

System.out.println(" k <= j = " + (k <= j)); //true - k , j 'ye esit

//Esittir

System.out.println("Esittir...");

System.out.println(" i == j = " + (i == j)); //false - i , j den kucuktur

System.out.println(" k == j = " + (k == j)); //true - k , j 'ye esit

//Esit degil

System.out.println("Esit degil...");

System.out.println(" i != j = " + (i != j)); //true - i , j den kucuktur

System.out.println(" k != j = " + (k != j)); //false - k , j 'ye esit

}

}

Uygulamamızın çıktısı :

Degisken degerleri...

i = 37

j = 42

k = 42

Buyuktur...

i > j = false

j > i = true

k > j = false

Buyuktur veya esittir...

i >= j = false

j >= i = true

k >= j = true

Kucuktur...

i < j = true

j < i = false

k < j = false

Kucuktur veya esittir...

i <= j = true

j <= i = false

k <= j = true

Equal to...

i == j = false

k == j = true

Not equal to...

i != j = true

k != j = false

Objelerin Karşılaştırılması

Objelerin eşit olup olmadığını (= =) veya (! =) operatörleri ile test edebiliriz ama aklımız biraz karışıcak ..

ör-obje-esitligi

public class Denklik {

public static void main(String[] args)

{

Integer s1 = new Integer(47);

Integer s2 = new Integer(47);

System.out.println(s1 == s2);

System.out.println(s1 != s2);

}

} n1 ve n2 Integer tipinde ve içlerinde 47 değeri var .. gayet temiz ve kolay .

Uygulamamızın çıktısı olarak aşağıdaki değerleri bekliyor olabiliriz

true

falseAma ne yazik ki öyle değil . Nedenini ise şöyle açıklayabiliriz , elimizde iki adet ayrı Integer objesi bulunamaktadır. Bu Integer objelerinin taşıdıkları değerler birbirlerine eşittir ama biz "s1==s2" ifadesi kullanarak şunu demiş olduk "s1 ve s2 referanslarının işaret etmiş oldukları objeler aynı mı ?" cevap tahmin edilebileceği gibi hayırdır yani false dur , s1 ve s2 ayrı Integer objelerini işaret etmektedir , eşit olan tek şey bu iki ayrı objenin içlerinde taşıdıkları 47 değeridir -ki bu eşitliği "s1=s2" ifadesi ile yakalıyamayız. Programımızın çıktısı aşağıdaki gibidir :

false

truePeki yukarıdaki örnekdeki Integer objeleri yerini ilkel tip olan int tipini kullansaydık sonuç nasıl olurdu ?

ör-ilkel

public class IntIcinDenklik {

public static void main(String[] args) {

int s1 = 47;

int s2 = 47;

System.out.println(s1 == s2);

System.out.println(s1 != s2);

}

}Programın çıktısı :

true

falseİlkel (primitive) tipler değerleri direk olarak kendi üzerlerinde taşınıkları için , (==) operatörü s1 ve s2'nin değerlerini karşılaştırdı ve true döndürdü. Aynı şekilde (!=) operatörüde s1 ve s2'nin değerlerini karşılaştırdı ve false döndürdü. Sonuçlar beklediğimiz gibi .

İlişkisel ve koşul operatörlerinin birlikte kullanılması

Karışık karar mekanizmaları üretmek için ilişkisel operatörler ile koşul operatörleri sık olarak birlikte kullanılırlar . Java programlama dilinde toplam 6 adet koşul operatörü bulunur , bunlardan 5 tanesi ikili (binary) operatör , 1 tanesi ise tekli (unary) operatördür. Aşagıdaki tablodaki değişken1 ve değişken2 değerlerinin boolean (mantıksal) değerler içermesi gerekmektedir.

OperatörKullanılılş Şeklitrue değeri döner eğer ki........ && değişken1 && değişken2 Eğer hem değişken1 hemde değişken2 true ise ; değişken2'yi duruma göre hesaplar* || değişken1 || değişken2 değişken1'in veya değişken2'in true olması ; değişken2'yi duruma göre hesaplar* ! ! değişken Eğer değişken false ise & değişken1 & değişken2 Eğer hem değişken1 hemde değişken2 true ise ; değişken1 ve değişken2 her durumda hesaplanır*. | değişken1 | değişken2 değişken1'in veya değişken2'in true olması ; değişken1 ve değişken2 her durumda hesaplanır*. ^ değişken1 ^ değişken2 Eğer değişken1 ve değişken2 birbirlerinden farklı ise; ör: değişken1 true ,değişken2 false ise*tablo-6

Yukarıdaki tablo ile alakalı gösterimleri java uygulaması üzerinde gösterirsek;

ör-java-kosul-op

public class KosulOp {

public static void main( String args[] ) {

int a = 2 ;

int b = 3 ;

int c = 6 ;

int d = 1 ;

/*

(a < b) = bu ifadenin true oldugunu biliyoruz

(c < d) = bu ifadenin false oldugunu biliyoruz

*/

System.out.println(" (a < b) && (c < d) --> " + ( (a < b) && (c < d) ) );

System.out.println(" (a < b) || (c < d) --> " + ( (a < b) || (c < d) ) );

System.out.println(" ! (a < b) --> " + ( ! (a < b) ) );

System.out.println(" (a < b) & (c < d) --> " + ( (a < b) & (c < d) ) );

System.out.println(" (a < b) | (c < d) --> " + ( (a < b) | (c < d) ) );

System.out.println(" (a < b) ^ (c < d) --> " + ( (a < b) ^ (c < d) ) );

}

}

Uygulamamızın çıktısı aşağıdaki gibidir :

(a < b) && (c < d) --> false

(a < b) || (c < d) --> true

! (a < b) --> false

(a < b) & (c < d) --> false

(a < b) | (c < d) --> true

(a < b) ^ (c < d) --> truedurumuna göre hesaplar ibaresinin şu an için anlaşılmadığını biliyorum , if-else koşul ifadesinde yer alan kısa devre bölümünü incelemenizi tavsiye ediyorum .

Kaydırma(Shift) Operatörleri

Kaydırma operatörleri , veri üzerinde bitlerin sağa ve sola kaydırılması suretiyle hesaplamalar yapmamızı sağlar.Aşağıdaki tablo bu operatörlere ait özet bilgiler bulunmaktadır.

Operator Kullanılış Şekli Açıklama >> değişken1 >> değişken2değişken1'in bitlerini değişken2 nin değeri kadar sağa kaydırır. << değişken1 << değişken2değişken1'in bitlerini değişken2 nin değeri kadar sola kaydırır. >>> değişken1 >>> değişken2 değişken1'in bitlerini değişken2 nin değeri kadar sağa kaydırır. (unsigned)tablo-6

Aşağıdaki örneğimiz bu operatörlerin Java uygulamalarında nasıl kullanılacaklarına ait bir fikir verebilir .

ör-bitwise

public class Bitwise {

public static void main( String args[] ) {

int a = 9 ;

System.out.println(" (a >> 1) -->" + (a >> 1) );

System.out.println(" (a >> 2) -->" + (a >> 2) );

System.out.println(" (a << 1) -->" + (a << 1) );

System.out.println(" (a << 2) -->" + (a << 2) );

System.out.println(" (a >>> 2) -->" + (a >>> 2) );

}

}Bu örneğimizde verilen 9 sayısının ikilik düzene cevrilişi aşağıdaki gibidir :

(a >> 1) ifade ile 9 sayısına karşılık olan 1001 bitlerini sağa doğru 1 basamak kaydırıyoruz ; _100 , boş olan yerlere 0 yerleştirdiğimizde ifade tamamlanmış olmaktadır , 0100 , ondalık olarak 4 değerini elde etmiş olduk .

(a >> 2) ifade ile 9 sayısına karşılık olan 1001 bitlerini sağa doğru 2 basamak kaydırıyoruz ; __10 , boş olan yerlere 0 yerleştirdiğimizde ifade tamamlanmış olmaktadır , 0010 , ondalık olarak 2 değerini elde etmiş olduk .

(a << 1) ifade ile 9 sayısına karşılık olan 1001 bitlerini sola doğru 1 basamak kaydırıyoruz ; 1001_ , boş olan yerlere 0 yerleştirdiğimizde ifade tamamlanmış olmaktadır , 10010 , ondalık olarak 18 değerini elde etmiş olduk .

(a << 2) ifade ile 9 sayısına karşılık olan 1001 bitlerini sola doğru 2 basamak kaydırıyoruz ; 1001__ , boş olan yerlere 0 yerleştirdiğimizde ifade tamamlanmış olmaktadır , 100100 , ondalık olarak 36 değerini elde etmiş olduk .

(a >>> 2) ifadenin (a >> 2) ile arasında işlemsel olarak bir fark yoktur , sonuç olarak yine 2 elde ederiz. ">>>" operatörü işaretsiz (unsigned) sağa doğru kaydırım yapar .

Eğer char, byte, veya short tiplerinde kaydırım işlemi yapacaksanız bu tipler ilk önce int tipine dönüştürülürler.Eğer long tipinde kaydırma işlemi gerçekleştiriyorsanız o zaman yine long tipinde bir sonuç elde ederseniz .

Uygulamamızın çıktısı :

(a >> 1) -->4

(a >> 2) -->2

(a << 1) -->18

(a << 2) -->36

(a >>> 2) -->2Aşağıdaki tabloda gösterilen 4 operatör bitler üzerinde mantıksal işlemleri gerçektirmemize olanak tanır.

OperatörKullanılış ŞekliAçıklama &değişken1 & değişken2mantıksal and (VE) |değişken1 | değişken2mantıksal or (VEYA) ^değişken1 ^ değişken2mantıksal xor (ÖZEL VEYA) ~~değişkenmantıksal tamamlamatablo-7

Eğer değişkenler sayı ise yukarıda gösterilen operatörleri kullanarak mantıksal işlemler gerçekleştirebiliriz.

VE (And) işlemi

değişken1 değişken2 Sonuç 000010100111tablo-8

Ve(And) işlemi (&) aldığı iki değer ile yeni bir değer üretir , ürettiği değerler yukarıdaki tabloda mevcuttur ; Örneğin 10 ve 9 değerlerini VE (And) işleminden geçirirsek :

1010 //10

& 1001 //9

---------

1000 //8VE (And) işlemi sadece iki değerinde 1 olması durumunda1 sonucunu üretmektedir.

VEYA(Or) işlemi

değiken1 değişken2 Sonuç 000011101111tablo-9

örneğin yine 10 ve 9 sayıları üzerinde VEYA işlemini gerçekleştirelim

1010 //10

| 1001 //9

---------

1011 //11VEYA işleminde sadece iki değerinde sıfır olması durumunda sonuç sıfır olur

Özel VEYA (Exclusive Or) İşlemi

değişken1 değişken2 Sonuç 000011101110tablo-10

Özel VEYA değişken1 ve değişken2'nin farklı olması durumunda 1 sonucunu üretmektedir.

1010 //10

^ 1001 //9

---------

0011 //3

ör-bitwise-2

public class BitwiseOrnek2 {

public static void main( String args[] ) {

int a = 10 ;

int b = 9 ;

int c = 8 ;

System.out.println(" (a & b) --> " + (a & b) );

System.out.println(" (a | b) --> " + (a | b ) );

System.out.println(" (a ^ b) --> " + (a ^ b) );

System.out.println(" ( ~a ) --> " + ( ~a ) );

System.out.println(" ( ~b ) --> " + ( ~b ) );

System.out.println(" ( ~c ) --> " + ( ~c ) );

}

}Uygulamın çıktısı :

(a & b) --> 8

(a | b) --> 11

(a ^ b) --> 3

( ~a ) --> -11

( ~b ) --> -10

( ~c ) --> -9VE(And), VEYA( or ),ÖZEL VEYA (Exclusive Or) operatörlerini , birden çok mantıksal sonuç içeren ifadelerde kullanabilirsiniz.

Atama Operatörleri

En temel atama operatörü olarak "=" kullanılır.

ör-temel-atama

public class EnBuyukSayilar {

public static void ekranaBas(String deger) {

System.out.println(deger);

}

public static void main( String args[] ) {

// tam sayilar

byte enbuyukByte = Byte.MAX_VALUE;

short enbuyukShort = Short.MAX_VALUE;

int enbuyukInteger = Integer.MAX_VALUE;

long enbuyukLong = Long.MAX_VALUE;

ekranaBas("enbuyukByte-->" + enbuyukByte );

ekranaBas("enbuyukShort-->" + enbuyukShort );

ekranaBas("enbuyukInteger-->" + enbuyukInteger );

ekranaBas("enbuyukLong-->" + enbuyukLong );

ekranaBas("");

// gerçek sayilar

float enbuyukFloat = Float.MAX_VALUE;

double enbuyukDouble = Double.MAX_VALUE;

ekranaBas("enbuyukFloat-->" + enbuyukFloat );

ekranaBas("enbuyukDouble-->" + enbuyukDouble );

ekranaBas("");

// diger ilkel (primitive) tipler

char birChar = 'S';

boolean birBoolean = true;

ekranaBas("birChar-->" + birChar );

ekranaBas("birBoolean-->" + birBoolean );

}

}

Birazdan göreceğimiz kısa devre operatörleri ise hayatımızı dahada kolaylaştırmak amacı ile tasarlanmışlardır. Örneğin int tipinde olan i değişkenini 1 tam sayılarını toplamak için normal olarak aşağıdaki gibi bir ifade kullanırız .

i = i + 1 ;Kısa devre operatörler ile aynı ifadeyi aşağıdaki gibi yazmak mümkündür.

i += 1 ;