Java’da kontrol yapıları
Hayatta karşılaştığımız tüm problemlerin çözümünde de olduğu gibi, bilgisayar programını yazacağımız bir problemini de önce en iyi şekilde idrak edip, sonra iyi tasarlanmış bir çözüm oluşturulmalıyız. Tüm bilgisayar programla ma dillerinde olduğu gibi, iyi tasarlanmış bir çözüme ulaşmak için, önce o bilgisayar programındaki kontrol yapıları en iyi şekilde çalışılıp, anlaşılmalıdır.

Bu bölümde kontrol yapısı mantığı ve Java programlama dilinde bulunan kontrol yapılarına çalışacağız.

If,else kaliplari
if (boolean) {
Komutlar;
}
else {
Komutlar;
}

ÖRNEK

int sayı ;
sayı = sayıAl () ; // programdaki bir metot
if (sayı < 0) {
System.out.println („Hata: sayı değeri negatif!“):
}
else {
System.out.println („blabla „ +sayı+„ bla„) ;
}

Koşul kalibi

Bazen çok kısa koşullar için if else yerine kullanılır. koşul ? doğruysa : yanlışsa;
örnek:
int cevap;
cevap=x < y ? x : y;
Aynı işlemin if else şekli:
int cevap;
if x < y (eger x y‘den kücükse )
cevap=x; (cevap x olur )
else (yok hayir öyle degilse )

cevap=y; (cevap dogal olarak y olur )

 

Switch kalibi
Bir önceki bölümde if ve if/else tekli ve ikili seçim kontrol yapılarına çalışmıştık. Bu yapılar her programda çok kullanıldığı gibi çoğu zamanda tek bir değişkenlerin alabileceği bir çok değer için bir programın yapması gereken farklı işlemler olacaktır. Eğ er elimizde sadece if/else yapısı bulunsaydı, bu birden çok fazla değerin her birini kontrol etmek için bir if/else kontrolü yazmak zorunda kalacaktık. Bu çok sayıda if/else, hem programın okunurluğunu azaltacak hem deprogramı izlemeyi zorlaştıracaktır. I şte bu olumsuzlukları engelleyip daha verimli bir yapı oluşturabilmek için java proglama dilinde SWITCH çoklu seçim kontrol yapısı bulunmaktadır.

Bu switch deyimi bir değişkenlerin alabileceği bir çok değerin her biri için yapılması gerekli kod bloklarını içerir.
Switch yapısı ilk olarak SWITCH deyimi ile başlar, sonra değerlerine göre işlem yapılacak
değişkenlerin belirlenmesiyle devam eder. Değişkenlerin her değeri için yazılacak kod parçaları
CASE deyiminlerinden sonra yazılır ve Her CASE deyimin bittiği yeri gösteren BREAK deyimi ile case sonlandırılıp, SWITCH komut bloğundan çıkılır. Switch yapısının son elemanı ise seçimlik olarak DEFAULT deyimi olup eğer hiç bir CASE koşulu sağlanmazsa yapılacak  işlemleri iç erir.

switch (expr1)
{
case expr2:
Komutlar;
break;
case expr3:
Komutlar;
break;
default:
Komutlar;
break;
}

Örnek:
import java.awt.*;
import java.applet.*;
public class caseornek01 extends Applet {
Label prompt1;
TextField input1;
int sayi=0;
public void init()
{
prompt1 = new Label( "1 ILE 10 ARASI BIR SAYI GIRINIZ " );
input1 = new TextField( 5 );
add( prompt1 );
add( input1 );
}
public void paint( Graphics g )
{ g.drawString("Sonuc",50,125);
switch (sayi)
{
case 1:
g.drawString( " Girdiginiz sayi= "+sayi, 50, 150 );
break;

case 2:
g.drawString( " Girdiginiz sayi= "+sayi, 50, 150 );
break;
case 3:
g.drawString( " Girdiginiz sayi= "+sayi, 50, 150 );
break;
case 4:
g.drawString( " Girdiginiz sayi= "+sayi, 50, 150 );
break;
case 5:
g.drawString( " Girdiginiz sayi= "+sayi, 50, 150 );
break;
case 6:
g.drawString( " Girdiginiz sayi= "+sayi, 50, 150 );
break;
case 7:
g.drawString( " Girdiginiz sayi= "+sayi, 50, 150 );
break;
case 8:
g.drawString( " Girdiginiz sayi= "+sayi, 50, 150 );
break;
case 9:
g.drawString( " Girdiginiz sayi= "+sayi, 50, 150 );
break;
case 10:
g.drawString( " Girdiginiz sayi= "+sayi, 50, 150 );
break;
default:
g.drawString("Farklı Bir Sayı Girdiniz",50,150);
break;
}
}
public boolean action( Event event, Object o )
{
if ( event.target == input1 ) {
sayi = Integer.parseInt ( input1.getText() );
repaint();
}
return true;
}
}

 

Bu örnekte dışarıdan girilen sayının 1 ile 10 arasında olanını applet'e yazdırıyoruz. Eğer farklı bir sayı girilirse sayı için Farklı Bir Sayı Girdiniz mesajı dışarı verilir.
Bu algoritma gerçekleştirilirken sayi isimli değişken kullanılmış olup, bu sayi is imli değişkenlerin 10 değeri CASE kullanılarak kontrol edilmiştir. Eğer bu 10 CASE durumundan hiç biri olmazsa DEFAULT deyiminin kullanıldığı komut bloğu işlenilmiştir.

 

Break ve Continue komutları

BREAK ve CONTINUE komutları ile bir döngünün akışı değiştirilir. BREAK komutu
while, for, do/while, veya switch döngü yapılarından koşulsuz çıkışı sağlar.BREAK
komutunun asıl kullanım amacı bir döngüden döngünün sonunun gelmesini beklemeden çıkış için ve ya SWICTH çoklu seçim komut bloğunda BREAK komutunun altında kalan
komutları atlamak için kullanılır.

Aşağıdaki basit bir örnekle bunu gözlemleyelim.

//Örnek:
import java.awt.*;
import java.applet.*;
public class breakornek0 extends Applet
{
public void paint (Graphics g)
{
int y=25;
for (int i=1;i<=20;i++)
{
g.drawString("Döngü degiskenini ndegeri = "+i,15,y);
y=y+25;
if (i==8)
{
g.drawString("Bu Döngüden Çıkıyorum",15,y);

Görüldüğü üzere eğer FOR döngüsü normal şekilde sonlanacak olsaydı, aplet üzerine i döngü
kontrol değişkenlerinin alması gereken tüm değerler yazılacaktı. Fakak  değişkeni 8 değerine
ulaşınca BREAK komutu çalıştırılıyor ve FOR döngüsünden koşu lsuz çıkılıyor ve i nin
sadece ilk 8 değeri aplete yazdırılıyor.

break komutu iç içe oluşturulmuş döngülerde, hangi döngüde kullanılmışsa o döngüden
çıkmayı sağlar ve diğer dış döngüler işlemlerine devam eder. Aşagıdaki kod bloğu işletilince, apletten ilk olarak iç WHI LE döngüsünün çıkıldığı anlaşılıyor. Fakat dış WHILE  döngüsününe devam edildiği, dış WHILE döngüsünden ise bir sonraki BREAK komutu ile çıkıldığı görülüyor.

Örnek :
import java.awt.*;
import java.applet.*
public class breakornek extends Applet {
public void paint (Graphics g)
{
int y=25;
int i=0;
int j=0;
while (++i<=3)
{
g.drawString(" Dis while döngü degiskeni degeri I = "+i,15,y);
y=y+25;
while(++j<=10)
{
g.drawString(" ic while döngü degiskeni degeri J= "+i,15,y);
y=y+25;
if (j==3){g.drawString("ic while döngüsünden cikiliyor",15,y);
break;
}
}

 

Continue komutu ise, döngü içerisinde sadece döngünün o seferki dönüşünde, bu
komutun altında kalan komutları atlamaya yarar. Döngü sonraki değerleri için dönmeye devam eder. Ama CONTINUE komutunda dikkat etmemiz gereken husus bu  komutun DO/WHILE v e FOR döngü yapılarında kullanılınca farklılıklar içermesidir. DO/WHILE döngülerinde kontrol değişkenlerine uygulanması gereken arttırma veya azaltma işlemi gerçekleştirilmeden,döngü kontorolü yapılır ve işlemlere devam  edilir.Fakat FOR döngülerinde ise, CONTINUE komutu işlenince döngü kontrol  değişkeni için yapılması gereken artırma ve ya azaltma işlemi yapılır, sonra döngü  kontrolü yapılır. BU dikkat edilmesi gereken önemli bir durumdur.

Örnek
//Yukaridaki programlam bu program arasindaki farka dikkta edin!!
import java.awt.*;
import java.applet.*;
public class breakornek2 extends Applet {
public void paint (Graphics g) {
int y=25;
int i=0;
int j=0;
while (++i<=3)
{
g.drawString(" DIŞ WHILE DÖNGÜ DEĞIŞKENI DEĞERI I = "+i,15,y);
y=y+25;
while(++j<=10)
{
g.drawString(" IÇ WHILE DÖNGÜ DEĞIŞKENI DEĞERI J = "+i,15,y);
y=y+25;
if (j==3){g.drawString("IÇ WHILE DÖNGÜSÜNDEN ÇIKILIYOR",15,y);
y=y+25;
break;
}
}
if (i==1){g.drawString("DIŞ WHILE DÖNGÜSÜNDEN ÇIKILIYOR",15,y);
y=y+25;
break;
}
}
}

 

Döngü kaliplari

for döngüleri

for (ilk_değeri1; test_değeri2; arttırma_değeri3)
{
Komutlar;
}

 

Örnek
class don{
public static void main(String args[]) {
int x;
System.out.println("Cuneyt 10 defa sorar:");
for(x=0;x<=10;x++){
System.out.println("(: Bitmedimi bu askimiz hala Nalan ");
}
System.out.println("Nalan cevap verir:");
System.out.println("THE SON :)");
}
}

 

Programı çalıştırdığımızda, çıktı olarak elde ettiğimiz applet'i incelersek, sayac kontrol
değişkenlerin ilk olarak 1 değerini alığını görürüz. Daha sonra döngü içerisinde birer birer artığını ve 20 değerine ulaşınca döngünün son bulduğunu gözlemleriz . Böylece :

•    .ifade diye tanımladığımız sayac=1; komutu ile kontrol değişkenlerine ilk değeri atadığımız,
•    ifade diye tanımladığımız sayac<=20; komutu ile döngü uzunluğunu belirlediğimiz,
•    ifade diye tanımladığımız sayac++; komutu ile kontrol değişkenlerinin her dönüş için değişim miktarını belirlediğimiz görülür.

 

Java programlama dilinde for döngü yapıları için gerekli dediğimiz 3 ifadenin hepsi isteğe bağlı ifadelerdir. Yani istenirse yazılmayabilirler. Bu durumda dahi for
döngüsü çalışır. Ama eğer 1.ifade verilmezse bu, kontrol değişkenlerinin daha önceki komutlard a tanımlanmış ve değer atanmış olmasını gerektirir. 2.ifade verilmezse bu
ise for döngüsünün sonsuz bir döngü olacağı  anlamına gelir. 3.ifade verilmezse bu ise, döngü değişkenlerinin döngü içerisinde arttırıp , azaltacağı  anlayıp. Son olarak döngü değeri azalarak oluşturulmuş bir for döngüsü örneği inceleyelim. Programlamalıyı 20 den 1' e kadar i kontrol değişkenlerinin döngü içerisinde aldıgı  değerlerini applet'e yazıp, döngü değişkenlerin aldıgı değerlerin toplamyı çıktı  olarak veriyor.

Örnek
import java.awt.Graphics;
import java.applet.Applet;
public class forornek02 extends Applet {
public void paint(Graphics g)
{
int toplam=0;
int y=25;
for (int i=20;i>=1;i--){
g.drawString("I'nin DEĞERI : "+i,25,y);
y=y+25;
toplam=toplam+i;
}
g.drawString("toplam : "+toplam,50,y+25);
}
}

 

Bu örnek ile azalarak giden döngü kontrolü değişkenlerini görmüş olduk.  değişkeni ilk değeri olan 20 değerinden sonra, döngü her dönüşünde bu ilk değerinden birer birer azalarak 1 değerine ulaşır. 1 değerine ulaşınca döngü son bulur ve değerlerin to  plami  applet'e yazılıp , program sonlandırır.

Örnek:
class kare {
public static void main (String args[]) {
int l ,a;
if (args.length == 2) {
l = Integer.valueOf(args[0]).intValue();
a = Integer.valueOf(args[1]).intValue();
}
else {
l= 20;
a= 15;
}
for (int i=l; i>0; i--){
System.out.print("J");
}
System.out.print("\n");
for (int i= a-2; i>0; i--){
System.out.print("A");
for(int j=l-2; j>0; j--) {
System.out.print(" ");
}
System.out.print("V\n");
}
for (int i=l; i>0; i--){
System.out.print("A");
}
System.out.print("\n");
}
}

 

while döngüleri
While cok kullanilan tekrarlama yapilarindan biridir.( ) icindeki boolean terim true(dogru)olduğu  sürece yeniden islemi döndürür.Eger programda boolean islemi sonuclandiracak bir ifade yoksa  bu döngü sonsuza kadar devam edebilir.

while (boolean degisken)
{
Komutlar;
}

while(true) {
System.out.println(„Bu döngü sonsuze gider“);
}
Yukaridaki program sonsuza kadar gider.

Örnek:

import java.lang.*;
class whileornek {
public static void main(String args[]) {
int num=1;
while(num <=10){
num +=1;//veya ++
System.out.println("nummmer="+num);
}
}
}

 

do-while döngüleri

Komutlar; DO/WHILE döngü yapısı ile WHILE döngü yapısı birbirine çok benzer. Tek ve önemli fark, DO/WHILE yapısında döngü en az bir kere tekrarlanır . Bunun nedeni
döngü kontrolünün döngünün sonunda yapılmasıdır. Ama WHI LE döngü yapısında kontrol en başta olduğu için, döngü hiç dönmeyebilir. Bu yüzden DO/WHILE yapısı kullanırken döngünün en az bir kere döneceği unutulmamalıdır.

Örnek:

import java.awt.*;
import java.applet.*;
public class whileornek extends Applet {
int n[];
int c=0;
int num;
int y=25;
int toplam=0;
Label prompt1;
TextField input1;