Minter Coder Hack-Mack-Bi şeyler

08 Eylül

java operatörler derinlemesine operatörler operators shift operatorassignment operator compound operator

Bölüm 1.6: Java Operatörler

Selam gençler; 

Bugün operatörlere giriş yapacağız; Bir programlama dilinde olmazsa olmazlardan, proje geliştirdiğinizde illa ki değindiğiniz kullandığınız sembollerdir. Örneğin; +,-,*,/ gibi...

Şimdi Java'da operatörlere değinelim.

1) Java Unary Operator

Bu operatör türeli basit görevleri yapmak için kullanılır; Örneğin bir sayıyı arttırmak, bir sayıyı azaltmak, sayıyı negatif yada pozitif yapmak veya bir boolean değerinin tersini almak.

 

Unary Operatörleri : Okuyun ve aşağıdaki örneği incleeyin ki pekişsin.

 

+ Bu bir sayıyı toplamak için kullanılır yada String değerleri birleştirmede kullanılır.
- Bu bir sayıyı çıkarmak, bir sayıyı negatif yapmak için kullanılır. 
! Not operatör olarak da bilinir yani bir boolean değerini true ise false, false ise true yapar.
++ Bu bir sayıyı bir arttırmak için kullanılır. Eğer ki sayının önüne gelirse (++sayi buna biz pre-increment) sayıyı bir arttırır ve sayı değişkenine arttırılmış değeri yazar. (sayi++ buna post-increment diyoruz) olursa, sayıyı soldaki değişkene atar ve daha sonra sayi değişkenini bir arttırır.
-- Bu bir sayıyı azaltmak için kullanılır. Eğer ki sayının önüne gelirse (--sayi buna biz pre-decrement) sayıyı bir azaltır ve sayi değişkenine azaltışmış değeri yazar. (sayi-- buna post-decrement diyoruz) olursa, sayi yı soldaki değişkene atar ve daha sonra sayi değişkenini bir azaltır.
~ Bir sayıdaki binary değerlerinde bulunan 0'ları bir 1'leri sıfır yapar. Tüm bitleri değiştirir.

 

public class Main {
    public static void main(String[] args) {
        // + ve - örneği
        int sayi = 40;
        System.out.println("Sayı : "+sayi);    // 40
        System.out.println("Sayı : "+(-sayi)); // -40
        
        // ++ ve -- örneği
        int sayi2 = 40;
        System.out.println("Sayı2 : "+(++sayi2)); // 41
        System.out.println("Sayı2 : "+(sayi2++)); // 41
        System.out.println("Sayı2 : "+(sayi2));   // 42
        System.out.println("Sayı2 : "+(--sayi2)); // 41
        System.out.println("Sayı2 : "+(sayi2--)); // 41
        System.out.println("Sayı2 : "+(sayi2));   // 40
        
        // ~ ve ! örneği
        int sayi3 = 10;                          // Binary karşılığı : 00000000 00000000 00000000 00001010
        System.out.println("Sayı3 : "+(~sayi3)); // Ters çevrilmiş hali : 11111111 11111111 11111111 11110101 (two complement uygula) -11
        
        boolean sonuc = false;
        System.out.println("Sonuc tersi : "+(!sonuc)); // true
        
    }

}

2) Java Arithmetic Operators

Aritmetik Operatörler; matematikte bulunan (toplama,çıkarma,çarpma,bölme, extra olarak modülüs %) işlemler üzerinde kullanılan operatörlerdir. 

 

 

+ Toplama işlemi için kullanılır.
- Çıkarma işlemi için kullanılır.
* Çarpma işlemi için kullanılır.
/ Bölme işlemi için kullanılır.
% Sayıları böler ve kalanı bulmak için kullanılır.

Note : Bütün aritmetik operatörler, Java'da built-in olan 8 tane primitive typesların hepsine, boolean dışında,  uygulanabilir.

public class Main {
    public static void main(String[] args) {
        int x = 5;
        int y = 5;
        System.out.println(x+y); // 10
        System.out.println(x-y); // 0
        System.out.println(x*y); // 25
        System.out.println(x/y); // 1
        System.out.println(x%y); // 0
    }
}

!! Numeric Promotion gibi bir kuralı bilmemiz gerekiyor.

Java'da bazı kesin kurallar vardır

  1. Eğer ki 2 tane değer farklı bir veri tipine sahipse, Java otomatik olarak küçük olan tipi (örneğin short tipini), büyük olanın tipine yükseltecektir (int).
  2. Eğer ki 2 değerden bir tanesi sayısal ve diğeri de kayan sayı (floating-point) ise sayısal yani tam sayı olan değeri floating-point türüne( örneğin double) promote edecek yani yükseltecektir.
  3. Daha küçük veri tipine sahip olanlar, "byte,short,ve char", herhangi bir aritmetik operatörle kullanıldıkları zaman öncelikle otomatik olarak int tipine yükseltilirler.
  4. Bütün yükseltme süreçleri bittikten sonra ve bütün değerler artık aynı tipe sahip olduktan sonra sonuç da aynı tipe sahip olacaktır.

Örnekler

  • Bu örnekte x+y'nin tipi nedir ?
public class Main {
    public static void main(String[] args) {
        int x = 1;
        long y = 33;
        System.out.println(x+y); 
        Object result = x+y;
        System.out.println(result.getClass().getTypeName());
    }
}

Öncelikle ilk kuralımızı taip edelim bir değerimiz long ve diğeri int, long tipi kapsadığı değer açısından int'den büyük olduğu için , int (x) otomatikman long'a yükseltilecek ve daha sonrasında sonuçta long olacaktır. 

  • Bu örnekte x+y'nin tipi nedir ?
public class Main {

    public static void main(String[] args) {
        double x = 39.21;
        float y = 2.1;
        System.out.println(x + y);
    }
}

Şimdi görüldüğü üzere x'in tipi double ve y'nin tipi float olduğu için float'ı double'a promote edip sonra sonuç verilecek düşünebilirsiniz YANLIŞ! Çünkü bu biraz trick soru, floating-point sayılarında biz ne demiştik default olarak bütün sayılar double'dır ve float değildir eğer ki float istiyorsak sonuna ya "f" yada "F" bırakmamız lazım işte bu yüzden y'de bunlar olmadığı için compiler derlemeyecektir.

  • Bu örnekte x/y'nin tipi nedir ?
public class Main {
    public static void main(String[] args) {
        short x = 10;
        short y = 3;
        System.out.println(x/y);
        
        Object result = x/y;
        System.out.println(result.getClass().getName());
    }
}

Bu örnekte bizim 3.kuralımızı uygulamamız gerek , x ve y otomatikman kullanılmadan önce int tipine promote edilecek ve sonuç da int tipinde olacaktır.

  • Bu örnekte x*y/z tipi nedir ?
public class Main {
    public static void main(String[] args) {
        short x = 14;
        float y = 13;
        double z = 30;
        System.out.println(x*y/z);
        
        Object result = x*y/z;
        System.out.println(result.getClass().getName());
    }
}

Şimdi bütün kuralları gözden geçirmek adına tek tek değinelim. Öncelikle x değerimiz short olduğu için otomatikman binary arithmetic operatörüyle kullanıldığı için int'e promote edilecektir. Daha sonrasında x değeri y ile çarpıldığı için floating-point olduğundan dolayı x değeri float'a promote edilecek ve sonucunda x*y otomatikman double'a yükseltilecek ve z ile bölüm işlemi gerçekleştirilecektir bu yüzden sonuç tipi double.

3) Java Shift Operators

Shift operatörlerindeki ana amaç bitlerle oynamaktır bu sayede bitleri ya sağa yada istediğimiz şekilde sola doğru kaydırma işlemini yapabiliriz.

 

Left Shift Operator

public class Main {
    public static void main(String[] args) {
        System.out.println(10<<2); // 10*2^2
        System.out.println(10<<3); // 10*2^3
        System.out.println(20<<2); // 20*2^2
        System.out.println(15<<4); // 15*2^4
    }
}

Right Shift Operator

public class Main {
    public static void main(String[] args) {
        System.out.println(10>>2); // 10/2^2=2
        System.out.println(20>>2); // 20/2^2=5
        System.out.println(20>>3); // 20/2^3=2
    }
}

>> vs >>> (Unsigned Shift)

public class Main {
    public static void main(String[] args) {
        // >> ve >>> aynı çalışır    
        System.out.println(20>>2); // 5
        System.out.println(20>>>2); // 5
        // For negative number, >>> changes parity bit (MSB) to 0    
        System.out.println(-20>>2); // -5
        System.out.println(-20>>>2); // 1073741819
    }
}

4) Java Relational Operators

< (Küçüktür Operatör) Bir değerin diğerinden küçük olup olmadığını kontrol etmek için kullanırız.
> (Büyüktür Operatör) Bir değerin diğerinden büyük olup olmadığını kontrol etmek için kullanırız.
<= (Küçük ve Eşittir Operatör) Bir değerin diğerinden küçük ve eşit olup olmadığını kontrol etmek için kullanırız.
>= (Büyük yada Eşittir Operatör) Bir değerin diğerinden büyük ve eşit olup olmadığını kontrol etmek için kullanırız.
== (Eşit midir operatör) Bir değerin diğerine eşit olup olmadığını kontrol etmek için kullanırız.
!= (Eşit değil midir operatör) Bir değerin diğerine eşit olmadığını kontrol eder.

 

public class Main {
    public static void main(String[] args) {
        int x = 10,y = 20, z = 10;
        System.out.println(x<y); // true
        System.out.println(x<=y); // true
        System.out.println(x>=z); // true
        System.out.println(x>z); // false
        System.out.println(x==y); // false
        System.out.println(x!=y); // true
    }
}

5 ) Java Logical Operators (Bitwise Operators)

Logical Operators (&,^,|), numeric yada boolean veri tiplerine uygulanır. Eğer ki boolean tiplere uygulanırsa logical operators olarak bilinirken, numeric (sayısal) veri tiplerine uygulanırsa eğer bitwise operatörler olarak bilinir.

& (And) bu operatörde eğer ki iki tarafta sadece true ise sonuç true

| (Inclusive Or) bu operatörde sadece iki tarafta false ise sonuç false

^ (Exclusive Or) bu operatörde sadece iki tarafta farklı ise sonuç true.

public class Main {
    public static void main(String[] args) {
        int x = 10; // 1010
        int y = 5; // 0101
        
        // x|y = 1010|0101 = 1111 -> sonuç 15
        // x&y = 1010|0101 = 0000 -> sonuç 0
        // x^y = 1010|0101 = 0101 -> sonuç 5
        System.out.println("x|y = "+(x|y));
        System.out.println("x&y = "+(x&y));
        System.out.println("x^y = "+(x^y));
    }
}

6) Java Conditional Operators

Conditional Operators (&&,||) bunlar sıklıkla short-circuit ( kısa-devre ) operatörleri olarak da bilinirler örneğin:

boolean x = true || (y<4);

Burda sol tarafın true yani doğru olduğunu bildiğimizden dolayı artık sağ tarafı yani "(y<4)" kısmını tekrardan değerlendirmeye gerek yoktur.

Soru : 

public class Main {
    public static void main(String[] args) {
        int x = 6;
        boolean y = (x >= 6) || (++x <= 7);
        System.out.println("x : "+x);
    }
}

Burda önemli tricklerden birisi sol taraf "x => 6" true olduğu için sağ tarafı değerlendirmeye almaz yanı kısa devre olur bu yüzden direkt olarak x'in değerini çıktı olarak 6 basar.

7) Java Ternary Operator

if-then-else ifadesinin tek satırlık halidir ve Java da çok fazla kullanırız.

Kısaca fotoğrafta şu yazar eğer ki Condition kısmı doğru ise ValueIfTrue değeri atanır yanlış ise ValueIfFalse atanır.

public class Main {
    public static void main(String[] args) {
        int x = 2;
        int y = 3;
        
        // y x'den büyük ise x değil ise y
        int min = (x<y) ? x : y;
        System.out.println("Min : "+min); // 2
    }
}

8) Java Assignment Operators

Atama operatörleri sağdaki değişkenin değerini soldaki değişkene atamak, yada arttırıp,azaltıp atama yapmak için kullanılır.

Tabi sağdaki değişken ile soldaki değişkenin tipleri aynı olmak zorundadır yoksa compiler hata verir. 2 tip atama operatörü vardır :

  1. Simple Assignment Operator (=) matematikten bildiğimiz = (eşittir) operatörü.
  2. Compound Assignment Operators : =(eşittir) operatörü ile birlikte kullanılırlar yani +,-,* ve / ile birlikte kullanılır.

 

Simple Assignment Operator (=) Eşittir operatörüdür. Sağdaki değeri soldaki değişkene atamayı yapar.
Compound Assignment Operator (+=) Bu operatör soldaki değişkenin değeriyle sağdaki değişkenin değerini toplayıp soldaki değişkene atar.
Compound Assignment Operator (-=) Bu operatör soldaki değişkenin değeriyle sağdaki değişkenin değerini çıkarıp soldaki değişkene atar.
Compound Assignment Operator (*=) Bu operatör soldaki değişkenin değeriyle sağdaki değişkenin değerini çarpıp soldaki değişkene atamayı yapar.
Compound Assignment Operator (/=) Bu operatör soldaki değişkenin değeriyle sağdaki değişkenin değerini bölüp sonucu soldaki değişkene atar.
Compound Assignment Operator(%=) Bu operatör soldaki değişkenin değerini sağdaki değişkene bölüp kalan sonucu soldaki değişkene atamayı yapar.

 

public class Main {
    public static void main(String[] args) {
       int x = 2 , z=3; // simple assignment operator
       x = x*z; // simple assignment operator
       x *= z; // compound assignment operator yukarıdakine eşittir
    }
}

 

Şimdi size bir örnek ve bir de trick question soracağım.

 

public class Main {
    public static void main(String[] args) {
        int x = 2, y = 3;
        x += y; // 2+3'ü toplayıp x'e atar. x = 5
        System.out.println("x = " + x);
        x *= y; // 5*3'ü çarpıp x'e atar. x = 15
        System.out.println("x = " + x);
        x -= y; // 15-3'ü çıkarıp x'e atar. x = 12
        System.out.println("x = " + x);
        x /= y; // 12/3 yapıp x'e atar. x = 4
        System.out.println("x = " + x);
        x %= y; // 4%3 (4'ü 3'e böler ve kalanı x'e atar.) x = 1
        System.out.println("x = " + x);
    }
}

Trick question : Şimdi aşağıdaki kod neden derlenmez ?

public class Main {
    public static void main(String[] args) {
        long x = 10;
        int y = 5;
        y = y*x; // Derlemez
    }
}

 

Bu örnekte "y = y*x" kod satırının derlenmemesinin ana sebebi, çünkü compiler y*x yerinde y'yi öncelikle long'a numeric composition yapıyor yani long tipine yükselip sonra x ile çarpıyor ve sonucunu y'ye atıyor sonuç tipi long bu yüzden long tipini int tipine atamayız.

 

!!!! Compound assignment operatör ise şöyle yapar öncelikle y'yi long'a yükseltecek ve daha sonra iki değeri çarpıp sonucu int'e dönüştürüp y'ye atamasını yapacak.

public class Main {
    public static void main(String[] args) {
        long x = 10;
        int y = 5;
        // y = y*x; // Derlemez
        y *= x;
    }
}