İşlemciler

► Kısa anlatım

İşlemciler, bir, iki veya üç değişken veya sabite işlem yaparlar.

Atama işlemcisi

Atama işlemcisi sağ tarafında bulunan değeri sol tarafında bulunan değişkene atar.

int id1 = 21; /* int değişkene 21 değerini atar. */

char cd1 = 'A'; /* char değişkene 'A' harfini atar. */

sinif_adi sinif_nesne = new sinif_adi(para1, para2, ...); /* char değişkene 'A' harfini atar. */

Personel per = new Personel("Ahmet", "Kara", 27); /* sınıf değişkene atama */

Aritmetik işlemciler

Java programlama dilinde toplam 5 adet aritmetik işlemci vardır. Toplama işlemcisi aynı zamanda karakter dizilerinin birleştirilmesi için de kullanılmaktadır.

İşlemci  Kullanma amacı

   +     Toplama
   -     Çıkarma
   *     Çarpma
   /     Bölme
   %     Bölme işleminde kalanı verme

int id1 = 7 + 9;  /* int değişkeni 16 değerini alır. */ 
int id1 = 5 - 2;  /* int değişkeni 3 değerini alır. */ 
int id1 = 16 * 3; /* int değişkeni 48 değerini alır. */ 
int id1 = 36 / 3; /* int değişkeni 12 değerini alır. */ 
int id1 = 14 % 6; /* int değişkeni 2 değerini alır. */ 

id1 = 5;       /* değişkene 5 değerini atar. */ 
id1 = id1 + 7; /* değişkene 7 değerini ekler, değişkenin yeni değeri 12 olur. */ 
id1 = id1 - 3; /* değişkenden 3 değerini çıkarır, değişkenin yeni değeri 9 olur. */ 
id1 = id1 * 2; /* değişkeni 2 ile çarpar, değişkenin yeni değeri 18 olur. */ 
id1 = id1 / 3; /* değişkeni 3'e böler, değişkenin yeni değeri 6 olur. */ 
id1 = id1 % 4; /* değişkeni 4'e böler, değişkenin yeni değeri 2 olur. */ 

id1 += 9;      /* farklı bir değer ekleme yöntemi, yeni değer 11 olur. */ 

String str1 = "İlk dizi";
String str2 = "İkinci dizi";
String str3 = str1 + str2; /* "İlk dizi İkinci dizi" */ 

Tek elemanlı işlemciler

Sadece tek bir değişkene işlem yaparlar:

İşlemci Kullanma amacı

+ Pozitif değer işlemcisi (Kullanılmasada değişken pozitif bir değer taşır.)

- Negatif değer işlemcisi

++ Artırma işlemcisi: Bir değişken değerini 1 artırır.

-- Azaltma işlemcisi: Bir değişken değerini 1 azaltır.

! Mantıksal değer değiştirme işlemcisi: boolean bir değerin tersini alır.


int id1 = -12;       /* int değişkeni -12 değerini alır. */ 
id1 = +8;            /* int değişkeni 8 değerini alır. */ 
id1++;               /* int değişkeni 9 değerini alır. */ 
id1--;               /* int değişkeni tekrar 8 değerini alır. */ 

boolean bd1 = false; /* bd1 değişkeni false değer alır. */ 
boolean bd2 = !bd1;  /* bd2 değişkeni true değer alır. */ 

Artırma (++) ve azaltma (--) işlemcileri bir değişkenden önce veya sonra kullanılabilir. Değişken adından önce kullanıldığında, işlemin yapıldığı kod satırında yeni alacağı değer geçerli olur. Değişken adından sonra kullanıldığında ise, bir sonraki kod satırında alacağı değer geçerli olur.


int id1 = 7;               /* int değişkeni 7 değerini alır. */ 
System.out.println(++id1); /* Ekrana 8 yazar, değer hemen geçerli olur. */ 
System.out.println(id1++); /* Ekrana yine 8 yazar, değer sonraki satırda geçerlidir. */ 
System.out.println(id1);   /* Ekrana 9 yazar, değer burada geçerlidir. */ 

Eşitlik ve ilişkisel işlemciler

İşlemci  Kullanma amacı

   ==    Eşit ise
   !=    Eşit değilse
   >     Büyük ise
   >=    Büyük veya eşit ise
   <     Küçük ise
   <=    Küçük veya eşit ise

/* javaprog.java */
public class javaprog {
  public static void main(String args[]){
    int id1 = 17, id2 = 28;

    if(id1 == id2) System.out.println("Değişken değerleri eşit!");
    if(id1 != id2) System.out.println("Değişken değerleri farklı!");
    if(id1 > id2) System.out.println("id1 değeri id2 değerinden büyük!");
    if(id1 >= id2) System.out.println("id1 değeri id2 değerinden büyük veya eşit!");
    if(id1 < id2) System.out.println("id1 değeri id2 değerinden küçük!");
    if(id1 <= id2) System.out.println("id1 değeri id2 değerinden küçük veya eşit!");
  }
}

Komut satırında aşağıdaki satırları yazdığınızda program derlenir ve çalışır:

C:\>javac javaprog.java
C:\>java -Dfile.encoding=Cp857 javaprog
Değişken değerleri farklı!
id1 değeri id2 değerinden küçük!
id1 değeri id2 değerinden küçük veya eşit!

Koşul işlemcileri

Koşul işlemcileri 2 boolean ifade ile işlem yaparlar. Koşul işlemcileri doğru veya yanlış sonuç veren ifadeler arasında işlem yapan işlemcilerdir. Doğru ve yanlış ifade ile kastedilen sırasıyla 1 ve 0 değerleridir. Mantıksal işlemciler doğru ve/veya yanlış sonuçları birleştirip tek bir sonuç verirler. Genellikle ilişkisel işlemcilerle birlikte kullanılan mantıksal işlemciler AND, OR ve NOT ile ilgili mantıksal işlemlerin yerine getirilmesini sağlarlar.

İşlemci  Kullanma amacı

   &&    AND
   ||    OR
   ?:    3 değere işlem yapar, if-then-else yerine kullanılır.

Doğru ifadeler için 1, yanlış ifadeler için 0 değeri kullanılarak oluşturulmuş mantıksal işlemci tablosu aşağıdadır:

x   y     x && y    x || y     !x

0   0        0         0        1
0   1        0         1        1
1   1        1         1        0
1   0        0         1        0

/* javaprog.java */
public class javaprog {
  public static void main(String args[]){
    int id1 = 12, id2 = 24;

    if((id1 != id2) && (id1 > 10) && (id2 > 10))System.out.println("Değişkenler 10'dan büyük ve farklı iki sayı!");
    if((id1 > 20) || (id2 > 20))System.out.println("Değişkenlerin bir tanesi 20'den büyük bir sayı!");
	
    System.out.println((id1>id2) ? id1 : id2);
  }
}

Komut satırında aşağıdaki satırları yazdığınızda program derlenir ve çalışır:

C:\>javac javaprog.java
C:\>java -Dfile.encoding=Cp857 javaprog
Değişkenler 10'dan büyük ve farklı iki sayı!
Değişkenlerin bir tanesi 20'den büyük bir sayı!
24

Son satırda ? işlemcisi kullanılmaktadır. Eğer (id1>id2) koşulu doğru sonuç verirse ? işaretinden sonra yer alan değer, aksi takdirde : işaretinden sonraki değer geri döndürülür. Burada, id1 değişken değeri id2 değişken değerinden küçük olduğundan, koşul yanlış sonuç verir ve id2 değeri geri döndürülerek ekrana yazılır.

instanceof işlemcisi

instanceof işlemcisi tanımlanmış olan bir nesnenin bir sınıftan veya bir arayüzü kullanan bir sınıftan türetilip türetilmediğini belirlemek çin kullanılır. İşlem sonucu true veya false bir değer elde edilir.

nesne_adi instanceof sinif_arayüz_adi;

Aşağıdaki programda bir ana sınıf, bu ana sınıftan türetilen bir alt sınıf ve alt sınıfın kullandığı bir arayüz tanımlanmaktadır.


/* javaprog.java */
public class javaprog {
  public static void main(String[] args) {

    anasinif obj1 = new anasinif();
    anasinif obj2 = new altsinif();

    System.out.println("obj1 anasinif sınıfına aittir: " + (obj1 instanceof anasinif));
    System.out.println("obj1 altsinif sınıfına aittir: " + (obj1 instanceof altsinif));
    System.out.println("obj1 altInterface arayüzünü kullanan bir sınıfa aittir: " + (obj1 instanceof altInterface));
    System.out.println("obj2 anasinif sınıfına aittir: " + (obj2 instanceof anasinif));
    System.out.println("obj2 altsinif sınıfına aittir: " + (obj2 instanceof altsinif));
    System.out.println("obj2 altInterface arayüzünü kullanan bir sınıfa aittir: " + (obj2 instanceof altInterface));
  }
}

class anasinif {}
class altsinif extends anasinif implements altInterface {}
interface altInterface {}

Komut satırında aşağıdaki satırları yazdığınızda program derlenir ve çalışır:

C:\>javac javaprog.java
C:\>java -Dfile.encoding=Cp857 javaprog
obj1 anasinif sınıfına aittir: true
obj1 altsinif sınıfına aittir: false
obj1 altInterface arayüzünü kullanan bir sınıfa aittir: false
obj2 anasinif sınıfına aittir: true
obj2 altsinif sınıfına aittir: true
obj2 altInterface arayüzünü kullanan bir sınıfa aittir: true

Bit işlemcileri

İşlemci  Kullanma amacı

   &     AND
   |     OR
   ^     XOR
   
   ~     Bir sayının bütün bit değerlerini tersine çevirir (1 ise 0, 0 ise 1 yapar).   

& : İşlem yapılan değerlerin karşılıklı gelen her iki bit'i 1 ise, 1 değerini verir.

| : İşlem yapılan değerlerin karşılıklı gelen bit'lerinden herhangi biri 1 ise, 1 değerini verir.

^ : İşlem yapılan değerlerin karşılıklı gelen bit'lerinden ikisi de aynı değeri taşıyorsa 0, aksi takdirde 1 değerini verir.

~ : Tek değere işlem yapar. int veya char bir değer içindeki bütün bit değerlerini tersine çevirir (1 ise 0, 0 ise 1 yapar).


/* javaprog.java */
public class javaprog {
  public static void main(String[] args) {

    byte bd1 = 94;                 /* İkili sistem değeri: 0101 1110 */ 
    byte bd2 = 117;                /* İkili sistem değeri: 0111 0101 */

    System.out.println(bd1 & bd2); /* 84   : 0101 0100 */ 
    System.out.println(bd1 | bd2); /* 127  : 0111 1111 */ 
    System.out.println(bd1 ^ bd2); /* 43   : 0010 1011 */ 
    System.out.println(~bd1);      /* -95  : 1010 0001 */ 
    System.out.println(~bd2);      /* -128 : 1000 1010 */ 
  }
}

Komut satırında aşağıdaki satırları yazdığınızda program derlenir ve çalışır:

C:\>javac javaprog.java
C:\>java -Dfile.encoding=Cp857 javaprog
84
127
43
-95
-128

İkili sayı sisteminde, işaretli sayılar için en solda yer alan bit (yüksek bit) sayının işaret bit'i olarak kullanılır. Eğer bu sayı 0 ise sayı mutlaka pozitiftir. Eğer 1 ise sayı pozitif veya negatif olabilir.

Bit kaydırma işlemcileri

İşlemci  Kullanma amacı

   <<    İşaretli sayı sola bit kaydırma
   >>     İşaretli sayı sağa bit kaydırma
   >>>    İşaretsiz sayı sağa bit kaydırma

değişken << int-değer

değişken >> int-değer

değişken >>> int-değer

Bit kaydırma işlemcisilerini kullandığınızda, değişkenin ikili sayı sistemine göre yazılmış olan değerinde yer alan bitler işlemcisinin sağında yer alan int değer kadar sola ya da sağa kayar. Bu durumda, boşalan bitlerin yerine 0 değeri gelir.


/* javaprog.java */
public class javaprog {
  public static void main(String[] args) {

    byte bd1 = 21;                 /* İkili sistem değeri: 0001 0101 */ 

    System.out.println(bd1 << 2);  /* 84 : 0101 0100 */ 
    System.out.println(bd1 >> 2);  /* 5  : 0000 0101 */ 
    System.out.println(bd1 >>> 2); /* 5  : 0000 0101 */ 
  }
}

Komut satırında aşağıdaki satırları yazdığınızda program derlenir ve çalışır:

C:\>javac javaprog.java
C:\>java -Dfile.encoding=Cp857 javaprog
84
5
5

İşlemci öncelikleri

Bir komut satırında birden fazla işlemci yer aldığında, önceliği olan işlemci diğer işlemcilerden önce işlem görür.

Aşağıdaki tabloda en üst satırda yer alan işlemciler en yüksek işlemci önceliğine sahiptir. Satırlar aşağı doğru indikçe işlemci önceliği azalmaktadır. Aynı satırda yer alan işlemciler aynı işlemci özelliğine sahiptir.

expr++ expr--
++expr --expr +expr -expr ~ !
* / %
+ -
<< >> >>>
< > <= >= instanceof
== !=
AND  &
OR  ^
inclusive OR  |
logical AND  &&
logical OR 	||
?:
= += -= *= /= %= &= ^= |= <<= >>= >>>=