Ana içeriğe atla

Java Deger Atama ve Oparatörler

Uygulamanın akışını nasıl yönlendirebilirim ?

Javada oluşturulan ilkel tipleri , objeleri yönlendirmek veya değiştirmek için operatörleri kullanırız. Java , bu operatörleri C ve C++ dan miras almışdır ama bu miras üzerine kendiside birçok şey katmıştır.

Atamalar

Değer atamalar sağ tarafdaki değerin -ki bu değer bir sabit değer olabilir veya değişken olabilir , sol tarafdaki değişkene atanması ile gercekleşir . Sağ tarafdaki değişkenin bir fiziksel bir boşluğa sahip olması gerekir .
gösterim-1
         int a ;
     a=4 ; // dogru bir atama
     4=a ; // yanlış bir atama

İlkel tiplerde atama

Atama işlemi ilkel (primitive) tipler için basittir . ilkel (primitive) tipler değerleri direk kendileri tuttukları (herhangi bir objeyi referans etmediklerinden) için , bir ilkel tipi diğerine atadığımız zaman değişen sadece içelikler olur .
gösterim-2
    int a ;
  int b ;
  a=4 ;
  b=5 ;
  a=b ;
Sonuc olarak a ve b değişkenlerinin değerleri aşağıdaki gibi olur.
a=5  , b=5

Objelerde atama

Objelerde atamalar biraz daha karmaşıktır.Sonuç olarak objeleri yönetmek için referansları kullanırız ve eğer bir atama işlemi olacaksa bu referansların ayni objeyi göstermesi anlamına gelir.Objelerin birbirleri üzerlerine kopyalanması gibi bişey söz konusu değildir.

ör-obje-atama
class Sayi
{
  int i;
}
public class ObjelerdeAtama
{
  public static void main(String[] args) {
    Sayi s1 = new Sayi();
    Sayi s2 = new Sayi();
    s1.i = 9;
    s2.i = 47;
    System.out.println("1: s1.i: " + s1.i +", s2.i: " + s2.i);
    s1 = s2; // referanslar kopyalaniyor .. objeler değil
    System.out.println("2: s1.i: " + s1.i +", s2.i: " + s2.i);
    s1.i = 27;
    System.out.println("3: s1.i: " + s1.i +", s2.i: " + s2.i);
  }
}

Baştan sırayla açıklıyalım ; ilk önce 2 adet Sayi objesi oluşturduk ve bu objelere Sayi sınıfı türünden 2 adet referans(veya değişken diyin fark etmez) bağlandık , s1 ve s2. Bu referanslar artık 2 ayrı Sayi objesini göstermektedirler.
Daha sonra s1 referansının işaret ettği Sayi objesinin i değişkenine 9 sayısını atadık.Aynı şekilde s2 referansının işeret ettiği Sayi objesinin i değişkenine 47 sayısını atadık.Yaptığımız işlemlerin düzgün olup olmadıklarını görmek için bunları ekrana bastırdığımızda aşağıdaki görüntü ile karşılaşıyoruz.
      1: s1.i: 9, s2.i: 47
Şu ana kadar bir sorun olmadığı anlayıp , rahatladıktan sonra önemli hamleyi yapıyoruz .
gösterim-3
      s1 = s2 ;  // referanslar kopyalaniyor .. objeler değil
Burada gerçekte olan şudur, s1 artık s2 nin işaret etiği objeyi göstermektedir. Aşağıdaki şekil, örneğin anlanmasında yardımcı olabilir. Kısım-1 durumun , s2'nin s1'e atanmadan önceki halini göstermektedir. Kısım-2 ise s2'nin s1'e atandıktan sonraki halini göstermektedir.

şekil -1
Kaldığımız yerden devam edelim , şimdi s1 ve s2 nin değerlerini ekrana bastırdığımızda , s1.i ve s2.i değişkenlerinin aynı değerleri taşıdığını görürüz,
  2: s1.i: 47, s2.i: 47
sebebi ise bu iki referansın (s1 ve s2 ) aynı objeyi göstermeleridir. Son olarakta s1 in işaret ettiği objenin i değişkenin değerini değiştirip sonrada değerleri ekrana bastıralım. Görüldüğü üzere s2.i değişkeninde değeri değişmiş oldu. Sebebi ise yine s1 ve s2 referanlarının aynı objeyi göstermeleridir.
  3: s1.i: 27, s2.i: 27
Soru , s1 referansının daha evvelden işaret etmiş olduğu Sayi objesine ne olacaktır ? Cevap vermek için henüz erken ama yinede söyliyelim , bu obje kullanılmayacağından dolayı çöp haline gelecektir ve çöp toplayıcısı (Garbage Collector) tarafından temizlenecektir . Görüldüğü üzere kodu yazan kişinin objelerin temizliği konusunda yersiz bir endişeye kapılmasına gerek yoktur. Çöp toplayıcısını (Garbage Collector) ilerleyen bölümlerde daha detaylı bir şekilde inceliyeceğiz.
Bu örneğimizde s1 referansının s2'nin işaret etmiş olduğu objeyi göstermesini istemeyip ,sadece s2.i değişken değerinin s1.i değişken değerine atanmasını istemiş olsaydık , aşağıdaki gösterimi yazmış olmamız yetecekti.

gösterim-4
    s1.i = s2.i;
Böylece her iki referansımızda ayrı ayrı Sayi objelerini göstermiş olacaklardır. Bu durumda ortada kullanılmayan obje olmayacaktır.
Deyinmek istediğim diğer bir husus ise bir fiziksel dosya içersinde iki sınıf (class) tanımını yazabilmiş olmamızdır.Peki bu fiziksel dosyanın ismi Sayi.java mi olmasi gerekli yoksa ObjelerdeAtama.java mı olması gerekli ? Cevap fiziksel dosyanın ismimin ObjelerdeAtama.java olacağıdır , sebebi ise javada fiziksel dosyaların ismi her zaman public sınıf (class) isimleri ile bire bir (küçük büyük harf ayrımı olduğunu unutmayın - Case Sensitive) aynı olma gerekliliğidir.

Metod Cağrımları

Metodların parametere kabul ettiklerini ve bu parameteri alaraktan işlemler gerçekleştirdiğini biliyoruz . Peki metodlara parametre olarak ne gitmekte , objenin kendisi mi ? yoksa objenin referansı mı ?
ör-referans-1
class Harf
{
  char c;
}
public class ObjePaslama
{
  static void f(Harf h) { 
    h.c = 'z';
  }  
  public static void main(String[] args) { 
    Harf x = new Harf(); // Harf objesini yaratiyoruz 
    x.c = 'a'; // Harf objesinin c degiskenine deger atadik 
    System.out.println("1: x.c: " + x.c); 
    f(x); 
    /* Harf objesinin referansini f() methoduna gecirdik 
    Burada objenin methoda gonderilmesi soz konusu degildir 
    Method a gonderilen Harf objesinin referansidir. */
    System.out.println("2: x.c: " + x.c); 
  }
}
Yukarıdaki örneğimizde , iki adet sınıfımız bulunmakta , Harf Sınıfı ve ObjePaslama Sınıfımız. ObjePaslama sınıfımız public olduğu için fiziksel dosyanın ismi ObjePaslama.java dır. Bu ön bilgiden sonra programımızı açıklıyalım ; ilk olarak Harf objemizi oluşturuyoruz ve Harf objemizin char tipinde olan c değişkenine 'a' krakterini atıyoruz. Yaptığımız işlemi bir güzel ekrana bastırdıktan sonra Harf objesini işaret eden x referansını f() metoduna gönderiyoruz. İşler biraz karıştı gibi,devam edelim, sonra f() metodunun içersinde daha evvelden oluşturduğumuz Harf objesinin char tipinde olan c değişkenine 'z' krakterini atıyoruz.Bilgileri tekraradan ekrana bastırdığımızda görüyoruz ki Harf objesinin char tipinde olan c değişkeni değişmiş. Burada olan kesinlikle Harf objesinin yer değiştirmesi değildir. Harf objesinin bellekteki yeri her zaman sabittir. Olan olay sadece f() metodunun içersinde Harf objesine kısa süreli olarak başka bir Harf tipindeki bir referansın işaret etmiş olmasıdır (böylece Harf Objesine toplam iki referans işaret etmiş olmaktadır biri x diğeri ise h ). Metodun sonuna gelindiğinde ise bu referansın( h referansı) geçerlilik alanı bitmiştir ama bu kısa süreli işlemde Harf objesinin char tipinde olan c değişkeni değişmiştir.Bu konuyu ilerleyen bölümlerde daha detaylı bir şekilde inceliyeceğiz.

Matematiksel operatörler

Operatörler bir veya daha fazla değişken üzerinden işlemler gercekleştirirler.İşlem gerçekleştirmek için tek bir değişkene ihtiyaç duyan operatörlere tekli operatör (unary operator) , çift değişkene ihtiyac duyan operatörlere ikili operatör (binary operator) ve son olarakta işlem gerçekleştirmek için üç adet değişkene ihtiyaç duyan operatörlere ise üçlü operatör (ternary operator) denir.
Tekli operatörler hem ön ek(prefix) hemde son ek(postfix) işlemlerini desteklerler.
Ön ek dediğimizden kasıt operatörün değişkenden önce gelmesi anlamındadır.
operatör değişken //ön ek ifadesi
Son ek işlemlerine örnek olarak
değişken operatör // son ek ifadesi
Tüm ikili operatörler ara ek (infix) işlemlerinde kullanılırlar .
değişken1 operatör değişken2 //ara ek
Üçlü operatörlerde ara ek (infix) işlemlerde kullanılır. Javada üçlü operatörler tek bir tanedir.
değişken1 ? değişken2 : değişken3 //ara ek

Aritmetik Operatörler

Aritmetik operatörler değişkenlerdeki değeri alır ve bu değerin sonucunda yeni değerler üretirler. Java programlama dili kayan-noktalı ve tam sayılar için birçok aritmetik işlemi destekler. Bu işlemler (+) toplama operatörü , (-) çıkartma operatörü, (*) çarpma operatörü , (/) bölme operatörü ve son olarakta (%) modülo dur.

Operatör
Kullanılış
Açıklama
 +
  değişken1 + değişken2
 değişken1 ile değişken2 yi toplar
  - 
  değişken1 -  değişken2 
 değişken1 ile değişken2 yi çıkarır
 *
  değişken1 *  değişken2
 değişken1 ile değişken2 yi çarpar
 /
  değişken1 /  değişken2
 değişken1 ,değişken2 tarafından bölünür
%
  değişken1 %  değişken2
 değişken1 in değişken2 tarafından bölümünden kalan hesaplanır.
tablo-1
İsterseniz anlattıklarımızı bir java uygulaması üzerinde görelim.
ör-aritmatik-1

public class AritmetikOrnek {
 
   public static void main(String[] args) {
      //Degisken degerleri
      int a = 57;
      int b = 42;
      double c = 27.475;
      double d = 7.22;
      System.out.println("Degisken Degerleri...");
      System.out.println(" a = " + a);
      System.out.println(" b = " + b);
      System.out.println(" c = " + c);
      System.out.println(" d = " + d);
 
      //Sayilari topluyoruz
      System.out.println("Toplama...");
      System.out.println(" a + b = " + (a + b));
      System.out.println(" c + d = " + (c + d));
 
      //Sayilari cikartiyoruz
      System.out.println("Cikartma...");
      System.out.println(" a - b = " + (a - b));
      System.out.println(" c - d = " + (c - d));
 
      //Sayilari Carpiyoruz
      System.out.println("Carpma...");
      System.out.println(" a * b = " + (a * b));
      System.out.println(" c * d = " + (c * d));
 
      //Sayilari boluyoruz
      System.out.println("Bolme...");
      System.out.println(" a / b = " + (a / b));
      System.out.println(" c / d = " + (c / d));
 
      //Bolme islemlerinden kalan sayiyi hesapliyoruz
      System.out.println("Kalan sayiyi hesaplama ...");
      System.out.println(" a % b = " + (a % b));
      System.out.println(" c % d = " + (c % d));
 
      //double ve int tiplerini karisik sekilde kullaniyoruz 
      System.out.println("Karisik tipler...");
      System.out.println(" b + d = " + (b + d));
      System.out.println(" a * c = " + (a * c));
  }
}

Uygulamamızın çıktısı aşağıdaki gibidir .
Degisken Degerleri...
a = 57
b = 42
c = 27.475
d = 7.22
Toplama...
a + b = 99
c + d = 34.695
Cikartma...
a - b = 15
c - d = 20.255000000000003
Carpma...
a * b = 2394
c * d = 198.36950000000002
Bolme...
a / b = 1
c / d = 3.805401662049862
Kalan sayiyi hesaplama ...
a % b = 15
c % d = 5.815000000000002
Karisik tipler...
b + d = 49.22
a * c = 1566.075

Yukarıdaki örnekte dikkat edilecek olursa , tamsayı ile kayan noktalı sayıları tekli operatörden geçirirsek sonuç yine kayan noktalı sayı olmaktadır. Bu işlemde tamsayı , otomatik olarak kayan noktalı sayıya çevrilmiş olmaktadır.Aşağıdaki tablo bu otomatik çevrim işlemlerinin tümünü göstermektedir.
Sonuç Veri Tipi
Değişkenlerin Veri Tipleri
    long
 Değişkelerin float veya double tipinden farklı olması ve en az bir değişkenin long tipinde olması 
    int
 Değişkelerin float veya double tipinden farklı olması ve değişkenlerin long tipinden farklı olması
    double
 En az bir değişkenin double tipinde olması
    float
 Değişkenlerin hiçbirinin double tipinde olmaması ve değişkenlerden en az birinin float tipinde olması
tablo-2
+ ve - operatörlerin ikilik(binary) formuna dönüştürme misyonlari da vardir.
Operatör
   Kullanılış Şekli
   Açıklama
     +
  +değişken
Eğer  değişken char, byte veya short tipinde ise int tipine dönüştürür
      -
  -değişken
Değişkenin değerini negatif yapar (-1 ile çarpar).
tablo-3
Anlaşılması açısından ufak bir uygulama örneği verelim
ör-binary-form
public class OperatorTest {
 
    public static void main(String args[] ) {
       char a = 'a' ;
       int b = +a ; //otomatik olarak int ilkel tipine cevrildi
       int c = -b ; // degeri negatif yapti
       System.out.println("a = " + a );
       System.out.println("b = " + b );
       System.out.println("c = " + c );
    }
}

char tipleri ilkel(primitive) tipdir , ve bu tiplere değer atarken tek tırnak içersinde veri atamamız gerekmektedir.Bu örneğimizde bizim girdiğimiz char 'a' dır. Daha sonra + operatörünü kullanarak char değerini int tipine dönüştürüyoruz ve en son olarakta bu int değerini - operatörü ile negatif yapıyoruz . Uygulamanın çıktısı aşağıdaki gibidir .
a = a
b = 97
c = -97
Dönüştürme(Casting) işlemi
Bir ilkel (primitive) tipi diğer bir ilkel tipe dönüştürebilirsiniz, fakat oluşacak değer kayıplarından kodu yazan kişi sorumludur
ör-ilkel-dönüşüm
public class IlkelDonusum {
 
  public static void main(String args[]) {
    int a = 5 ; 
    double b = (double) a ;
 
    double x = 4.15 ;
    int y = (int) x ;
    long z = (long) y ;
 
    System.out.println("b = " + b + " y = " + y + " z = " + z);
  } 
}
Uygulamanın çıktısı
b = 5.0 y = 4 z = 4
String (+) Operatörü
“+” operatörü String tiplerde birleştirme görevi görür. Eğer ifade String ile başlarsa , onu takip eden tiplerde otomatik olarak String objesine dönüştürülür. Otomatik olarak String objesine dönüştürülme sırrını ilerleyen bölümlerde göreceğiz.
ör-otomatik-cevrim
public class OtamatikCevirim {
 
 public static void main(String args[]) {
  int x = 0, y = 1, z = 2;
  System.out.println("Sonuc =" + x + y + z);
 }
}
uygulamanın çıktısı
Sonuc =012
String bir ifadeden sonra gelen tamsayılar görüldüğü üzere toplanmadı, direk String objesine çevrilip ekrana çıktı olarak gönderildiler .

Otomatik arttırım ve azaltım
Java dilinde C dilinde olduğu gibi birçok kısaltmalar vardır . Bu kısaltmalar hayatı bazen daha güzel bazen ise çekilmez kılar. En iyi kısaltmalardan ikisi ise arttırma ve azaltma operatörleridir.
Operatör
Kullanılış Şekli
 Açıklama
  ++
  değişken++
 Önce değişkenin değerini hesaplar sonra değişkenin değerini bir arttırır.
  ++
  ++değişken
 Önce değişkenin değerini arttırır sonra değişkenin değerini hesaplar.
  --
  değişken--
 Önce değişkenin değerini hesaplar sonra değişkenin değerini bir azaltır.
  --
  --değişken
 Önce değişkenin değerini azaltır sonra değişkenin değerini hesaplar.
tablo-4
Bu operatörlerin kullanımının iki çeşit yöntemi vardir . Birincisi ön ek(prefix) -ki bu (--) veya (++) operatörünün , kullanılan değişkenin önüne gelmesi anlamını taşır , diğeri ise son ek'dir (postfix) , bu da (--) veya (++) operatörünün değişkenin sonuna gelmesi anlamına gelir. Peki bu operatörlerin değişkenin başına gelmesi ile sonuna gelmesi arasında ne farklar vardır ?
Mesela (++a veya --a) örneğinde , önce matematiksel toplama veya çıkartma işlemi gerçekleşir daha sonra değer üretilir.Ama (a++ veya a--) durumunda ise önce değer üretilir daha sonra matematiksel toplama veya çıkartma işlemi gerçekleşir. Aşagıdaki ufak program bunu güzel bir şekilde ifade etmektedir.
ör-otomatik-art-azal
public class OtomatikArtveAz {
 
  static void ekranaYaz(String s) { 
   System.out.println(s); 
  }
 
  public static void main(String[] args) {
   int i = 1; 
   ekranaYaz("i : " + i);
   ekranaYaz("++i : " + ++i); // onek arttirim
   ekranaYaz("i++ : " + i++); // sonek -arttirim
   ekranaYaz("i : " + i);
   ekranaYaz("--i : " + --i); // onek-azaltim
   ekranaYaz("i-- : " + i--); // sonek-azaltim
   ekranaYaz("i : " + i);
  } 
} 
Uygulamamız çıktısı aşağıdaki gibidir :
i : 1
++i : 2
i++ : 2
i : 3
--i : 2
i-- : 2
i : 1

İlişkişel Operatörler

İlişkisel operatörler iki değeri karşılaştırarak bu değerler arasındaki mantıksal ilişkiyi hesaplarlar. Örneğin iki değer birbirine eşit değilse ; "==" bu ilişki çercevesinde hesaplanan değer false olacaktır. Aşağıdaki tabloda bu hesaplamalar verilmiştir.
Operatör
Kullanılılş Şekli
 true değeri döner eğer ki........
> 
 değişken1 > değişken2 
 değişken1 , değişken2'den büyükse
>=
 değişken1 >= değişken2
 değişken1 , değişken2'den büyükse veya eşitse
< 
 değişken1 < değişken2
 değişken1 , değişken2'den küçükse
<=
 değişken1 <= değişken2
 değişken1 , değişken2'den küçükse veya eşitse
==
 değişken1 == değişken2
 değişken1 , değişken2'ye eşitse
!=
 değişken1 != değişken2
 değişken1 , değişken2'ye eşit değilse
tablo-5
Yukarıda açıklanan ifadeleri java uygulaması üzerinde anlatırsak ;
ör-iliskisel
public class IliskiselDeneme {
 
  public static void main(String[] args) {
 

//bir kac sayi
int i = 37;
int j = 42;
int k = 42;
System.out.println("Degisken degerleri...");
System.out.println(" i = " + i);
System.out.println(" j = " + j);
System.out.println(" k = " + k);

//Buyuktur
System.out.println("Buyuktur...");
System.out.println(" i > j = " + (i > j)); //false - i , j den kucuktur
System.out.println(" j > i = " + (j > i)); //true - j , i den buyuktur
System.out.println(" k > j = " + (k > j)); //false - k , j 'ye esit

//Buyuktur veya esittir
System.out.println("Buyuktur veya esittir...");
System.out.println(" i >= j = " + (i >= j)); //false - i , j den kucuktur
System.out.println(" j >= i = " + (j >= i)); //true - j , i den buyuktur
System.out.println(" k >= j = " + (k >= j)); //true - k , j 'ye esit

//Kucuktur
System.out.println("Kucuktur...");
System.out.println(" i < j = " + (i < j)); //true - i , j den kucuktur
System.out.println(" j < i = " + (j < i)); //false - j , i den buyuktur
System.out.println(" k < j = " + (k < j)); //false - k , j 'ye esit

//Kucuktur veya esittir
System.out.println("Kucuktur veya esittir...");
System.out.println(" i <= j = " + (i <= j)); //true - i , j den kucuktur
System.out.println(" j <= i = " + (j <= i)); //false - j , i den buyuktur
System.out.println(" k <= j = " + (k <= j)); //true - k , j 'ye esit

//Esittir
System.out.println("Esittir...");
System.out.println(" i == j = " + (i == j)); //false - i , j den kucuktur
System.out.println(" k == j = " + (k == j)); //true - k , j 'ye esit

//Esit degil
System.out.println("Esit degil...");
System.out.println(" i != j = " + (i != j)); //true - i , j den kucuktur
System.out.println(" k != j = " + (k != j)); //false - k , j 'ye esit

}
}

Uygulamamızın çıktısı :
Degisken degerleri...
i = 37
j = 42
k = 42
Buyuktur...
i > j = false
j > i = true
k > j = false
Buyuktur veya esittir...
i >= j = false
j >= i = true
k >= j = true
Kucuktur...
i < j = true
j < i = false
k < j = false
Kucuktur veya esittir...
i <= j = true
j <= i = false
k <= j = true
Equal to...
i == j = false
k == j = true
Not equal to...
i != j = true
k != j = false

Objelerin Karşılaştırılması
Objelerin eşit olup olmadığını (= =) veya (! =) operatörleri ile test edebiliriz ama aklımız biraz karışıcak ..
ör-obje-esitligi
public class Denklik {
public static void main(String[] args)
{
Integer s1 = new Integer(47);
Integer s2 = new Integer(47);
System.out.println(s1 == s2);
System.out.println(s1 != s2);
}
} n1 ve n2 Integer tipinde ve içlerinde 47 değeri var .. gayet temiz ve kolay .
Uygulamamızın çıktısı olarak aşağıdaki değerleri bekliyor olabiliriz
true
falseAma ne yazik ki öyle değil . Nedenini ise şöyle açıklayabiliriz , elimizde iki adet ayrı Integer objesi bulunamaktadır. Bu Integer objelerinin taşıdıkları değerler birbirlerine eşittir ama biz "s1==s2" ifadesi kullanarak şunu demiş olduk "s1 ve s2 referanslarının işaret etmiş oldukları objeler aynı mı ?" cevap tahmin edilebileceği gibi hayırdır yani false dur , s1 ve s2 ayrı Integer objelerini işaret etmektedir , eşit olan tek şey bu iki ayrı objenin içlerinde taşıdıkları 47 değeridir -ki bu eşitliği "s1=s2" ifadesi ile yakalıyamayız. Programımızın çıktısı aşağıdaki gibidir :
false
truePeki yukarıdaki örnekdeki Integer objeleri yerini ilkel tip olan int tipini kullansaydık sonuç nasıl olurdu ?
ör-ilkel
public class IntIcinDenklik {
public static void main(String[] args) {
int s1 = 47;
int s2 = 47;
System.out.println(s1 == s2);
System.out.println(s1 != s2);
}
}Programın çıktısı :
true
falseİlkel (primitive) tipler değerleri direk olarak kendi üzerlerinde taşınıkları için , (==) operatörü s1 ve s2'nin değerlerini karşılaştırdı ve true döndürdü. Aynı şekilde (!=) operatörüde s1 ve s2'nin değerlerini karşılaştırdı ve false döndürdü. Sonuçlar beklediğimiz gibi .
İlişkisel ve koşul operatörlerinin birlikte kullanılması
Karışık karar mekanizmaları üretmek için ilişkisel operatörler ile koşul operatörleri sık olarak birlikte kullanılırlar . Java programlama dilinde toplam 6 adet koşul operatörü bulunur , bunlardan 5 tanesi ikili (binary) operatör , 1 tanesi ise tekli (unary) operatördür. Aşagıdaki tablodaki değişken1 ve değişken2 değerlerinin boolean (mantıksal) değerler içermesi gerekmektedir.
OperatörKullanılılş Şeklitrue değeri döner eğer ki........ && değişken1 && değişken2 Eğer hem değişken1 hemde değişken2 true ise ; değişken2'yi duruma göre hesaplar* || değişken1 || değişken2 değişken1'in veya değişken2'in true olması ; değişken2'yi duruma göre hesaplar* ! ! değişken Eğer değişken false ise & değişken1 & değişken2 Eğer hem değişken1 hemde değişken2 true ise ; değişken1 ve değişken2 her durumda hesaplanır*. | değişken1 | değişken2 değişken1'in veya değişken2'in true olması ; değişken1 ve değişken2 her durumda hesaplanır*. ^ değişken1 ^ değişken2 Eğer değişken1 ve değişken2 birbirlerinden farklı ise; ör: değişken1 true ,değişken2 false ise*tablo-6
Yukarıdaki tablo ile alakalı gösterimleri java uygulaması üzerinde gösterirsek;
ör-java-kosul-op
public class KosulOp {
public static void main( String args[] ) {
int a = 2 ;
int b = 3 ;
int c = 6 ;
int d = 1 ;
/*
(a < b) = bu ifadenin true oldugunu biliyoruz
(c < d) = bu ifadenin false oldugunu biliyoruz
*/
System.out.println(" (a < b) && (c < d) --> " + ( (a < b) && (c < d) ) );
System.out.println(" (a < b) || (c < d) --> " + ( (a < b) || (c < d) ) );
System.out.println(" ! (a < b) --> " + ( ! (a < b) ) );
System.out.println(" (a < b) & (c < d) --> " + ( (a < b) & (c < d) ) );
System.out.println(" (a < b) | (c < d) --> " + ( (a < b) | (c < d) ) );
System.out.println(" (a < b) ^ (c < d) --> " + ( (a < b) ^ (c < d) ) );
}
}
Uygulamamızın çıktısı aşağıdaki gibidir :
(a < b) && (c < d) --> false
(a < b) || (c < d) --> true
! (a < b) --> false
(a < b) & (c < d) --> false
(a < b) | (c < d) --> true
(a < b) ^ (c < d) --> truedurumuna göre hesaplar ibaresinin şu an için anlaşılmadığını biliyorum , if-else koşul ifadesinde yer alan kısa devre bölümünü incelemenizi tavsiye ediyorum .
Kaydırma(Shift) Operatörleri
Kaydırma operatörleri , veri üzerinde bitlerin sağa ve sola kaydırılması suretiyle hesaplamalar yapmamızı sağlar.Aşağıdaki tablo bu operatörlere ait özet bilgiler bulunmaktadır.
Operator Kullanılış Şekli Açıklama >> değişken1 >> değişken2değişken1'in bitlerini değişken2 nin değeri kadar sağa kaydırır. << değişken1 << değişken2değişken1'in bitlerini değişken2 nin değeri kadar sola kaydırır. >>> değişken1 >>> değişken2 değişken1'in bitlerini değişken2 nin değeri kadar sağa kaydırır. (unsigned)tablo-6
Aşağıdaki örneğimiz bu operatörlerin Java uygulamalarında nasıl kullanılacaklarına ait bir fikir verebilir .
ör-bitwise
public class Bitwise {
public static void main( String args[] ) {
int a = 9 ;
System.out.println(" (a >> 1) -->" + (a >> 1) );
System.out.println(" (a >> 2) -->" + (a >> 2) );
System.out.println(" (a << 1) -->" + (a << 1) );
System.out.println(" (a << 2) -->" + (a << 2) );
System.out.println(" (a >>> 2) -->" + (a >>> 2) );
}
}Bu örneğimizde verilen 9 sayısının ikilik düzene cevrilişi aşağıdaki gibidir :
(a >> 1) ifade ile 9 sayısına karşılık olan 1001 bitlerini sağa doğru 1 basamak kaydırıyoruz ; _100 , boş olan yerlere 0 yerleştirdiğimizde ifade tamamlanmış olmaktadır , 0100 , ondalık olarak 4 değerini elde etmiş olduk .
(a >> 2) ifade ile 9 sayısına karşılık olan 1001 bitlerini sağa doğru 2 basamak kaydırıyoruz ; __10 , boş olan yerlere 0 yerleştirdiğimizde ifade tamamlanmış olmaktadır , 0010 , ondalık olarak 2 değerini elde etmiş olduk .
(a << 1) ifade ile 9 sayısına karşılık olan 1001 bitlerini sola doğru 1 basamak kaydırıyoruz ; 1001_ , boş olan yerlere 0 yerleştirdiğimizde ifade tamamlanmış olmaktadır , 10010 , ondalık olarak 18 değerini elde etmiş olduk .
(a << 2) ifade ile 9 sayısına karşılık olan 1001 bitlerini sola doğru 2 basamak kaydırıyoruz ; 1001__ , boş olan yerlere 0 yerleştirdiğimizde ifade tamamlanmış olmaktadır , 100100 , ondalık olarak 36 değerini elde etmiş olduk .
(a >>> 2) ifadenin (a >> 2) ile arasında işlemsel olarak bir fark yoktur , sonuç olarak yine 2 elde ederiz. ">>>" operatörü işaretsiz (unsigned) sağa doğru kaydırım yapar .
Eğer char, byte, veya short tiplerinde kaydırım işlemi yapacaksanız bu tipler ilk önce int tipine dönüştürülürler.Eğer long tipinde kaydırma işlemi gerçekleştiriyorsanız o zaman yine long tipinde bir sonuç elde ederseniz .
Uygulamamızın çıktısı :
(a >> 1) -->4
(a >> 2) -->2
(a << 1) -->18
(a << 2) -->36
(a >>> 2) -->2Aşağıdaki tabloda gösterilen 4 operatör bitler üzerinde mantıksal işlemleri gerçektirmemize olanak tanır.
OperatörKullanılış ŞekliAçıklama &değişken1 & değişken2mantıksal and (VE) |değişken1 | değişken2mantıksal or (VEYA) ^değişken1 ^ değişken2mantıksal xor (ÖZEL VEYA) ~~değişkenmantıksal tamamlamatablo-7
Eğer değişkenler sayı ise yukarıda gösterilen operatörleri kullanarak mantıksal işlemler gerçekleştirebiliriz.
VE (And) işlemi
değişken1 değişken2 Sonuç 000010100111tablo-8
Ve(And) işlemi (&) aldığı iki değer ile yeni bir değer üretir , ürettiği değerler yukarıdaki tabloda mevcuttur ; Örneğin 10 ve 9 değerlerini VE (And) işleminden geçirirsek :
1010 //10
& 1001 //9
---------
1000 //8VE (And) işlemi sadece iki değerinde 1 olması durumunda1 sonucunu üretmektedir.
VEYA(Or) işlemi
değiken1 değişken2 Sonuç 000011101111tablo-9
örneğin yine 10 ve 9 sayıları üzerinde VEYA işlemini gerçekleştirelim
1010 //10
| 1001 //9
---------
1011 //11VEYA işleminde sadece iki değerinde sıfır olması durumunda sonuç sıfır olur
Özel VEYA (Exclusive Or) İşlemi
değişken1 değişken2 Sonuç 000011101110tablo-10
Özel VEYA değişken1 ve değişken2'nin farklı olması durumunda 1 sonucunu üretmektedir.
1010 //10
^ 1001 //9
---------
0011 //3
ör-bitwise-2
public class BitwiseOrnek2 {
public static void main( String args[] ) {
int a = 10 ;
int b = 9 ;
int c = 8 ;
System.out.println(" (a & b) --> " + (a & b) );
System.out.println(" (a | b) --> " + (a | b ) );
System.out.println(" (a ^ b) --> " + (a ^ b) );
System.out.println(" ( ~a ) --> " + ( ~a ) );
System.out.println(" ( ~b ) --> " + ( ~b ) );
System.out.println(" ( ~c ) --> " + ( ~c ) );
}
}Uygulamın çıktısı :
(a & b) --> 8
(a | b) --> 11
(a ^ b) --> 3
( ~a ) --> -11
( ~b ) --> -10
( ~c ) --> -9VE(And), VEYA( or ),ÖZEL VEYA (Exclusive Or) operatörlerini , birden çok mantıksal sonuç içeren ifadelerde kullanabilirsiniz.
Atama Operatörleri
En temel atama operatörü olarak "=" kullanılır.
ör-temel-atama
public class EnBuyukSayilar {
public static void ekranaBas(String deger) {
System.out.println(deger);
}
public static void main( String args[] ) {
// tam sayilar
byte enbuyukByte = Byte.MAX_VALUE;
short enbuyukShort = Short.MAX_VALUE;
int enbuyukInteger = Integer.MAX_VALUE;
long enbuyukLong = Long.MAX_VALUE;
ekranaBas("enbuyukByte-->" + enbuyukByte );
ekranaBas("enbuyukShort-->" + enbuyukShort );
ekranaBas("enbuyukInteger-->" + enbuyukInteger );
ekranaBas("enbuyukLong-->" + enbuyukLong );
ekranaBas("");
// gerçek sayilar
float enbuyukFloat = Float.MAX_VALUE;
double enbuyukDouble = Double.MAX_VALUE;
ekranaBas("enbuyukFloat-->" + enbuyukFloat );
ekranaBas("enbuyukDouble-->" + enbuyukDouble );
ekranaBas("");
// diger ilkel (primitive) tipler
char birChar = 'S';
boolean birBoolean = true;
ekranaBas("birChar-->" + birChar );
ekranaBas("birBoolean-->" + birBoolean );
}
}
Birazdan göreceğimiz kısa devre operatörleri ise hayatımızı dahada kolaylaştırmak amacı ile tasarlanmışlardır. Örneğin int tipinde olan i değişkenini 1 tam sayılarını toplamak için normal olarak aşağıdaki gibi bir ifade kullanırız .
i = i + 1 ;Kısa devre operatörler ile aynı ifadeyi aşağıdaki gibi yazmak mümkündür.
i += 1 ;


Yorumlar

Bu blogdaki popüler yayınlar

Java Deger Atama ve Local Değişkenler

Değişkenlereilk değerlerini atama Javauygulamalarında üç tür değişken çeşiti bulunur , yerel (local) değişkenler, obje'ye ait global değişkenler ve son olarak sınıfa aitglobal değişkenler(statik değişkenler). Bu değişkenlerin tipleri ilkel(primitive) veya herhangi bir obje tipi olabilir. ör-javada-degiskenler public class DegiskenGosterim {int x ; //objeye ait global degiskenstatic int y ; // sınıfa ait global degiskenpublic void metod () {int i ; //yerel degisken//static int y = 5 ;// yanlis}} Yerel(local)değişkenlerYereldeğişkenlere kesin olarak ilk değerleri kodu yazan kişi tarafındanverilmelidir. İlk değeri verilmeden kullanılan yerel değişkenlere uyarı ,derleme(compile-time) anında verilir. gösterim-11 public int hesapla () { // yerel değişkenlere ilk değerleri her zaman verilmelidir.int i ; i++; // ! Hata ! ilk deger verilmeden üzerinde işlem yapılamazreturn i ;} Objeyeait global değişkenlerObjelereait global değişkenler'e ilk değerlerini kodu kişi vermek zorunda değildir.Ja…

Anakart ve Bileşenleri Nelerdir?

Anakart
Mainboard olarak da adlandırılır. Sistemdeki bütün kartların, işlemcinin üzerine takıldığı, diğer donanım aygıtlarının kablolar vasıtasıyla bağlandığı ve bilgisayarın en karmaşık parçalarından biridir.
Anakart Bileşenleri
1. İşlemci soketi: İşlemcinin takıldığı sokettir.
2. Bellek soketi: RAM denilen sistem belleğinin takıldığı soketdir.
3.Genişleme Yolları Anakart üzerine ekran kartı, modem, ses kartı, vs gibi parçalar anakart üzerindeki genişleme yuvaları ya da veri yolu yuvaları denilen soketlere takılır. Yani kartların işlediği veriler ve kartlara giden bilgiler, bu yuvalar ve anakart üzerindeki veri yolları aracılığı ile işlemciye ve diğer aygıtlara ulaşırlar.
4. Güç Konnektörleri(Güç kaynağı girişi): Anakart üzerine güç kaynağından gelen kablolar bu konnektörlere bağlanır.
5. Klavye/Fare Konnektörleri(portları): Klavye ve fare yuvarlak 6 pinli bir fiş (PS/2 fişi) kullanılarak anakartaki klavye ve fare portlarına bağlanır.
6. Yonga Setleri (Chipsets): Bilgisayarların trafik pol…

Elektrik Devre Laboratuarı Dersi Ön Çalışma Soruları-Çözümleri

Elektrik DevreLabaratuarı Ön Çalışma Çözümleri
Deney 1 deki direnç okumak için
Deney 1










İsterseniz Yukarıdaki Resimleri Altta Bulunan Linkten İndirebilirsiniz

KAYDET