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

false

Ama 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

true

Peki 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ör

Kullanılılş Şekli

true 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) --> true

durumuna 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şken2

değişken1'in bitlerini değişken2 nin değeri kadar sağa kaydırır.

 <<

 değişken1 << değişken2

değ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) -->2

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

Operatör

Kullanılış Şekli

Açıklama

 &

değişken1  & değişken2

mantıksal and (VE)

 |

değişken1 | değişken2

mantıksal or (VEYA)

 ^

değişken1 ^ değişken2

mantıksal xor (ÖZEL VEYA) 

 ~

~değişken

mantıksal tamamlama

tablo-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ç 

0

0

0

0

1

0

1

0

0

1

1

1

tablo-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 :  

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

VEYA(Or) işlemi

 değiken1 

 değişken2 

 Sonuç 

0

0

0

0

1

1

1

0

1

1

1

1

tablo-9

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

     1010     //10
  |  1001     //9
  ---------
     1011      //11

VEYA 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ç 

0

0

0

0

1

1

1

0

1

1

1

0

tablo-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 ) --> -9

VE(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

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 ;

Aşağıdaki tablo bu tip kısa devre operatörlerin bir listesini vermketedir 

tablo-11

Kontrol İfadeleri

Kontrol ifadeleri bir uygulamanın hangi durumlarda ne yapması gerektiğini belirten ifadelerdir.Onlarsız bir uygulama yazamak neredeyse imkansız diyebilirim . Java programlama dilinde toplam 4 adet kontrol ifade çeşiti bulunur :

İfade tipi

Anahtar Kelime

 döngüleme

while, do-while , for

 karar verme

if-else, switch-case

 istisna yakalama

try-catch-finally, throw 

 dallandırma

break, continue, label:, return

tablo-12

Döngüleme

while  - do while 

while

while ifadesi , çalışması istenen kod bloğunu , durum true ifadesini bulana kadar devamlı olarak çalıştırır.Genel yazım ifadesi aşağıdaki gibidir 

while (durum) {
    çalışması istenen kod bloğu 
}

while ifadesi ilk önce durumun true olup olmadığına bakar , eğer durum true ise döngüye girerek çalışması istenen kod bloğunu çalıştırır bu süreç durumun false olmasına kadar sürüp gider .

ör-while

public class WhileOrnek {

    public static void main(String args[]) {

         int i = 0 ; //döngü kontrol degiskeni
         while (i < 10 ) 
	 {
             System.out.println("i = " + i);
             i++ ;
         }
         System.out.println("Sayma islemi tamamlandi.");
    }

}

Uygulamanın çıktısı :

 i = 0
 i = 1
 i = 2
 i = 3
 i = 4
 i = 5
 i = 6
 i = 7
 i = 8
 i = 9
 Sayma islemi tamamlandi.

do-while

do-while ifadesinin genel yazım şekli aşağıdaki gibidir :

do {
    çalışması istenen kod bloğu 
} while (durum);

do-while ifadesi, durumu en yukarıda değilde en aşağıda hesaplar , böylece do-while ifadesinde durum false olsa bile çalışması istenen kod bloğuna en az bir kere girilir.

ör-dowhile

Bu örneğimizi while ifadesi ile yazmış olsaydık ekranda sadece "Sayma islemi tamamladi" ibaresini görecektik ama do-while ifadesi kullanarak çalışması istenen kod bloğuna durum false olsa dahi bir kere  girmesini sağladık.

while döngüsü kullanırken dikkat edilmesi gereken hususlar kısaca belirtirsek ;

1. Döngü kontrol değişkenine uygun bir şekilde değer atandığına dikkat edin.

2. Döngü durumunun true ile başlamısına dikkat edin.

3. Döngü kontrol değişkeninin uygun bir şekilde  güncellendiğinden emin olun.(sonsuz döngüye girmemesi için)

for ifadesi

for ifadesi döngüsel işlemleri daha bir derli toplu yapma şeklidir. Döngünün ne zaman başlayacağı ve ne zaman biteceği en başta belirtilmiştir . for ifadesinin genel yazım ifadesi aşağıdaki gibidir  :

for (başlangıç durumunu belirtme ; sonlanma durumunu belirtme; artış) {
    çalışması istenen kod bloğu 
}

ör-for-2

public class ForOrnek {

  public static void main(String args[]) {

    for (int i=0 ; i < 10 ; i ++) 
    {
      System.out.println("i = " + i);
    } 
  }
}

Uygulamın çıktısı 

i = 0
i = 1
i = 2
i = 3
i = 4
i = 5
i = 6
i = 7
i = 8
i = 9

for ifadesi kullanarak sonsuz döngü oluşturmak isterseniz aşağıdaki ifadeyi kullanabilirsiniz.

for ( ; ; ) {    // sonsuz döngü
    ...
}

ayrıca for ifadesinin içersinde birden fazla değişken kullanabilirsiniz 

ör-for-2

Uygulamanın çıktısı  : 

i = 0 j = 0
i = 1 j = 1
i = 4 j = 2
i = 15 j = 3
i = 64 j = 4

Karar Verme 

if-else  ifadesi 

Bazı kriterlere göre uygulamanızın akışını değiştirmek istiyorsanız doğru yerdesiniz. if koşuluna, durum eğer true ise girecektir.Genel yazım ifadesi aşağıdaki gibidir.

if (durum) {
  durum true olduğunda çalışması istenen kod bloğu
} else {
  durum false olduğunda çalışması istenen kod bloğu
}

ör-if-else-1

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

    int puan = 76;
    char sonuc;

    if (puan >= 90) {
     sonuc = 'A';
    } else if (puan >= 80) {
     sonuc = 'B';
    } else if (puan >= 70) {
     sonuc = 'C';
    } else if (puan >= 60) {
     sonuc = 'D';
    } else {
     sonuc = 'F';
    }
    System.out.println("Sonuc = " + sonuc);
  }
}

int tipindeki puan değişkeni sıra ile tüm koşullara uğramaktadır. Uygulamamızın çıktısı aşağıdaki gibidir.

Sonuc = C

Üçlü if-else

Üçlü if-else ifadesi , önceki if-else ifadesine alternatif olarak kullanılabilir.Genel yazılış biçimi 

boolean-ifade ? deger0 : deger1

Eğer  boolean ifade true ise değer0  hesaplanır , eğer boolean ifade false ise deger1 hesaplanır. 

Kısa devre

  VE (And) işleminde(bkz1) , işleme giren iki değerinde true olması durumunda sonuç true oluyordu (bkz2) .If ifadesinde eğer VE(And) işlemi kullanılmış ise ve ilk değerden false dönmüş ise ikinci değer kesinlikle hesaplanmaz çünkü bu iki değerin sonuçu VE(And) işlemine göre true dönmesi imkansızdır. Kısa devre özelliği sayesinde uygulamalar gereksiz hesaplamalardan kurtulmuş olur .

ör-kısa-devre

Programızı açıklarsak ; hesaplaBir() ve hesaplaIki() adında iki adet metodumuz var. Bu metodlar int tipinde değişken kabul diyorlar ve boolean tipinde sonuc üretip geri döndürüyorlar. Bu metodlara girildiği zaman ekrana kendilerini tanıtan bir yazı çıkarttırıyoruz -ki gerçekten kısa devre olup olmadığını anlayalım. 

hesaplaBir() metodu kendisine gelen int tipindeki değişkeni alip 1 den büyük mü diye kontrol yapıyor , biz burada hesaplaBir() metoduna parametre olarak 0 sayısını gönderdiğimizden dolayı dönecek değerin false olucağını biliyoruz . hesaplaIki() metodunada aynı şekilde 3 sayısını göndererek bu metodun bize true değeri döndüreceğinden emin olduktan sonra işlemlere başlıyoruz.

İlk olarak metodlardan bize geri dönen değerleri VE(And) işlemine tabii tutuyoruz. Görüldüğü üzere sadece hesaplaBir() metoduna giriyor çünkü hesaplaBir() metodundan false değeri dönmekte , VE (And) işleminde true dönebilmesi için iki değerinde true olması gerektiğinden (bkz1) hesaplaIki() metoduna gitmeyerek kısa devre yapmış oldu.

İkinci olarak bize gelen değerleri VEYA(Or) işlemine tabii tutuyoruz.Görüldüğü üzere hem hesaplaBir() , hemde hesaplaIki() metodlarına girmekte.VEYA(Or) tablosunu hatırlarsanız (bkz2), sonucun false olması için iki değerinde false olması gerekmekteydi.Burada ilk değerden false değeri döndü ama ikinci değerinde hesaplanması gerek aksi taktirdi sonucun öğrenilmesi imkansız olur, bu sebebten burada kısa devre olayı gerçekleşmedi. Ama eğer ilk değer true dönseydi o zaman ikinci metod olan hesaplaIki()'ye girmeyecekti sebebei ise VEYA(Or) işlemlerinin sonucunun true olabilmesi için değerlerden birinin true olmasının yetmesidir.

Üçüncü olarak değerlerimizi yine VE(And) işlemine tabii tutuyoruz ama burada (&) operatörü kullanıldığı için kısa devre olayı ortadan kalkar ve iki metoda da ayrı ayrı girer. (bkz3)

Dördüncü olarak değerlerimizi  VEYA(Or) işlemine tabii tutuyoruz fakat ( | ) operatörünün zaten kısa devre kullanımı ortadan kaldırdığı için iki metoda da ayrı ayrı girer.(bkz3) .

Son olarak değerlerimizi ÖZEL VEYA(Exclusive Or) işlemine tabii tutuyoruz , bu işlemde kesinlikle iki değerede bakılma zorunluluğu olduğundan, kısa devre işlemi söz konusu değildir.(bkz4)

Uygulamanın çıktısı

Baslangic
hesaplaBir(0) && hesaplaIki(3)
hesaplaBir metoduna girildi
1 -false
--------
hesaplaBir(0) || hesaplaIki(3)
hesaplaBir metoduna girildi
hesaplaIki metoduna girildi
2 -true
--------
hesaplaBir(0) & hesaplaIki(3)
hesaplaBir metoduna girildi
hesaplaIki metoduna girildi
3 -false
--------
hesaplaBir(0) | hesaplaIki(3)
hesaplaBir metoduna girildi
hesaplaIki metoduna girildi
4 -true
--------
hesaplaBir(0) ^ hesaplaIki(3)
hesaplaBir metoduna girildi
hesaplaIki metoduna girildi
5 -true
Son..

switch ifadesi

switch ifadesi , tamsayıların karşılaştırılması ile doğru koşulların elde edilmesini sağlayan mekanizmadır. switch ifadesinin genel yazım biçimi aiağıdaki gibidir  

switch(tamsayı) {
  case uygun-tamsayı-deger1 : çalışması istenen kod bloğu; break; 
  case uygun-tamsayı-deger2 : çalışması istenen kod bloğu; break;
  case uygun-tamsayı-deger3 : çalışması istenen kod bloğu; break;
  case uygun-tamsayı-deger4 : çalışması istenen kod bloğu; break;
  case uygun-tamsayı-deger5 : çalışması istenen kod bloğu; break;
          // ...
  default: çalışması istenen kod bloğu ;
}

switch içersindeki tamsayı ile , bu tamsayıya karşılık gelen koşula girilir ve istenen kod bloğu çalıştırılır.Kod bloklarından sonra break koymak gerekir aksi takdirde uygun koşulu bulduktan sonraki her koşula girilecektir.Eğer tamsayımız koşullardan hiçbirine uymuyorsa default koşulundaki kod bloğu çalıştırılarak son bulur.

ör-switch-1

Uygulamanın çıktısı 

Agustos

Aynı örneğimizin ,  break anahtar kelimelerinin kaldırılmış haldeki versiyonu 

ör-switch-2

public class AylarSwitchTest {
    
    public static void main(String[] args) {
        
	int ay = 8;
	switch (ay) {
            case 1:  System.out.println("Ocak"); 
            case 2:  System.out.println("Subat"); 
            case 3:  System.out.println("Mart"); 
            case 4:  System.out.println("Nisan"); 
            case 5:  System.out.println("Mayis"); 
            case 6:  System.out.println("Haziran"); 
            case 7:  System.out.println("Temmuz"); 
            case 8:  System.out.println("Agustos"); 
            case 9:  System.out.println("Eylul"); 
            case 10: System.out.println("Ekim"); 
            case 11: System.out.println("Kasim"); 
            case 12: System.out.println("Aralik"); 
        }
    }
}

Uygulamanın çıktısı aşağıdaki gibidir , bu istenmeyen bir durumdur ;

Agustos
Eylul
Ekim
Kasim
Aralik

ör-switch-3

Bu örneğimizde istenen durum hiçbir koşula uymadığı için , default koşulundaki kod bloğu çalışmaktadır. 

Uygulamanın çıktısı 

Heyoo ,Aranilan Kosul Bulunamadi !!

Dallandırma İfadeleri

Java programlama dilinde dalladırma ifadeleri toplam 3 adettir .

• break ifadesi

• continue ifadesi 

• return ifadesi

break ifadesi

break ifadesinin iki türlü şekli bulunur , bunlardan biri etiketli (labeled) diğeri ise etiketsiz (unlabeled ) versiyonlardır.Etiketsiz (unlabeled ) break ifadesi versiyonunun , switch ifadelerinde nasıl kullanıldığını görmüştük.Etiketsiz  break ifadesi sayesinde , koşul sağlandığında switch ifadesinin sonlanmasını sağlıyorduk. break ifadesini aynı şekilde while , do-while ve for ifadelerinden çıkmak içinde kullanabilirsiniz. 

ör-break-1-etiketsiz

Normalde 0 dan 99'a kadar dönmesi gereken kod bloğu , i değişkenin 9 değerine gelmesiyle for dönüsünğn dışına çıktı . Uygulamanın çıktısı aşağıdaki gibidir .

i =0
i =1
i =2
i =3
i =4
i =5
i =6
i =7
i =8
Donguden cikti

Etikesiz break ifadeleri en içteki while , do-while , for döngü ifadelerini sona erdirirken , etiketli break ifadeleri  etiket(label) hangi döngünün başına konulmuş ise  o döngü sistemini  sona erdirir. 

ör-break-etiketli

Yukarıdaki örneğimizde etiket kullanarak , daha geniş çaplı bir döngü sisteminden çıkmuş olduk .Uygulamanın çıktısı 

i =0
i =1
i =2
i =3
i =4
i =5
i =6
i =7
i =8

continue İfadesi

continue ifadesi döngü içersinde o anki döngü  işleminin pas geçilmesini ve bir sonraki döngü işleminin başlamasını sağlayan bir mekanızmadır. continue ifadeleride break ifadeleri gibi iki çeşite ayrılır. Etiketsiz (unlabeled ) continue  ve etiketli (labeled) continue. Etiketsiz continue en içdeki döngü içersinde etkili olurken , etiketli (labeled) continue ise başına konulduğu döngü sisteminin etkiler.

ör-continue -etiketsiz

Uygulamanın çıktısı ;

Ekran çıktısına dikkat edersek , 9 değerinin olmadığını görürüz . continue ifadesi , break ifadesi gibi döngüleri kırmaz , sadece belli durumlardaki döngü işleminin pas geçilmesini sağlar .

ör-continue-etiketli

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

		pas : 
		for ( int j = 0 ; j < 6 ; j ++ ) {

			for ( int i = 0; i < 5; i++ ) {
				if ( i ==3 ) {// for dongusunu kiriyor
					continue pas;
				}
				System.out.println("i =" +i);
			}
			System.out.println("Donguden cikti");
			System.out.println("j =" +j);
		}
	} 
}

Bu uygulamamızda , pas label ekitini kullanarak , continue işleminin en dışdaki döngüsel sistemden başlamasını sağladık. Uygulamamızın çıktısı;

i =0
i =1
i =2
i =0
i =1
i =2
i =0
i =1
i =2
i =0
i =1
i =2
i =0
i =1
i =2
i =0
i =1
i =2

i değişkeninin her seferinde yeniden 0'dan başladığını ve 2 de kesiltiğini görmekteyiz.Bu işlem toplam 6 kez olmuştur yani en dışdaki döngünün sınırları dahilinde.

return ifadesi

return ifadesini daha evvelden bahsetmistik ama yeni bir hatırlatma fena olmaz . return ifadesinin iki tür kullanım şekli vardır . Birincisi ideğer döndürmek için -ki metodlardan değerleri böyle geri döndürürüz , ikincisi ise eğer metodun dönüş tipi buna izin veriyorsa (void ise ) herhangi bir taviz vermeden return yazıp  metod dan çıkabiliriz.