Java 101; If -Else if- else Yapıları ve Döngüler (for, özel for Yapıları ( foreach))

Programlama dediğimiz zaman aklımıza gelen ilk yapı if blokları olur.  Diller değişse bile mantık hep aynı çalışır, ancak söz diziminde(syntax) bazı ufak farklılıklar olabilir. If blokları kod yazarken en çok kullanacağımız yapıdır. O kadar genel bir yapıdır ki, sadece bu bloklarla da diğer döngülerin birçoğunun yaptığı görevleri yerine getirebiliriz, ancak bu çok kullanışsız ve zor bir yöntem olur. Önceki yazıda ilişkisel operatörlerden(<, >, >=, <=, ==, !=) bahsetmiştik. If bloklarında da bu yapılar ve sonucu boolean( true, false) dönen diğer değerler kullanılır. If blokları aslında makinaya  soru sorma yöntemimizdir diyebiliriz ve bu soruların cevaplarına göre de istediğimiz işlemleri yaptırırız. 

Örneğin;

int a = 10;
 boolean d = true;
 
 if(a<15) // >> (sonuc true) "a" 15'ten küçükse süslü parantez içine yazacağımız kodlar çalıştırılır.
 { 
 //Birşeyler yap
 }
 
 
 
 if(a == 10) // >> (sonuc true)
 {
 System.out.println("Çalıştı"); // a 10'a eşit olduğu için konsola "Çalıştı" yazdırılır. 
 }
 
 if(!d) // >> (sonuc false) d false ise gibi bir koşul beklendiği ve d her zaman true olduğu için 
 // sonuc false olacak ve if bloğunun içine hiç girilmeyecektir.
 {
 System.out.println("Çalıştı"); // d true olarak tanımlandığı için if bloğunun içine hiç girilmez
 // ve konsola hiçbirşey yazılmaz. Varsa blok dışındaki diğer kodlar 
 // sırasıyla çalıştırılır.
 }

 

Yukarıdaki örnekler çoğaltılabilir. Bir de if-else if ve else yapılarını inceleyelim. Bu yapılar birbirini izleyen çok sayıda koşul kontrolünü gerçekleştirebilmek için kullanılır. Mesela bir  ürünümüz olsun ve birim fiyatını satın alınan adet sayısına göre belirlemek isteyelim. 10 adetten fazla alınmışsa 10 tl, 20 adetten alınmışsa 8 tl, 30 den fazla alınmışsa 6 tl, hiçbiri değilse yani 10 adetten az ise 12 tl olsun.

 

if(ifade1) // ifade1 koşulu doğruysa Deyim1 işlemi çalıştırılır.
     Deyim1;

 else if (ifade2) // ifade2 doğruysa Deyim2 çalışır.
     Deyim2;

 else if (ifade3) // ifade3 doğruysa Deyim3 çalışır.
     Deyim3;

 ....
 ....
 ....

 else
 { // hiçbiri doğru değilse DeyimN çalıştırılır.
    DeyimN;
 Deyim_N+1;
 Deyim_N+2;
 }

 /*if - else if - else yapısının çalışma mantığı bu şekildedir.
 
 NOT : Eğer bu yapıların içerisinde sadece 1 deyim (işlem) yaptırılacaksa
 bloğu süslü parantezle kapatmaya gerek yoktur. Ancak 1'den fazla işlem yaptırılıyorsa
 süslü parantezle kapatmamız gerekir. */
 
 int satinAlinanMiktar;
 int fiyat;
 
 if(satinAlinanMiktar > 10)
 fiyat = 10;
 
 else if(satinAlinanMiktar > 20)
 fiyat = 8;
 
 else if(satinAlinanMiktar > 30)
 fiyat = 6;
 
 else
 fiyat = 12;
 
 
 
 System.out.println("Fiyat = " + fiyat + " TL");
 
 /* Bu örnekte satinAlinanMiktar'ın 35 olduğunu varsayalım. Bu durumda ikinci else if
 yapısına kadar tüm koşulları sağladığı için sırayla, tek tek bu blokların içini çalıştırır. 
 ilk if'te fiyat 10, else if te 8 ve ikinci else if'te 6 olarak güncellenir ve else koşulunu sağlamadığı
 için doğrudan en sondaki konsola bastırma işlemi yaptırılır. Sonuç olarak istediğimiz rakam olan 6 TL 
 fiyatının bastırıldığını görebiliriz. Ancak aslında gereksiz yere else'e kadar olan tüm koşulları çalıştırdığı
 ve işlemcimizi yorduğu için bu tarz kodlama yanlıştır. Doğrusu şu şekilde olmalıdır ;
 */
 
 if(satinAlinanMiktar > 10 && satinAlinanMiktar < 20)
 fiyat = 10;
 
 else if(satinAlinanMiktar > 20 && satinAlinanMiktar < 30)
 fiyat = 8;
 
 else if(satinAlinanMiktar > 30)
 fiyat = 6;
 
 else
 fiyat = 12;
 
 
 
 System.out.println("Fiyat = " + fiyat + " TL");

 

 Döngüler

Döngülerden en çok kullanılanı for döngüsüdür. Bir deyim, önceden belirli olan sayıda tekrar edecekse bu işlemi for döngüsüyle gerçekleştirebiliriz. İhtiyacımıza göre bir döngünün içerisinde başka döngüler açabilir ya da if yapıları kullanabiliriz.

 

 for (int i = 0; i < 10; i++) // Burada i 0'dan başlayarak 10'a kadar 1'er 1'er
 //artırılmak suretiyle süslü parantez içindeki kod çalıştırılır.
 {
 System.out.println("Merhaba"); // Konsola 10 kere "Merhaba" yazılır.
 }
 
 
 
 for (int i = -6; i >= -16; i-=2) // Peki bunun sonucunda kaç kere "Nasılsın" yazdırılır?
 {
 System.out.println("Nasılsın");
 }
 
 
 
 
 /* Cevap : 8 kere yazdırılır. i = -6 -6 >= -20 ? Nasılsın
 i = -8 -8 >= -20 ? Nasılsın
 i = -10 -10 >= -20 ? Nasılsın
 i = -12 -12 >= -20 ? Nasılsın
 i = -14 -14 >= -20 ? Nasılsın
 i = -16 -16 >= -20 ? Nasılsın
 */
 
 
 for (int i = 0; i < 20; i++) 
 {
 if(i % 2 == 0)
 {
 System.out.println(i+" 2'ye tam bölünür.");
 }
 }
 // Burada for'un içindeki if koşuluyla sadece ikiye tam bölünebilen sayılar ekrana bastırılır.
 
 
 
 /* İç içe for dögülerini bir saate benzetebiliriz. Bir saati 3 tane iç içe for döngüsüyle
 tanımlayabiliriz. Sırasıyla saat i, dakika j, saniya k olsun. Saatin 1 artması için dakikanın 60
 ve dakikanın 60 artabilmesi için saniyenin de 60 artması gerekir. Bunu for döngüsüyle gösterecek olursak;
 */
 
 for (int i = 0; i < 24; i++) 
 {
 for (int j = 0; j < 60; j++) 
 {
 for (int k = 0; k < 60; k++) 
 {
 try {
 Thread.sleep(1000); // 1000 milisaniye beklemeyi sağlar.
 
 System.out.println("Saat şuanda = "+ i +":" + j +":" + k );
 
 } catch (Exception e) {e.printStackTrace();}
 
 // şimdilik try-catch ve Thread yapılarına takılmayın. İleriki
 // ileriki konularda bunları anlatacağım.
 }
 }
 }
 
 
 /* 1/2! + 1/3! + 1/4! + ..... + 1/13! e kadar olan dizinin toplamını bulalım.
 
 */
 
 double s, fakt; int i, j; s=0; 
 for (i = 2; i <= 13; i++) 
 { 
 fakt = 1; 
 
 for(j = 1; j <= i; j++) 
 { 
 fakt = fakt*j;
 } 
 
 s = s+1/fakt; 
 System.out.println(s);
 } 
 
 System.out.println("Seri toplami " + s); 
 
 /*
 
 i = 2 j = 1 fakt = 1 * 1 = 1 s = 1 / 1 
 i = 2 j = 2 fakt = 1 * 2 = 2 s = 1 / 2
 
 i = 3 j = 1 fakt = 1 * 1 = 1 s = 1 / 1
 i = 3 j = 2 fakt = 1 * 2 = 2 s = 1 / 2
 i = 3 j = 3 fakt = 2 * 3 = 6 s = 1 / 6
 
 i = 3 j = 1 fakt = 1 * 1 = 1 s = 1 / 1
 i = 3 j = 2 fakt = 1 * 2 = 2 s = 1 / 2
 i = 3 j = 1 fakt = 2 * 3 = 6 s = 1 / 6
 i = 3 j = 1 fakt = 6 * 4 = 24 s = 1 / 24
 .
 .
 .
 .
 .
 */

 

Özel for yapısına gelecek olursak programlama dillerinin hepsinde for-each kavramı  programcıların gereksinim duydukları bir standart olmuştur. For-each olarak bildiğiniz bu döngü javada bulunmaz. Bunun yerine Java, for-each döngüsünün yaptığı işi, for döngüsü içerisine entegre etmiştir. Yani Java’da bu döngünün gerçekleştirdiği işlemler for döngüsünün gelişmiş bir versiyonu tarafından yerine getirilir. Özel for olarak da adlandırılan bu yapı, dizi ve liste tabanlı değişkenler üzerinde baştan sona kadar ilerleyen sıralı bir döngü oluşturur.

 

 int sayilar[] = {15, 23, 35, 2, 41, 9, 70, 10, 12};
 int toplam = 0;
 for(int x : sayilar) // x diye bir integer değişken oluşturup sayılar dizisindeki
 // tüm değerleri sırasıyla x'e atar ve döngü içinde toplama ekler.
 {
 toplam += x;
 x += 10;
 }
 
 System.out.println("Toplam="+toplam);


//Özel for döngüsü, dizide ki tüm elemanlar işlenene kadar iterasyon yapsa da, döngüyü bir break ifadesiyle sonlandırmak mümkündür.

 int numaralar[]={15, 2, 13, 22, 18, 32, 25, 8};
 int aranan = 22;
 boolean durum = false;
 for(int x : numaralar)
 {
 if(x == aranan)
 {
 durum = true;
 break;                    //if bloğunun içine girildiğinde yani x = aranan ise durum true olur ve break komutuyla döngü sonlandırılır.
                           // diğer elemanlar kontrol edilmez.
 }
 }
 
 if(durum)
 System.out.println("Değer bulundu.");
 else
 System.out.println("Dğer bulunamadı.");

 

 

 

 

 

0

Leave a Reply

Your email address will not be published. Required fields are marked *