Operatörler – II

Daha önceki yazıda aritmetik ve ilişkisel operatörleri incelemiştirk. Bu yazımızda da javadaki operatörleri incelemeye devam edeceğiz.

Önceki yazıdan kalan değişkenlerimizi tekrar hatırlayalım. Ancak bu defa değerleriyle biraz oynayalım. Pratiğimizi ilerletmek için değişkenleri javada tanımladığımız gibi yazacağım.

int a = 5;
int b = 15;
int c = 0;

Mantıksal operatörler genelde birden fazla durumun bir arada olumlu veya olumsuz olarak gerçekleşmesini denetlemek için kullanılır. Bunu günlük hayata benzetirsek; “Apartmana postacı dışında kimse girmiş mi?” sorusuna cevap ararken şu iki duruma bakarsınız:

  • Apartmana kimse girdi mi?
  • Önceki sorunun cevabı evet ise apartmana giren kişi(ler) postacı mıydı?

Görüldüğü üzere apartmana giren kişinin varlığı durumu anlamlandırmaya yetmiyor. Bir de o kişinin mesleğini denetlemek istiyoruz.

Mantıksal operatörleri kullanabilmemiz için değişkenlerimizin tipini değiştireceğim. Değişkenlerimizi doğru (true) veya yanlış (false) değerlerini taşıyabilen boolean tipinde yeniden tanımlıyoruz. Eğer int tipteki değişkenleri kullanmaya devam etseydiniz derleyiciniz size bunu yapamayacağınıza dair uyarı verirdi.

boolean a = true;
boolean b = true;
boolean c = false;

Şimdi de mantıksal operatörlerimizin neler olduğuna bakalım.

OperatörTanımİşlem -> Sonuç
&& (ve)Her iki tarafındaki ifade 0’dan(false) farklı ise true döner.a && b -> true
a && c ->false
|| (veya)Bir tarafındaki ifade 0’dan(false) farklı ise true döner.a || b -> true
a || c -> true
! (değilse)Mantıksal operatörün sonucunu terse çevirir!(a && b) -> false
!(a && c) -> true

Yine başka bir sınıf daha yazıp bu operatörleri burada deneyelim.

public class MantiksalOperator {

   public static void main(String args[]) {
      boolean a = true;
      boolean b = true;
      boolean c = false;

      System.out.println("a && b = " + (a&&b));
      System.out.println("a && c = " + (a&&c));
      System.out.println("a || b = " + (a||b) );
      System.out.println("a || c = " + (a||c) );
      System.out.println("!(a && b) = " + !(a && b));
      System.out.println("!(a && c) = " + !(a && c));
   }
}

Çıktı:

a && b = true
a && c = false
a || b = true
a || c = true
!(a && b) = false
!(a && c) = true

Elbette ki atama operatörleri de mevcuttur. Java her şeyi baştan tanımlayıp sonsuza kadar kullanmamız gereken bir dil değildir. Yani bir değişkenin değerini sonradan değiştirmemiz de mümkündür. Bir değişkenin değerinin nasıl değiştirilemez hale getirileceğini de ayrıca ilerideki yazılarda işleyeceğiz. Peki bir değişkene ne tarz atama işlemleri yapabiliriz? Aşağıdaki tabloda atama operatörlerini görebilirsiniz.

Önce değişkenlerimizi tekrar tanımlayalım.

int a = 5;
int b = 15;
int c = 10;
OperatörTanımİşlem -> Sonuç
=Basit atama operatörü. Sağdaki değeri soldakine atar.c=a+b -> c=20
+=Soldaki değere sağdakini ekler ve sonucu soldakine atar.c+=a -> c=15
-=Soldaki değerden sağdakini çıkarır ve sonucu soldakine atar.c -= a -> c=5
*=Soldaki değerle sağdakini çarpar ve sonucu soldakine atar.c *= a -> c=50
/=Soldaki değeri sağdakine böler ve sonucu soldakine atar.c /= a -> c=2

Her defasında olduğu gibi yeni bir sınıf yaratıyoruz. Ancak bu defa işlemlerde dikkatinizi çeken bir nokta olabilir. Koda bakarsanız her işlem öncesi c değişkenine tekrar tekrar atama yaptığımızı göreceksiniz. Bunun sebebi c değişkenin bir önceki işlemde manipüle edilmesidir. Kafa karışıklı yaratmaması adına her adımda tekrar c değişkeninin değerini 10’a eşitliyorum ki yukarıda verdiğimiz tabloyla uyumlu olsun. a ve b değişkenlerinin değerlerini manipüle etmediğimizden onlarla ilgili olarak sadece en başta yapılan atama işlemlerini göreceksiniz.

public class Op {

    public static void main(String args[]) {
        int a = 5;
        int b = 15;
        int c = 10;

        c = a + b;
        System.out.println("c = a + b = " + c );

        c = 10;
        c += a ;
        System.out.println("c += a  = " + c );

        c = 10;
        c -= a ;
        System.out.println("c -= a = " + c );

        c = 10;
        c *= a ;
        System.out.println("c *= a = " + c );

        c = 10;
        c /= a ;
        System.out.println("c /= a = " + c );

    }
}

Çıktı:

c = a + b = 20
c += a = 15
c -= a = 5
c *= a = 50
c /= a = 2

Javada en çok kullanılan operatörlere Operatörler – I ve Operatörler – II yazımızla değinmiş bulunuyoruz. Bitwise operatörler gibi daha farklı operatörlere ise değinmeyeceğiz. Temel java için şu ana kadar değindiğimiz operatörlerin yeni başlayanlar için yeterli olacağını düşünüyorum. Bir sonraki konu başlığında görüşmek üzere.

Operatörler – I

Operatörler, programlama dillerinde çeşitli işlemleri gerçekleştirmek üzere kullanılan işaretlerler veya ifadelerdir. Javada da değişkenleri ve değerleri denetlemek, kıyaslamak veya daha farklı amaçlara hizmet etmek üzere kullanılan çeşitli operatörler bulunmaktadır.

Aritmetik operatörleri konunun başlangıcı olarak alabiliriz. Java artırma, toplama, mod alma gibi işlemleri yapabilen operatörlere sahiptir. Aşağıdaki tabloda bu operatörleri bulabilirsiniz.

Bu tabloyu daha anlamlı hale getirmek için 2 adet int değişken düşünebiliriz. Değişken a ve değişken b sırasıyla 5 ve 15 değerlerini taşıyor olsun. Bu bilgiye istinaden aritmetik operatörlere göz atalım.

OperatörTanımİşlem -> Sonuç
+ (Toplama)Sağındaki ve solundaki sayıyı toplar.a+b -> 20
– (Çıkarma)Sağındaki sayıyı soldakinden çıkarıra-b -> -10
* (Çarpma)Sağındaki ve solundaki sayıyı çarpara*b -> 75
/ (Bölme)Solundaki sayıyı sağındaki sayıya bölerb/a -> 3
% (Mod alma)Verilen sayının modunu alır ve kalanı döner.b%a -> 0
++ (Artırma)Değişkenin değerini 1 artırır.a++ -> 6
— (Azaltma)Değişkenin değerini 1 azaltır.b– -> 14

Şimdi bu operatörleri bir de uygulamalı olarak görelim. Aşağıda bir java sınıfı görmektesiniz. Bu sınıfı isterseniz merhaba dünya örneğindeki gibi yeni bir proje oluşturarak, o projenin içerisinde oluşturabilir ve çalıştırabilirsiniz. İsterseniz merhaba dünya projenizde yeni bir sınıf oluşturup testinizi buradan yapabilirsiniz.

public class AritmetikOperator {

   public static void main(String args[]) {
      int a = 5;
      int b = 15;

      System.out.println("a + b = " + (a + b) );
      System.out.println("a - b = " + (a - b) );
      System.out.println("a * b = " + (a * b) );
      System.out.println("b / a = " + (b / a) );
      System.out.println("b % a = " + (b % a) );
      System.out.println("c % a = " + (c % a) );
      System.out.println("a++   = " +  (a++) );
      System.out.println("b--   = " +  (a--) );

   }
}

Çıktı:

a + b = 20 
a - b = -10
a * b = 75
b / a = 3
b % a = 0
a++ = 6
b-- = 14

Aritmetik operatörlerin yanısıra ilişkisel operatörler de javada mevcuttur. Bunlar daha çok iki değişken veya değer arasındaki kıyaslama için kullanılır. Aritmetik operatörlerdeki a ve b değişkenlerimizi elimizde tutarak ilişkisel operatörlere de göz atalım. Bir de c değişkenini ekleyelim ve bu değişkenin değeri 5 olsun.

OperatörTanımİşlem -> Sonuç
== (eşitlik)İki tarafındaki değeri karşılaştırır ve eşit ise true (doğru) döner.a==b -> false
!= (eşitsizlik)İki tarafındaki değeri karşılaştırır ve eşit ise false (yanlış) döner. Eşit değilse true döner.a!=b -> true
a!=c -> false
> (büyüktür)Solundaki sayı sağındakinden büyükse true döner.a>b -> true
a>c -> false
< (küçüktür)Solundaki sayı sağındakinden küçükse true döner.a<b -> true
a<c -> false
>= (büyük eşit)Solundaki sayı sağındakinden büyük veya eşitse true döner.a>=b -> false
a>=c ->true
<= (küçük eşit)Solundaki sayı sağındakinden küçük veya eşitse true döner.a<=b -> true
a<=c ->true

AritmetikOperator sınıfımızın yanına şimdi bir sınıf daha yaratalım ve iilişkisel operatörleri de test edelim.

public class Test {

   public static void main(String args[]) {
      int a = 5;
      int b = 15;
      int c = 5;

      System.out.println("a == b = " + (a == b) );
      System.out.println("a != b = " + (a != b) );
      System.out.println("a != c = " + (a != c) );
      System.out.println("a > b = " + (a > b) );
      System.out.println("a > c = " + (a > c) );
      System.out.println("a < b = " + (a < b) );
      System.out.println("a < c = " + (a < c) );
      System.out.println("a >= b = " + (a >= b) );
      System.out.println("a >= c = " + (a >= c) );
      System.out.println("a <= b = " + (a <= b) );
      System.out.println("a <= c = " + (a <= c) );
   }
}

Çıktı:

a == b = false 
a != b = true
a != c = false
a > b = false
a > c = false
a < b = true
a < c = true
a >= b = false
a >= c = true
a <= b = true
a <= c = true

Operatörlerin ilk kısmını bitirdik. Değneceğimiz diğer operatörlere Operatörler – II yazısından ulaşabilirsiniz.