Java Ders - 8 Operatörler

uekapps' Alıntı:

Java:

package dersler;

public class Operatorler {

    public static void main(String[] args) {
        // Basit Atama Operatörü
        /*
         * Basit atama operatörleri kod geliştirmeye ilk başladığımız
         * andan itibaren kullandığımız ve (=) ile gösterilen operatördür.
         * Bu operatöre yazdığımız kodlarda değişkenlere değer atarken
         * kullandığımız operatörü örnek verebiliriz.
         * int intDeger = 1453;
         * String strDeger = "UEKAPPS";
         */
       
        System.out.println("***Aritmetik Operatörler***");
        // Aritmetik Operatörler
        /*
         * Aritmetik operatörler klasik matematiksel işlemleri yapılmasını
         * sağlayan operatörlerdir. +(toplama), -(çıkarma), *(çarpma),
         * (bölme) ve %(mod alma) işlemlerinin yapılmasını sağlayan operatörlerdir.
         */
       
        int deger1 = 66;
        int deger2 = 23;
           
        int toplama = deger1 + deger2;
        int cikarma = deger1 - deger2;
        int carpma = deger1 * deger2;
        int bolme= deger1 / deger2;
        int mod = deger1 % deger2;
       
        System.out.println("Toplama Sonuç: " + toplama);
        System.out.println("Çıkarma Sonuç: " + cikarma);
        System.out.println("Çarpma Sonuç: " + carpma);
        System.out.println("Bölme Sonuç: " + bolme);
        System.out.println("Mod Sonuç: " + mod);
       
        System.out.println("\n");
       
        System.out.println("***Tekli Operatörler***");
        //Tekli Operatörler
        /*
         * Tekli operatörler bir değişkenin sağına veya soluna gelerek tek başına
         * değişkenin değerini değiştirebilen operatörlerdir. +(artı), -(eksi),
         * ++(1 değer arttırma), --(1 değer düşürme), !(boolean tipi tersine çevirme)
         * operatörleri mevcuttur.
         */
       
        int deger = +1;
       
        System.out.println("Değer: " + deger);
       
        // eksiye çevirme
        deger = -deger;
        System.out.println("Değer: " + deger);
       
        // +1 ekle
        deger++;
        System.out.println("Değer: " + deger);
       
        // -1 çıkar
        deger--;
        System.out.println("Değer: " + deger);
       
        boolean durum = true;
       
        System.out.println("Durum: " + durum);
       
        System.out.println("Durum: " + !durum);
       
        System.out.println("\n");
       
        System.out.println("***Eşitlik ve İlişkisel Operatörler***");
        /*
         * Eşitlik ve İlişkisel operatörler iki farklı değişkenin eşitliğini veya
         * arasındaki ilişkiye yönelik farklılıkları ortaya çıkarmaya yarayan operatörlerdir.
         * ==(eşittir), !=(eşit değildir), >(büyüktür), <(küçüktür), >=(büyük eşittir),
         * <=(küçük eşittir) operatörlerinden oluşur.
         */
       
        int sayi1 = 26;
        int sayi2 = 26;
       
        if(sayi1 == sayi2) {
            System.out.println(sayi1 + " eşittir " + sayi2);
        }
       
        int sayi3 = 26;
        int sayi4 = 28;
       
        if(sayi3 != sayi4) {
            System.out.println(sayi3 + " eşit değildir " + sayi4);
        }
       
        if(sayi3 < sayi4) {
            System.out.println(sayi3 + " küçüktür " + sayi4);
        }
       
        if(sayi3 <= sayi4) {
            System.out.println(sayi3 + " küçük veya eşittir " + sayi4);
        }
       
        int sayi5 = 26;
        int sayi6 = 13;
       
        if(sayi5 > sayi6) {
            System.out.println(sayi5 + " büyüktür " + sayi6);
        }
       
        int sayi7 = 15;
        int sayi8 = 15;
       
        if(sayi7 >= sayi8) {
            System.out.println(sayi7 + " büyük veya eşittir " + sayi8);
        }
       
        System.out.println("\n");
       
        System.out.println("***Koşul Operatörleri***");
        /*
         * Koşul operatörleri verilen parametrelerin birden fazla eşitlik veya ilişkisel
         * koşulu sağlayıp sağlamadığını kontrol ederken kullanılır. &&(ve), ||(veya),
         * ?:(üçlü) operatör seçenekleri mevcuttur.
         */
       
        int f1 = 2;
        int f2 = 4;
        String strDeger1 = "uekapps";
        String strDeger2 = "uekapps";
       
        if((f1 < f2) && (strDeger1.contains(strDeger2))) {
            System.out.println(f1 + " küçüktür " + f2
                    + " ve " + strDeger1 + " içinde " + strDeger2 +
                    " String değerini içermektedir.");
        }
       
        if((f1 == f2) || (strDeger1.contains(strDeger2))) {
            System.out.println(f1 + " eşittir " + f2
                    + " veya " + strDeger1 + " içinde " + strDeger2 +
                    " String değerini içermektedir.");
        }
       
        if((f1 < f2) || (strDeger1.equals(strDeger2))) {
            System.out.println(f1 + " küçüktür " + f2
                    + " veya " + strDeger1 + " içinde " + strDeger2 +
                    " String değerini içermektedir.");
        }
       
        int f3 = 23;
       
        // f3 23'e eşitse f4'ün değerini 24 yap değilse 22 yap
        int f4 = (f3 == 23) ? 24 : 22;
        System.out.println("f4: " + f4);
       
        // f3 22'ye eşitse f4'ün değerini 24 yap değilse 22 yap
        f4 = (f3 == 24) ? 24 : 22;
        System.out.println("f4: " + f4);
       
        System.out.println("\n");
       
        System.out.println("***Karşılaştırma Operatörleri***");
        /*
         * Karşılaştırma operaötrü insteadOf olarak bilinmektedir. Bir sınıfı
         * bir sınıfla veya interface ile karşılaştırma yaparken kullanılmaktadır.
         */
        Parent obj1 = new Parent();
        Parent obj2 = new Child();
       
        System.out.println("obj1 instanceof Parent: " + (obj1 instanceof Parent));
        System.out.println("obj1 instanceof Child: " + (obj1 instanceof Child));
        System.out.println("obj1 instanceof MyInterface: " + (obj1 instanceof MyInterface));
       
        System.out.println("obj2 instanceof Parent: " + (obj2 instanceof Parent));
        System.out.println("obj1 instanceof Child: " + (obj2 instanceof Child));
        System.out.println("obj1 instanceof MyInterface: " + (obj2 instanceof MyInterface));
       
       
    }

}

// Nesne yönelimli programlama bilmek gerektirdiği için üzerinde çok durmayacağım.
    class Parent {}
    class Child extends Parent implements MyInterface {}
    interface MyInterface {}

Konsol Çıktısı:
***Aritmetik Operatörler***
Toplama Sonuç: 89
Çıkarma Sonuç: 43
Çarpma Sonuç: 1518
Bölme Sonuç: 2
Mod Sonuç: 20


***Tekli Operatörler***
Değer: 1
Değer: -1
Değer: 0
Değer: -1
Durum: true
Durum: false


***Eşitlik ve İlişkisel Operatörler***
26 eşittir 26
26 eşit değildir 28
26 küçüktür 28
26 küçük veya eşittir 28
26 büyüktür 13
15 büyük veya eşittir 15


***Koşul Operatörler***
2 küçüktür 4 ve uekapps içinde uekapps String değerini içermektedir.
2 eşittir 4 veya uekapps içinde uekapps String değerini içermektedir.
2 küçüktür 4 veya uekapps içinde uekapps String değerini içermektedir.
f4: 24
f4: 22

***Karşılaştırma Operatörleri***
obj1 instanceof Parent: true
obj1 instanceof Child: false
obj1 instanceof MyInterface: false
obj2 instanceof Parent: true
obj1 instanceof Child: true
obj1 instanceof MyInterface: true

Genişletmek için tıkla ...