Bölüm 3 - Java da Programlama Yapılarının Temelleri 3

Operators

Operatörler değerleri birleştirmek için kullanılırlar. Aşağıda detaylı değiniyoruz.

Arithmetic Operators

Bilinen arirtmek operatörler +,-,*, / bunlar sırasıyla Java'da toplama,çıkarma,çarpma ve bölme olarak kullanılırlar. Buna istinaden bir de % (modulus) dediğimiz bir operatör vardır bu da bölümden kalan değeri verir bize.

double i = 1.0/0;
System.out.println(i); // infinity

int i = 1/0;
System.out.println(i); // hata fırlatır.

Mathematical Functions and Constants

Math class'ı Java'da matematik methodlarını içerir.

Örneğin bir sayının karekökünü almak istersek:

double x = 4;
double y = Math.sqrt(x);
System.out.println(y); // 2.0

Bir sayının a üssünü almak istersek:

double y = Math.pow(x,a);

Bazı trigonometrik methodları da içerir: Math.sin Math.cos Math.tan Math.atan Math.atan2

Üstel methodlar Math.exp Math.log Math.log10

Constants Math.PI Math.E

Eğer ki biz Math prefixini önlemek istersek örneğin sqrt(x) yazmak istersek bunun için import özelliğini şöyle yapmamız gerekir.

import static java.lang.Math.*;
...
...
double x = 4;
double y = sqrt(x);
System.out.println(y); // 2.0

Not : Math sınıfındaki yöntemler, en hızlı performans için bilgisayarın floating-point birimindeki rutinleri kullanır. Tamamen öngörülebilir sonuçlar performanstan daha önemliyse, bunun yerine StrictMath sınıfını kullanmamız gerekir. Bu sınıf, "Freely Distributable Math Library"ndeki (https://netlib.org/fdlibm) algoritmaları uygulayarak tüm platformlarda aynı sonuçları garanti eder.

Random sayı üretmek istersek eğer: Math.random kullanabiliriz.

Math.random()*10; // Math.random bize bir floating-point sayısı döner 0 dahil 1 dahil değil eğer ki biz bir sayı istersek 0 ile 10 arası olsun, bunu yazabiliriz.

Conversions between Numeric Types

Sayılar arasındaki dönüşüm için:

Solid Arrows -> Herhangi bir information kaybı olmadan dönüşüm yapılabileceğini gösterir. Three Dotted Arrows -> Hassasiyet kaybı olarak dönüşüm yapabileceğini gösterir. Örneğin int bir değeri float'a dönüştürürsek hassasiyet kaybı olabilir.

int n = 123456789;
float f = n;
System.out.println(f); // 1.2345679E8

Eğer ki biz binary operatorü ile 2 tane değeri birleştirirsek örneğin (n + f) bu iki operanta hangisi ortak bir tipse operation (toplama) olmadan önce ortak bir tipe dönüşüm yapılır, kurallar:

• Eğer ki operandlardan birisi double ise, diğeri de otomatik olarak double'a dönüştürülür.
• Eğer ki operandlardan birisi float ise diğeri de otomatik olarak float'a dönüştürülür.
• Eğer ki operandlardan birisi long ise diğer tip otomatik olarak long'a dönüştürülür.
• Diğer durumlarda bütün operandlar otomatik olarak int' dönüştürülür.

Casts

Casts demek dönüşüm demek yani bilgi kaybı olsa da olmasada tipler arasında dönüşümü yapmak istersek casts deriz ve bunun için de hedef olarak istediğimiz tip'i parantez içinde belirtiriz.

double x = 9.997;
int nx = (int)x; // 9

Tabi burda bilgi kaybı oldu, eğer ki biz en yakın tam sayıya floating-point'i yuvarlamak istersek şunu da kullanabilirdik:

double x = 9.997;
int nx = (int) Math.round(x); // 10

Assignment

Binary operatorler olan (+,-,*,/,%) gibi operatörleri atamada kısa yol vardır şöyle ki :

x+=4; // bu aşağıdakine eşittir.
x = x+4;

Increment ve Decrement Operators

En yaygın operasyonlardan birisi bir integer tamsayıya 1 atayıp yada çıkarma yapmaktır. Örneğin n++ bizim değişkenimize 1 değerini atarken, n-- ise değişkenimizden 1 çıkarır.

int n = 12;
n++; // n'nin artık değeri 13 oldu.

Bu operatörler bir değişkenin değerini değiştirirler ama sayıların kendisine direkt olarak uygulanamazlar şöyle yapamayız yani 4++ çalışmaz. Bu operatörlerin 2 tipi vardır: birisi postfix, bu operand(n değişkenimiz)dan sonra gelir (n++, n--) birisi prefix, bu operand(n değişkenimiz)den önce gelir (++n, --n). Bu ikisi arasındaki fark ise şudur, eğer ki prefix kullandıysak önce sayı üzerinde işlemi yapar mesela ++n yaptığımızda artık değişkenin değeri 1 artırılır yada azaltılır ve daha sonrasında değişkenin yeni değeri kullanılabilir, ama postfix olursa değişken kullanılı ve daha sonrasında o değişkenin değeri 1 arttırılı yada azaltılır.

int m = 7;
int n = 7;
int a = 2 * ++m; // a 16 olur çünkü m'in değeri 8'dir artık.
int b = 2 * n++; // b 14 olur çünkü n'in değeri 7'dir.

Relational ve boolean Operatorler

Eğer ki eşitliği test etmek istersek == bu operatörü kullanırız. Örneğin

3 == 7

değeri false'dir eğer ki eşit değildir kullanmak istersek != bu operatörü kullanırız. Örneğin

3 != 7

değeri true'dir.

Ayrıca bizim için bazı ilişkileri test edebilmemiz için farklı operatörler vardır.

> (büyüktür)
< (küçüktür)
<= (küçük eşittir)
>= (büyük eşittir)
&& (ve operatörü)
|| (veya operatörü)

Şöyle ki iki ifademizin olduğunuz düşünelim.

expression1 && expression2 
expression1 || expression2

Ve operatörünü matematikteki logic (mantık) dersimizdeki gibi düşünebiliriz ifadelerden ikisi doğru ise doğru, diğer herhangi bir durumda sonuç yanlıştır. Veya operatörünü matematikteki logic(mantık) dersimizdeki gibi düşünebiliriz ifadelerden ikisi yanlış ise yanlış, diğer herhangi bir durumda sonuç doğrudur.

Ayrıca bu operatörler "short circuit" olarak isimlendirilir, eğer ki ilk argument (expression1) değeri belirlenmişse buna göre ikinci ifade (expression2) değerlendirilmez. Şöyle ki;

int y = 5;
boolean x = true || (y++<4);
System.out.println("y:"+y); // y'nin değeri 5 yazar.

Conditional Operator (Şartlı Operatör)

Java bizim için ?: conditional (şartlı) operatör sağlar, ve bunun da temeli boolean değerlere dayalıdır. Syntax şu şekildedir :

condition ? expression1 : expression2

Eğer ki condition doğru ise expression1 değilse expression2 çalışacaktır.

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

Switch Expressions

Eğer 2'den fazla değer arasından seçim yapmanız gerekiyorsa o zaman switch ifadesini (switch expression) kullanabiliriz. (Java 14).

String seasonName = switch(seasonCode){
    case 0 -> "Spring";
    case 1 -> "Summer";
    case 2 -> "Fall";
    case 3 -> "Winter";
    default -> "???";
};

case etiketleri ayrıca string yada enum tipi sabiti olabilirler.

Birden fazla case etiketinin değerlerini tanımlayabiliriz.

int numLetter = switch(seasonName){
    case "Spring","Summer","Winter" -> 6;
    case "Fall" -> 4;
    default -> -1;
};

Eğer ki enum tipi kullanılırsa, enum ismini belirtmeye gerek yoktur şöyle ki; Ayrıca her enum değerini tanımlayacağımız için default'u istersek kaldırabiliriz.

public static void main(String[] args) {
    Size itemSize = Size.EXTRA_LARGE;
    String label = switch(itemSize){
        case SMALL -> "S"; // Burda Size.SMALL yazmamıza gerek yoktur.
        case MEDIUM -> "M";
        case LARGE -> "L";
        case EXTRA_LARGE -> "XL";
    };
}

enum Size {
    SMALL, MEDIUM, LARGE, EXTRA_LARGE
};

Bitwise Operators (Operatörleri)

Eğer ki biz tamsayılar üzerinde bit düzeyinde işlem yapmak istersek bu süreci bitwise operatörler üzerinde yapabiliriz.

& (and) | (or) ^ (xor) ! (not)

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

Biz eğer ki bitwise operatörleri boolean değerler üzerinde kullanırsak boolean değer döner. Şöyle ki bu operatörler && yada || operatörlere benzerler ama bu operatörlerde "short circuit" yoktur. Bu yüzden bu bitwise operatörlerde iki tarafta değerlendirilir yani short circuit olmaz.

Shift Operators

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

>>> unsigned shifting yapar aşağıda güzel basit bir örnek var.

// >> 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