Java'da Kontrol Yapıları
Java'da Kontrol Yapıları
Diğer programlama dillerinde olduğu gibi Java'da da kontrol yapıları dilin en önemli parçasını oluşturur. Başka bir deyişle, kontrol yapıları olmasaydı bilgisayar programları, bilgi giriş-çıkışı ve bazı hesaplamalar dışında bir işlemi gerçekleştiremezlerdi. Bu bölüme kadar verilen programlar bir bakıma düz hat programları olarak görülebilir. Yani şu ana kadar verilen programlarda bir komuttan sonra aradaki komutları atlayarak başka bir noktaya sıçrama söz konusu değildi. Bir bilgisayar programında komutlar normal olarak yazılış sırasına göre çalıştırılır. Örneğin, herhangi bir programlama dilinde yazılmış olan,
Komut1
Komut2
Komut3
........
Komutn1
Komutn
şeklindeki bir programda, önce Komut1 sonra Komut2 daha sonra Komut3 ... Komutn1 ve en son da Komutn çalıştırılır.
Programlama problemlerinden birçoğu bu kadar basit değildir. Programlama dillerinin gücü, aynı işi tekrar tekrar yapabilmelerinden ya da farklı parametre değerleri için değişik işler yapabilmelerinden gelir. Kontrol komutları, yukarda bahsedilen doğrusal akış sırasını değiştirebilen komutlardır. Örneğin Komut2 bir kontrol komutu olsaydı, bu komut bir koşulu kontrol ederek koşulun sonucuna göre, Komut3 ,Komut4 ve Komut5’i atlayarak programın icrasını doğrudan Komut6’ya gönderebilirdi. Bir bilgisayar programında programın kontrolünün aradaki komutlar atlanarak bir komuttan diğerine sıçramasına dallanma (branching) diyoruz. Bu anlamda kontrol komutları dallanmayı gerçekleştiren komutlardır. Diğer programlama dillerinde olduğu gibi, Java dilinde de esas olarak iki farklı tür kontrol yapısı ya da komutu mevcuttur:
- Seçme (selection) işlemini gerçekleştiren kontrol komutları: Bu tip kontrol komutlarında bir ifade kontrol edilerek ifadenin değerine göre çeşitli seçeneklerden bir tanesinde dallanma işlemi gerçekleştirilir: if, if else, switch case gibi yapılar bu tür komutları oluşturur.
- Tekrarlama (loop, repetition): Bu tip kontrol yapılarında bir işlemler grubu bir koşula bağlı olarak belirli sayıda (10 kez, 50 kez vb.) tekrarlı olarak çalıştırılabilir.
if Deyimi
if deyimi, bir önceki sayfada sözünü ettiğimiz "ifadeyi denetleyerek, ifadenin değerine göre uygun yollardan bir tanesiyle dallanma işlemini gerçekleştiren" bir kontrol deyimidir. Bu sayede şartlı dallanma (conditional branching) adı verilen işlem gerçekleştirilir. Şartlı dallanma, bir programlama dili için en temel kontrol yapısıdır.
Şartlı dallanma işlemiyle bir program, gidişatını daha önceden verdiğiniz yollardan biriyle devam ettirmeye karar verebilir hale gelir. Bir şarta göre bir komut dizisini çalıştırır veya esgeçer.
Java dilinde şartlı dallanma if ve else anahtar sözcükleriyle gerçekleştirilir. if deyiminin basit gösterimi şöyledir:
if (şart) komut 1
komut 2
komut 2
Burada şartın değeri doğru (true) olarak sağlanıyorsa ancak komut 1 çalıştırılır. Daha sonra program normal bir akışla komut 2’yi çalıştırmaya geçer. Şartın değeri yanlış (false) ise, bu durumda program doğrudan komut 2’ye geçer ve onunla devam eder. Kısacası şartın değeri yanlış ise komut 1 hiçbir zaman çalışmayacaktır.
Aşağıda if yapısını açıklayan bir akış diyagramı verilmiştir. Hemen ardından Java'da yazılan bir if örneği verilmiştir.
if deyimi için akış diyagramı (flow chart)
if (fiyat==1) {
//fiyat 1 ise çalıştırılacak komutlar
}a
Bu noktada, Java dilinde doğru ve yanlışın ne anlama geldiğini belirtelim: Şartın doğru olması, o ifadenin matematiksel olarak 1 yani true (doğru) olan bir değer üretmesi demektir. Yanlış olması ise, matematiksel olarak değerin 0 yani false (yanlış) olan bir değer üretmesi anlamına gelir. Programlama dillerinde sadece bu iki değerden birini alabilen değişken türleri boolean olarak anılır.
Şartlı dallanmanın yarısını bitirdik, şimdi diğer yarısına bakalım.
Sizin de dikkat ettiğiniz gibi yukarıdaki örnek sadece şart sağlanırsa olacaklara ilişkin bir dallanmaya gidiyor. Şimdi şart sağlanmazsa durumuna bakalım. Bunun için yeni bir deyim olarak else deyimi ile tanışacağız. "else" deyimi sadece if ile birlikte kullanılan bir şartlı dallanma deyimidir. İkisinin beraber kullanımı şöyle bir yapıda gerçekleşir:
if (şart) komut 1
else komut 2
komut 3
else komut 2
komut 3
Bu durumda, şart doğru ise komut 1 çalıştırılır ve sonra komut 3’e geçilir. Şartın değeri yanlış ise, bu durumda da komut 1 atlanarak doğrudan else’i takip eden komut 2’ye geçilir. Bu çalıştırıldıktan sonra program yine komut 3 ile çalışmaya devam eder. Bu yapıya ilişkin aşağıdaki akış diyagramına göz atalım ve sonra da Java programlama diliyle yazılan if-else örneğine göz atalım:
if else deyimi için akış diyagramı(flow chart)
if-else'li bir Java kodu da şöyle olur:
public class SartliDallanmaOrnek1 {
public static void main(String[] args) {
int parola=2013;
if (parola==2013) {
System.out.println("Parolalar eşleşiyor.");
}
}
}
Bu örnekte programın içinde tanımlanmış integer tipli 'parola' değişkeninin değerinin 2013 olup olmadığı şartını denetliyoruz ve eğer şart doğru olarak ifade edilebiliyorsa ekrana 'Parolalar eşleşiyor.' yazdırıyoruz.
Evet, yukarıdaki sahiden basit bir örnek. Genelde parola değişkeni gibi programcı tarafından programın içinde oluşturulan ve program bittiğinde yok edilen değişkenler ile böyle denetimler yapıp, programı şartlı dallanmaya uğratmayız. Programcının dışında olanlarla ilgileniriz. Kullanıcıyla etkileşime geçerek veya bilgisayardaki başka değişenlere (saat, ağ bağlantısının müsaitliği ve daha bir sürü değişebilecek durum) göre dallanma yaparız. Aşağıdaki örnekte bunu deneyelim. Kullanıcıya İstanbul'un plaka kodunu soralım ve verdiği yanıta göre ona tekrar yanıt dönelim:
NOT: Aşağıdaki örnekte kullanıcıdan veri almak için Scanner adında bir sınıf kullanılmıştır. Scanner sınıfı java.util paketi içerisinde bulunan bir sınıftır. Bazı basit tipteki ifadeleri klavyeden okumaya yarayan sade bir yazı tarayıcı sınıfıdır. Scanner sınıfı hakkında bazı önemli noktalar şöyledir:
- Bir Scanner girdiyi bazı kalıplara göre ayırıştırır. Bu ayrışım genellikle girdinin içerdiği boşluklara göre olur.
- Bir tarama işlemi kullanıcıdan girdi gelmesi için bekleme yapabilir.
Bu kod parçasında Scanner, konsolda kullanıcının girdiği metni alır ve bir değişkene atar.
import java.io.IOException;
import java.util.Scanner;
public class SartliDallanmaOrnek2 {
public static void main(String[] args) throws IOException {
Scanner giris=new Scanner(System.in);
//String kullanicininYazdigi;
int istanbulPlakaKodu=34;
int girilenPlakaKodu;
//soruyu ekrana basalım
System.out.println("Istanbul'un plaka kodu nedir?");
//klavyeyle girilen değeri integer olarak alalım
girilenPlakaKodu=giris.nextInt();
if(girilenPlakaKodu==istanbulPlakaKodu) {
System.out.println("Evet! Dogru yanit.");
} else {
System.out.println("Hayir, Istanbul'un plaka kodu 34'tur.");
}
}
}
Bu program ile basitçe kullanıcıdan İstanbul'un plaka kodunu girmesini istiyoruz ve girdiği değeri önce kullanicininYazdigi değişkeninde tutuyoruz ve sonra onu girilenPlakaKodu değişkeninde tutulacak bir hale çeviriyoruz. Bu sayede tamsayı tipindeki istanbulPlakaKodu değişkeniyle karşılaştırabiliyoruz. Karşılaştırma sırasında == operatörü kullanıyoruz. Bu "eşit mi?" anlamına geliyor. Eğer girilenPlakaKodu ile istanbulPlakaKodu değişkeni birbirine eşitse, bu şart bize true (doğru) döndürüyor ve if bloku çalışıyor. Eşit değilse else bloku devreye giriyor ve kullanıcıya olumsuz mesaj veriliyor.
if Deyimiyle İlgili Problemler
Problem 1:
f(x) ve g(x) fonksiyonları,
x > 0 ise f(x)= 1 / ( 1 + ln x ) ve g(x)= 1 / ( x + ln x )
x≤0 ise f(x) = 1 / ( 1+ x2 ) ve g(x)=1 / ( 1 + x + x2 )
x≤0 ise f(x) = 1 / ( 1+ x2 ) ve g(x)=1 / ( 1 + x + x2 )
şeklinde tanımlanıyor. x değeri klavyeden girildiğinde, f(x) ve g(x)’i hesaplatan ve yazdıran bir Java programı yazalım.
import java.io.IOException;
import java.util.Scanner;
public class If1
{
public static void main(String args[]) throws IOException
{
Scanner giris = new Scanner(System.in);
double x, f, g;
System.out.println("Bir sayi giriniz: ");
x = giris.nextDouble();
if (x > 0.0)
{
f = 1.0 / (1.0 + Math.log(x)); g = 1.0 / (x + Math.log(x));
}
else
{
f = 1.0 / (1.0 + x * x); g = 1.0 / (1.0 + x + x * x);
}
System.out.println("\nf(x)=" + f);
System.out.println("\ng(x)=" + g);
}
}
Programın çıktısı:
x negatif bir değer olarak girildiğindeyse,
çıktısı elde edilecektir.
NOT: Java'da birçok matematik kütüphanesi Math adında bir sınıfın altında bulunur. log fonksiyonu, e tabanına göre logaritma yani tabii logaritma hesaplayan bir Java fonksiyonudur.
Problem 2:
Bir satış elemanının sattığı ürün miktarına göre alacağı günlük ücret aşağıdaki gibi belirleniyor:
- Günlük satış miktarı 50 adetten az ise 15 TL tutarındaki sabit ücrete, satılan ürün başına 1 TL değerinde prim eklenerek günlük ücret belirlenir.
- Günlük satış miktarı 50 adet ya da daha fazla ise, bu durumda günlük sabit ücret 15 TL alınarak, satılan ürün başına da ilk 50 adet ürün için 2 TL, 50 adedi aşan kısım için de 3 TL prim verilerek günlük ücret belirlenir.
Bir satıcının günlük satış miktarı bilgisayara girildiğinde satıcının alacağı günlük ücreti hesaplayan bir Java programı yazınız.
import java.io.IOException;
import java.text.DecimalFormat;
import java.util.Scanner;
public class Satis
{
public static void main(String args[]) throws IOException
{
Scanner giris = new Scanner(System.in);
double satis, ucret; //DecimalFormat tipiyle özel biçimlerde sayılar gösterebilirsiniz.
DecimalFormat nf = new DecimalFormat("###,###.00");
System.out.println("Gunluk kac tane urun satiyorsunuz? ");
satis = giris.nextDouble();
if (satis < 50)
{
ucret = 15.0 + satis * 1.0;
}
else
{
ucret = 15.0 + 50 * 2.0 + (satis - 50) * 3.0;
}
System.out.println("Buna gore gunluk ucretiniz: "+nf.format(ucret)+" TL");
}
}
Programın çıktısı:
Gerekli tüm aralıkların kontrolü için program 10, 30 ve 60 adetlik satış miktarları için test edildiğinde aşağıdaki sonuçlar elde ediliyor:
Problem 3:
Bilgisayara negatif olmayan bir sayı girildiğinde bu sayının karekökünü hesaplayan, negatif bir sayı girildiğinde ise kullanıcıyı uyaran bir Java programı yazalım.
import java.util.Scanner;
public class KareKok
{
public static void main(String args[])
{
Scanner giris = new Scanner(System.in);
double sayi; System.out.println("Karekokunu bulmak icin bir sayi giriniz: ");
sayi = giris.nextDouble();
if(sayi < 0)
System.out.println ("Olmadi, pozitif sayi girmeliydiniz");
else
System.out.println (sayi + "'nin karekoku: "+ Math.sqrt(sayi));
}
}
Programın çıktısı:
Not: Programda, verilen bir sayının karekökünü hesaplayan sqrt fonksiyonu kullanılmıştır. Bu fonksiyon math kütüphanesinin bir elemanı olup sayının karekökünü bulur. Math kütüphanesinin içinde matematik işlemlerini yapmak için daha birçok fonksiyon bulunur. Bu sayede programcı matematiksel işlemleri math kütüphanesinin özelliklerini kullanarak çok rahat bir şekilde yapabilir.
İç içe if Deyimleri
Tek bir if deyimi, programınızın iki seçenekten birini seçmesine olanak sağlar ve tüm dallanma bu kadardır. Öte yandan pratikte daha fazla dallanmaya ihtiyaç duyan uygulamalar yapmanız gerekir. Birinci karardan sonra ikinci, ikinciden sonra üçüncü kararın (dallanmanın) alınması gerekebilir. Bu şekilde giden bir program akışı için iç içe if deyimleri (nested if statements) kullanmalısınız.
Örneğin şöyle kullanabilirsiniz:
if (koşul) {
//koşul 1'in komutları
//if (koşul1a) {
//koşul 1a'nın komutları
//...
}
}
İlk şartlı dallanmanın içinde tekrar bir şartlı dallanma yapmak gerektiğinde, iç içe if kullanabilirsiniz. Bunun kullanımına ilişkin şu örneğe göz atınız:
public class IcIceIfDeyimi1 {
public static void main(String[] args) {
int sinav1=45;
int sinav2=50;
int sinav3=66;
//ortalama'yı float olarak alıyoruz.
float ortalama= (float) (sinav1+sinav2+sinav3)/3;
String sonuc;
if (ortalama<45) {
//0-44 arası ortalama zayıf
sonuc="Zayif";
} else if (ortalama<55){
//45-54 arası ortalama geçer
sonuc="Gecer";
} else if (ortalama<70) {
//55-69 arası ortalamaya orta
sonuc="Orta";
} else if (ortalama<85) {
//70-84 arası ortalamaya iyi
sonuc="Iyi";
} else {
//başka bir sonuç kalmadığı için tekrar
//if ile şart aramıyoruz
sonuc="Pekiyi";
}
System.out.println("Ortalama: "+ortalama);
System.out.println("Buna gore sonuc: "+sonuc);
}
}
Programın sonucu şöyle olacaktır:
NOT: İç içe if kullanırken dikkat etmemiz gereken şey, koşulları yazarken programın adım adım bunları denetleyeceğini dikkate almamız gerektiğidir. En dıştaki veya en üstteki şart, ondan sonra gelenlerle çelişmemelidir.
Yukarıdaki if deyimlerini daha kısa olacak şekilde şöyle de yazabiliriz:
if (ortalama<45)
sonuc="Zayif";
else if (ortalama<55)
sonuc="Gecer";
else if (ortalama<70)
sonuc="Orta";
else if (ortalama<85)
sonuc="Iyi";
else
sonuc="Pekiyi";
Bu şekilde bir yazım genelde if'ten sonraki komut/deyim tek satırlık olacaksa kullanışlıır.
Şimdi biraz daha gerçek bir iç içe if deyimi örneği üzerinde duralım. Bu örnekte kullanıcıdan 3 tane sayı girmesini istiyoruz ve bu 3 sayıdan en küçüğünü bulup ekrana basıyoruz.
import java.io.IOException;
import java.util.Scanner;
public class IcIceIfDeyimi2 {
public static void main(String[] args) throws IOException {
Scanner giris = new Scanner(System.in);
int a,b,c; //sayılar, bu değişkenlere
int enKucukSayi; //en küçüğü bir yerde tutalım
System.out.println("Birinci sayiyi giriniz: ");
a = giris.nextInt();
System.out.println("Ikinci sayiyi giriniz: ");
b=giris.nextInt();
System.out.println("Ucuncu sayiyi giriniz: ");
c=giris.nextInt();
if (a < b) {
if (a < c) {
enKucukSayi=a;
} else {
enKucukSayi=c;
}
} else if (b < c) {
enKucukSayi=b;
} else {
enKucukSayi=c;
}
System.out.println("En kucuk sayi: "+enKucukSayi);
}
}
Bu kodu çalıştırdığınızda ve sayıları girdiğinizde şöyle bir çıktı oluşacaktır:
Bu örnekte üç sayıdan en küçüğünü bulabilmek için önce ilk iki sayıyı ele alıyoruz.
- Önce ilk sayı ikinci sayıdan küçük mü diye (a < b) bakıyoruz.
- Bu şart sağlanıyorsa bu sefer ilk sayıyla üçüncü sayıyı ele alıyoruz (a < c).
- İlk sayı üçüncü sayıdan küçükse en küçük sayı ilk sayıdır.
- İlk sayı üçüncü sayıdan küçük değilse en küçük sayı üçüncü sayıdır.
- İlk sayının ikinci sayıdan küçük olma şartı sağlanmıyorsa ikinci ile üçüncü sayıyı ele alıyoruz (b < c).
- İkinci sayı üçüncü sayıdan küçükse en küçük sayı ikinci sayıdır.
- İkinci sayı üçüncü sayıdan küçük değilse en küçük sayı üçüncü sayıdır.
Karşılaştırma İşlemleri
Şartlı bir ifadede iki değer arasında karşılaştırma işlemi gereklidir. İlişkisel operatörler (relational operators) olarak da anılan 6 karşılaştırma operatörü vardır. Bunlar aşağıdaki tabloda yer alıyor:
| KARŞILAŞTIRMA OPERATÖRÜ | İŞLEVİ |
|---|---|
| < | den daha küçük |
| > | den daha büyük |
| <= | küçük ya da eşit |
| >= | büyük ya da eşit |
| == (Art arda iki == sembolü) | -e eşit |
| != | eşit değil |
Pascal ve FORTRAN’da olduğu gibi, Java dilinde de karşılaştırma sonucu doğru ise Boolean tipinde true (doğru) değeri elde edilirken karşılaştırma sonucu yanlış ise de Boolean tipinde false (yanlış) değeri elde edilir.
| İFADE | DEĞER |
|---|---|
| -12 < 0 | 1 |
| 0 > 23 | 0 |
| 1 == 1 | 1 |
| 3 != 7 | 1 |
| 1 >= -2 | 1 |
| 6 > 8 | 0 |
Aşağıdaki Java programı, çeşitli karşılaştırma işlemlerinin sonuçlarını ekrana aktarıyor:
public class Lojik {
public static void main(String[] args) {
System.out.println("3>5 ifadesinin degeri .."+(3>5));
System.out.println("3<5 ifadesinin degeri .."+(3<5));
System.out.println("3!=5 ifadesinin degeri .."+(3!=5));
System.out.println("5==5 ifadesinin degeri .."+(5==5));
System.out.println("5>=4 ifadesinin degeri .."+(5>=4));
System.out.println("-1<0 ifadesinin degeri .."+(-1<0));
}
}
Sonucu şöyle olacaktır:
Karşılaştırma işlemlerinde dikkat edilmesi önemli bir husus vardır. Aşağıdaki kod parçasını inceleyelim:
import java.util.Scanner;
public class Esit {
public static void main(String[] args) {
Scanner giris=new Scanner(System.in);
int girilenSayi=0;
System.out.println("Bir sayi giriniz: ");
girilenSayi=giris.nextInt();
if(girilenSayi=7){
System.out.println("Girdiginiz sayi 7'dir.");
}
}
}
Özellikle if blokuna yönelirsek;
Karşılaştırma işlemlerinde eşitlik kontrolünün == sembolü yerine (yani art arda iki = sembolü) yanlışlıkla = sembolü ile yapılması durumunda Eclipse üzerinde aşağıdaki gibi hata mesajı alırsınız:
if’deki bu hatayı düzelterek, yani = yerine aşağıdaki gibi == yazarak
if(girilenSayi==7.0) {
System.out.println("Girdiginiz sayi 7'dir.");
}
programı çalıştırdığınız takdirde aşağıdaki gibi beklenen sonucu elde ederiz:
if-else-if Basamak Yapısı
Birbirini izleyen çok sayıda koşul kontrolünü gerçekleştirmeye yarayan bir yapı if-else-if basamağı adını alır ve yazılış biçimi aşağıdaki gibidir:
if(ifade1)
Deyim1;
else if (ifade2)
Deyim2;
else if (ifade3)
Deyim3;
....
....
else
Deyim_n;
Deyim_n+1;
Bu yapı şu şekilde çalışır:
- Önce ifade1 kontrol edilir; bu ifade doğru ise, Deyim1 uygulanır ve sonra Deyim_n+1’e geçilir.
- İfade1 yanlış ise, o takdirde, ifade2 kontrol edilir. Bu ifade doğru ise, bu durumda sadece Deyim2 uygulanır ve sonra Deyim_n+1’e geçilir.
- İfade2 yanlış ise, o takdirde, ifade3 kontrol edilir. Bu ifade doğru ise, bu durumda sadece Deyim3 uygulanır ve sonra Deyim_n+1’e geçilir.
Bu işlemler daha fazla sayıda else if bulunduğu durumda aynı şekilde devam eder.
if’ler ile kontrol edilen ifadelerin tümü yanlış ise, bu durumda programın kontrolü else’i izleyen Deyim_n’ye geçer ve bu deyim çalıştırılır. Daha sonra kontrol Deyim_n+1’e geçer. Yukardaki yapı içinde Deyim1, Deyim2 ...Deyim_n ile belirttiğimiz birimler tek bir deyimden ibaret olabileceduği gibi, { } sembolleri içine alınmış deyimler grubundan da oluşabilir.
Örnek Problem:
Bu örnekte basit bir vergi hesabı programı geliştirmek istiyoruz. Gelir vergisinin aşağıdaki kurallara göre belirlendiğini varsayalım:
Gelir ≤ 150,000,000 ise vergi oranı %25
Gelir ≤ 300,000,000 ise vergi oranı %30
Gelir ≤ 600,000,000 ise vergi oranı %35
Gelir ≤ 1,200,000,000 ise vergi oranı %40
Gelir > 1,200,000,000 ise vergi oranı %50
Gelir ≤ 300,000,000 ise vergi oranı %30
Gelir ≤ 600,000,000 ise vergi oranı %35
Gelir ≤ 1,200,000,000 ise vergi oranı %40
Gelir > 1,200,000,000 ise vergi oranı %50
Bu problemi Java dilinde programlayabilmek için aşağıdaki basit algoritmayı uygulayacağız:
- Gelir bilgisi klavyeden girilecek.
- Gelir bilgisi, yukardaki vergi hesaplama kurallarına göre kontrol edilerek vergi hesaplanacak.
- Hesaplanan vergi ekrana yazdırılacak.
import java.util.Scanner;
public class Vergi {
public static void main(String args[]){
Scanner giris = new Scanner(System.in);
double gelir, v, v1, v2, v3, v4;
System.out.println("Gelir miktarınız (TL): ");
gelir = giris.nextDouble();
v1 = 150000000 * 0.25;
v2 = 150000000 * 0.30;
v3 = 300000000 * 0.35;
v4 = 600000000 * 0.40;
if (gelir <= 150000000)
v = gelir * 0.25;
else if (gelir <= 300000000)
v = v1 + (gelir - 150000000) * 0.3;
else if (gelir <= 600000000)
v = v1 + v2 + (gelir - 300000000) * 0.35;
else if (gelir <= 1200000000)
v = v1 + v2 + v3 + (gelir - 600000000) * 0.4;
else
v = v1 + v2 + v3 + v4 + (gelir - 1200000000) * 0.5;
System.out.println("Odemeniz gereken vergi: " + v);
}
}
Programın çıktıları
ÇIKTI 1:
ÇIKTI 2:
Yukarıdaki programda uygulanan vergilendirme mantığı şöyledir:
Örneğin, bir kişinin geliri 200,000,000 TL olsun. Bunun ilk 150,000,000 TL’si %25 üzerinden, kalan 200,000,000 – 150,000,000 = 50,000,000 TL’si ise %30 üzerinden vergilendirir. O nedenle programın başında her aralığa ait sabit vergiler hesaplanarak v1, v2, v3 ve v4 değişkenlerine atanır.
İkinci Dereceden Bir Denklemin Köklerinin Bulunması
Lise yıllarında öğrendiğimiz ikinci derece denklem,
ax2 + bx + c = 0
şeklinde ifade edilir. Denklemin kökleri hakkında bilgi sahibi olabilmek için, denklemin diskriminantı adı verilen,
∆=b2–4ac
ifadesini hesaplamamız gerekir. Diskriminantın değerlerine göre, eğer ∆<0 ise denklemin gerçel sayılarla ifade edilebilecek bir kökü yoktur.
∆=0 ise denklemin, değerleri birbirine eşit olan iki kökü vardır ve bunlar,
x1=x2= –b/ (2a)
şeklinde hesaplanırlar. Bunlara iki kat kök ya da çakışık kök adı verilir.
∆>0 ise de denklemin birbirinden farklı iki gerçel kökü vardır ve bunlar,
x1=(–b+√∆)/(2a)
ve
x2=(–b–√∆)/(2a)
şeklinde hesaplanırlar.
Şimdi ikinci dereceden bir denklemin köklerini bulan Java programına bakalım.
KOD BLOĞU:
import java.util.Scanner;
public class IkinciDerece{
public static void main(String args[]){
Scanner giris = new Scanner(System.in);
double a, b, c, x1, x2, delta;
System.out.println("a: ");
a=giris.nextDouble();
System.out.println("b: ");
b=giris.nextDouble();
System.out.println("c: ");
c=giris.nextDouble();
delta = b * b - 4 * a * c;
if (delta < 0) {
System.out.println("Gercek kok yoktur. \n");
}
else if (delta == 0) {
x1 = -b / (2 * a);
System.out.println("x1=x2=" + x1);
}
else {
x1 = (-b + Math.sqrt(delta)) / (2 * a);
x2 = (-b - Math.sqrt(delta)) / (2 * a);
System.out.println("x1=" + x1);
System.out.println("x2=" + x2);
}
}
}
ÖRNEK ÇIKTI 1:
ÖRNEK ÇIKTI 2:
Soru İşareti Operatörü
if / else deyimi yerine kullanılabilecek bir seçenek de ? üçlü operatörüdür. Üçlü (ternary) operatör denmesinin nedeni doğal olarak üç tane operand ile işlem görmesidir.
? operatörü ile kontrol yapısının yazılış biçimi aşağıdaki gibidir:
İfade1 ? İfade2:İfade3;
Çalışma biçimi şu şekildedir:
İfade1 hesaplanır. İfade1’in değeri doğru (true) ise bu durumda ifade2 hesaplanır ve bir sonraki deyime geçilir. İfade1’in değeri yanlış (false) ise, ifade3 hesaplanır ve bir sonraki deyime geçilir.
? operatörü ile oluşturulan yukardaki kalıp,
if(ifade1) ifade2
else ifade3;
else ifade3;
yapısına denktir.
? operatörü, ifade1’in doğru ya da yanlış olması durumunda sadece bir deyimin çalıştırılacağı durumlar için if / else yapısı yerine kullanılabilir. İfade2 ve ifade3 yerinde fonksiyonlar da bulunabilir.
import java.io.IOException;
import java.util.Scanner;
public class Soru
{
public static void main(String args[]) throws IOException
{
Scanner giris = new Scanner(System.in);
String sonuc; double not;
System.out.println("Sinav notunu (0-100) giriniz: ");
not = giris.nextDouble();
sonuc = not >= 50 ? "Basarili" : "Basarisiz";
System.out.println("Sonuc: "+sonuc);
}
}
Örnek programın çıktısı:
switch / case Yapısı
Bir programda çok sayıda koşul kontrolü ve bunların sonucuna göre gerçekleştirilmesi gereken işlemler varsa, if-else yapıları ile akışın izlenmesi zorlaşabilir. Böyle durumlar genellikle switch deyiminin kullanılmasının gerekli olacağı durumlardır. switch deyimi, tek bir ifadenin değerine göre sınırsız sayıda çalıştırma yolu belirlemeyi sağlayan bir komuttur.
- switch sözcüğünden hemen sonra gelen ifade parantez içinde yer almalı ve bir tamsayı ifade olmalıdır.
- case anahtar sözcüklerini izleyen ifadeler tamsayı sabit türünde ifadeler olmalıdır, yani değişken içermemelidir.
switch deyiminin çalışma prensibi basittir. switch ifadesi hangi case’i izleyen sabitle çakışıyorsa, programın kontrolü o case’i izleyen kısma geçer. Bu case’den sonraki deyimler de kontrol edilmeden çalıştırılır.
case sabitlerinden hiçbiri ifade ile uyuşmuyorsa, programın akışı default‘u izleyen kısıma geçer. (Bu kısım mevcutsa) default‘un en sonda olması şart değildir. Fakat en sona koymak iyi bir programlama stilidir.
İki case sabiti aynı değeri alamaz.
Switch/case yapısında, programın kontrolünün ifadenin değerine göre case seçeneklerinden sadece birini çalıştırıp bundan sonra switch/case yapısını terketmesini isiyorsak bu durumda her case seçeneğinden sonra break komutu yerleştirmeliyiz.
- C DİLİ: Switch/case yapısında, programın kontrolünün ifadenin değerine göre case seçeneklerinden sadece birini çalıştırıp bundan sonra switch/case yapısını terketmesini istiyorsak bu durumda her case seçeneğinden sonra break komutu yerleştirmeliyiz.
- C# DİLİ: Her case’den sonra break kullanmamız gerekir.
Örnek Program:
import java.util.Scanner;
public class Cases{
public static void main(String args[]) {
Scanner giris = new Scanner(System.in);
int secim;
System.out.println("Secim yapiniz (1 - 2 - 3)");
secim=giris.nextInt();
switch (secim) {
case 1 :
System.out.println("A sinifi dergilerin listesi");
break;
case 2 :
System.out.println("B sinifi dergilerin listesi");
break;
case 3 :
System.out.println("C sinifi dergilerin listesi");
break;
default :
System.out.println("Hatali secim! 1, 2 ya da 3'e basiniz.");
break;
}
}
}
Bu programın çıktısı aşağıdaki gibi gerçekleşecektir:
switch / case yapısıyla ilgili örnek:
Bir turizm şirketi farklı tur çeşitlerinden oluşan bir liste sunuyor. Kullanıcı bu listeden ilgilendiği bir turu seçtiğinde, o turla ilişkili ayrıntılı bilgiye ulaşıyor. Burada aşağıdaki basit algoritmayı uygulayacağız
- Tur seçenekleri ekrana yazdırılır.
- Kullanıcıdan bu tur seçeneklerinden bir tanesini seçmesi istenir.
- Kullanıcının seçimine uygun olan tur hakkındaki bilgiler ekrana yazdırılır.
import java.io.IOException;
import java.util.Scanner;
public class Cases2{
public static void main(String args[]) throws IOException{
Scanner giris = new Scanner(System.in);
int i;
System.out.println("Portakal Turizm A.S. Sunar");
System.out.println("(1) Orta Avrupa Turu");
System.out.println("(2) Amerika Turu");
System.out.println("(3) Uzak Dogu Turu");
System.out.println("Seciminiz?");
i = giris.nextInt();
switch (i) {
case 1 :
System.out.println("Ucak ile Viyana, Budapeste, Prag");
System.out.println("4 yildizli otellerde sok! 1700$\n");
break;
case 2 :
System.out.println("Ozel ucak ile New York, Boston, Los Angeles");
System.out.println("5 yildizli otellerde sok! 3700$\n");
break;
case 3 :
System.out.println("Ozel ucak ile Bang Kong, Hong Kong");
System.out.println("Tokyo, Pekin");
System.out.println("5 yildizli otellerde sok! 4000$\n");
break;
default :
System.out.println("Hatali secim! 1, 2 veya 3 girilmeli");
break;
}
}
}
Programın çıktısı aşağıdaki gibi olacak:
while Döngüsü
Döngüsel işlem veya tekrarlı işlem (iterasyon, İng. iteration), bilgisayarı aynı işlem grubunu belirli bir koşul sağlanana kadar tekrar tekrar yapmak için yönlendirir. Java dilinde döngü yapısını oluşturmak için while döngüsü, do-while döngüsü ve for döngüsü kullanılır.
while döngüsü
While döngüsü bir şart sağlanıyor iken sürekli içindeki komutları çalıştırır. Kelime anlamı olarak "olduğu müddetçe" anlamı çıkar. Yapısı şöyledir:
while (koşul) {
//komut 1
//komut 2
//...
//komutlar
}
While döngüsünde koşulun en başta olması ayırt edici bir özelliktir. Program akışı önce buradaki koşulu mantıksal bir süzgeçten geçirir. Buna göre eğer koşula yazılan ifade matematiksel olarak true (doğru) değer döndürüyorsa, süslü parantezlerle çevrili bloktaki komutlar sırasıyla çalıştırılır. Ancak false (yanlış) değerini döndürüyorsa, bu komutlar hiçbir zaman çalışmayacaktır. Bu durumda program akışına döngünün bittiği yerden devam eder.
Koşulun true (doğru) döndürmesinin ardından bloktaki komutlar sırasıyla çalıştırılır ve son komut da çalıştırıldığında akış tekrardan koşulun olduğu satıra gelir ve koşulun true değer döndürüp döndürmediği kontrol edilir. Koşul doğru olduğu müddetçe komutlar çalıştırılır.
Şimdi, while döngüsünü kullanarak 10'dan geriye doğru giden ve bu sırada sayıları ekrana basan bir Java uygulaması yapalım:
public class WhileDongusu1 {
public static void main(String[] args) {
int sayac=10;
while (sayac>=1) {
System.out.println(sayac);
sayac--;
}
}
}
Bu uygulamanın ekran çıktısı çok basitçe
şeklinde olacaktır.
Aşağıdaki programda bir faktöriyel hesabı yapalım. 1'den 10'a kadar olan sayıların faktöriyelini ekrana basan bir Java programı olsun.
public class WhileDongusu2 {
public static void main(String[] args) {
int faktoriyel=1;
int carpan=1;
while(carpan<=10) {
faktoriyel=faktoriyel*carpan; //1*1, 1*2, 2*3, 6*4, 24*5...
System.out.println(carpan+" faktoriyel: "+faktoriyel);
carpan++;
}
}
}
Bu programın örnek ekran çıktısı şöyle olacaktır:
Yukarıdaki örnekte while döngüsü, programcı tarafından sınırları belli bir alanda çalışıyor: carpan değişkeni 10'a eşit veya küçük olduğu müddetçe. While döngüsü genelde tam sayı gibi sınırları kesin olarak belli alanlarda kullanılmaz. Sınırları kesin belli olan tekrarlamalar için sonraki bölümlerde göreceğiniz for döngüsü kullanılır.
Bir sonraki konuda, while döngüsünden tek farkı şartın yazıldığı yer olan do-while döngüsünü göreceksiniz.
do ... while Döngüsü
while deyiminin önemli bir özelliği, test koşulunun döngünün başlangıcında olmasıdır. Bunun anlamı, ilk anda koşulun yanlış olması halinde, while gövdesinin hiçbir zaman çalıştırılmayacağıdır. Ancak gövdeyi hiç olmazsa bir kere çalıştırmamız gereken durumlar vardır. Bu durumlar çok yaygın olmasa da gerektiği zaman do...while deyimini kullanmalıyız.
do..while döngü yapısının yazılışı şu şekildedir:
do {
Deyim1;
Deyim2;
...
Deyim_n;
} while(İfade) ;
do...while ve while döngüleri arasındaki tek fark, test koşulunun (ifadenin) do while döngüsünde, döngünün sonunda yer almasıdır. Bunun anlamı, programın döngüyü hiç olmazsa bir kez çalıştırmasıdır (ilk kez). Sonra, ifadenin değerine bağlı olarak, ifade doğru ise tekrar do'ya dönülerek döngü sürebilir veya ifade yanlış ise bir sonraki deyimle devam edilebilir.
int sayac = 1;
do {
System.out.println("Sayaç: " + sayac);
sayac++;
} while (sayac < 11);
for Döngüsü
for deyimi ve for deyimi kullanılarak oluşturulacak döngü yapısı, işlemlerin tekrar sayısının önceden belli olduğu durumlarda kullanılır.
for deyiminin yazılışı:
for(ifade1;ifade2;ifade3) Deyim;
Deyim_x;
veya
for(ifade1;ifade2;ifade3)
{ Deyim1;
Deyim2;
...
Deyim_n;
}
Deyim_x;
şeklindedir.
- İlk olarak ifade1 hesaplanır; bu genellikle bir ya da daha fazla değişkene ilk değeri veren bir atama deyimidir.
- Sonra ifade2 hesaplanır. Bu, deyimin koşulsal kısmıdır.
- ifade2 yanlışsa, programın kontrolü for deyiminden çıkar ve program akışı programdaki bir sonraki deyime geçer (deyim_x). Eğer ifade2 doğru ise, deyim veya deyimler grubu uygulanır.
- Deyim ya da blok yapılı şekilde deyimler grubu çalıştırıldıktan sonra, ifade3 çalıştırılarak hesaplanır. O zaman çevrim yine geriye, ifade2'ye döner.
İfade1 sadece bir kez çalıştırılır; ifade2 ve ifade3 ise, çevrimin her tekrarında (iteration) çalışıtırılır.
for deyimini anlamanın en iyi yolu, onu aşağıda olduğu gibi while deyimiyle karşılaştırmaktır.
for (ifade1; ifade2; ifade3)
deyim;
yapısı
ifade1;
while (ifade2)
{
deyim;
ifade3;
}
yapısı ile tamamen aynıdır.
Aşağıda basit bir örnek ile for döngü yapısını daha iyi anlamaya çalışalım:
ÖRNEK: for İLE TAM SAYILAR TOPLAMININ BULUNMASI
import java.util.Scanner;
public class PozTop{
public static void main(String args[]) {
Scanner giris = new Scanner(System.in);
int n, toplam;
int i;
System.out.println("Kaca kadar sayilar toplansin? ");
n = giris.nextInt();
toplam = 0;
for (i = 1; i <= n; i++) {
toplam += i;
}
switch (n) {
case 1 :
System.out.println("\n" + n + "=" + toplam);
break;
case 2 :
System.out.println("\n1+" + n + "=" + toplam);
break;
case 3 :
System.out.println("\n1+2+" + n + "=" + toplam);
break;
case 4 :
System.out.println("\n1+2+3+" + n + "=" + toplam);
break;
default :
System.out.println("\n1+2+3+..+" + n + "=" + toplam);
}
}
}
PROGRAMIN ÇIKTISI
Bu programda, for’un başlangıç koşulunu belirleyen ve ifade1 olarak belirttiğimiz ifade i=1 şeklindedir ve bu for döngüsünün parametresi diyebileceğimiz i değişkenine 1 değerini bir ilk değer olarak atamaktadır.
İfade2 ise, i <= n şeklinde bir koşul ifadesidir. i değişkeninin değeri n’den küçük ya da n’ye eşit olduğu sürece döngü sürecektir.
İfade3 ise i = i + 1 şeklinde bir artım ifadesidir ve döngünün her tekrarında i değişkeninin değerini 1 arttıracaktır.
Aşağıdaki tabloda döngü süresince i ve toplam değişkenlerinin değerlerinin nasıl değişeceğine bakalım:
| ÇEVRİM ADIMI | i | Toplam |
|---|---|---|
| Başlangıç, çevrim öncesi | 0 | |
| 1 | 1 | 1 |
| 2 | 2 | 3 (1+2) |
| 3 | 3 | 6 (1+2+3) |
| 4 | 4 | 10 (1+2+3+4) |
| 5 | 5 | 15 (1+2+3+4+5) |
Aşağıdaki program parçasında görüldüğü gibi,
for(i=1; i<=n; i=i+1) {
toplam=toplam+i;
}
System.out.println("\n1+2+3+..+"+n+"="+toplam);
System.out.println("\ni="+i);
döngüden çıkınca i’nin değeri yazdırılırsa,
i=6
değeri görünecektir.
ÖRNEK: FAKTÖRİYEL HESABI
for döngüsünü kullanacağımız diğer bir örnek program ise faktöriyel hesabı programı olacaktır. Matematikte faktöriyel bilindiği gibi,
n!=1.2.3...n
şeklinde tanımlanır; yani n sayısının faktöriyeli 1’den n’ye kadar tam sayıların çarpımına eşittir. Aşağıda, faktöriyel hesabıyla ilgili Java programı ve bu program içindeki değişkenlerin programın çalıştırılması sırasındaki değişimlerini gösteren tablo yer alıyor:
KOD BLOĞU:
import java.util.Scanner;
public class Faktoriyel{
public static void main(String args[]){
Scanner giris = new Scanner(System.in);
int n, fakt;
int i;
System.out.println("Kacin faktoriyeli bulunacak? ");
n = giris.nextInt();
fakt = 1;
for (i = 1; i <= n; i++) {
fakt = fakt * i;
}
switch (n) {
case 1 :
System.out.println("\n" + n + "=" + fakt);
break;
case 2 :
System.out.println("\n1*" + n + "=" + fakt);
break;
case 3 :
System.out.println("\n1*2*" + n + "=" + fakt);
break;
case 4 :
System.out.println("\n1*2*3*" + n + "=" + fakt);
break;
default :
System.out.println("\n1*2*3*..*" + n + "=" + fakt);
}
}
}
PROGRAMIN ÇIKTISI:
Faktöriyel Programındaki Değişkenlerin Programın Çalıştırılması Sırasındaki Değişimlerini Gösteren Tablo
| i | fakt | n |
|---|---|---|
| Çevrim Öncesi | 1 | 5 |
| 1 | 1 | 5 |
| 2 | 2(1*2) | 5 |
| 3 | 6(1*2*3) | 5 |
| 4 | 24(1*2*3*4) | 5 |
| 5 | 120(1*2*3*4*5) | 5 |
ÖRNEK: ALTERNE SERİ TOPLAMI
1.2/(3.4) - 5.6/(7.8) + 9.10/(11.12) - 13.14/(15.16)
şeklindeki alterne seri toplamını hesaplayalım. (Yukardaki ifadede "." sembolü çarpma işlemi anlamındadır.)
KOD BLOĞU:
public class Alterne {
public static void main(String args[]){
int i,p;
double x,s;
s=0;
p=1;
x=1.0;
for (i=1;i<=4;i++)
{
s=s+(x*(x+1))/((x+2)*(x+3))*p;
x=x+4;
p=-p;
}
System.out.println("Toplam= "+s);
}
}
PROGRAMIN ÇIKTISI:
| i | x | s | p |
|---|---|---|---|
| Çevrim öncesi | 1.0 | 0 | 1 |
| 1 | 1.0 | (1.2)/ (3.4) | 1 |
| 2 | 5.0 | (1.2)/ (3.4) – (5.6)/ (7.8) | –1 |
| 3 | 9.0 | (1.2)/ (3.4) – (5.6)/ (7.8) +(9.10)/ (11.12) | 1 |
| 4 | 13.0 | (1.2)/ (3.4) – (5.6)/ (7.8) +(9.10)/ (11.12) – (13.14)/(15.16) | –1 |
AÇIKLAMA:
Sadece 4 terim olduğu için for döngüsü 1’den 4’e kadar çalıştırıldı. İlk terim 1.2/ (3.4) ve ikinci terim 5.6/(7.8) olduğu için, x değişkeninin ilk terimdeki ilk sayıyı temsil ettiği durumda, terimi x.(x+1)/((x+2).(x+3)) şeklinde ifade edebiliriz. x yerine 1 koyarak bu durum kolayca kanıtlayabiliriz. İkinci terimde ilk sayı 5, üçüncü terimde ilk sayı 9 olduğuna göre x her seferinde 4 arttırılmalıdır. Bunu da programda x=x+4; deyimiyle gerçekleştiriyoruz. Bu terimi x+=4; şeklinde de yazabiliriz.
Seri alterne seri olduğuna göre, yani terimlerin işaretleri +,–,+,– şeklinde değiştiğine göre, p değişkeni yardımıyla terimlerin işaretlerini ayarlayabiliriz. p önce 1 olarak atanır. Sonra döngü içine konulan p=–p; ifadesi ise bir sonraki işareti –, bir sonrakini + ve onu izleyeni – yapar. (Programı kâğıt üzerinde adım adım izleyelim).
İç İçe Döngüler
Bir döngü yapısının içine başka bir döngü yapısının yerleştirilmesiyle elde edilen yapıya iç içe döngü (nested loop) adı verilir.
Java dilinde, if deyimlerini herhangi bir derinliğe kadar iç içe kullanmak nasıl mümkünse, döngü deyimlerini de iç içe kullanmak olasıdır. Şu kural iç içe döngüler için daima geçerlidir:
| İç içe döngülerde en içteki döngü en önce tamamlanır. |
İç İçe for Döngüleri İçin Örnekler
ÖRNEK 1:
Aşağıdaki programda, dış döngü olan a parametreli döngü 5 kez çalışıyor (a=1, 2, 3, 4, 5). a’nın her değeri içinse içteki döngü 3 kez çalışıyor (i=1, 2, 3). Böylece aşağıdaki çıktı elde ediliyor:
KOD BLOĞU:
public class IcIce
{
public static void main(String args[])
{
int a,i; //5 kez tekrarla
for(a=1;a<=5;a++)
{
System.out.println("a= "+a);
for(i=1;i<=3;i++) //3 kez tekrarla
{
System.out.println("i= "+i);
}
System.out.println();
}
}
}
PROGRAMIN ÇIKTISI:
ÖRNEK 2: ÇARPIM TABLOSU
1’den 10’a kadar sayılar için bir çarpım tablosu hazırlamak istiyoruz. Bunun için iç içe 2 döngü yeterlidir ve her iki döngünün de parametresi 1’den 10’a kadar değişecektir. Programın kodu şu şekildedir:
KOD BLOĞU:
public class CarpimTablosu
{
public static void main(String args[])
{
int altcizgi, i, j;
System.out.println(" 1 2 3 4 5 6 7 8 9 10 ");
for(altcizgi=1; altcizgi<=70; altcizgi++) //döngüyle uzunca bir çizgi çizelim
{
System.out.print("_");
}
System.out.println();
for (i =1; i<=10; i++)
{
System.out.print(i+" | ");
for (j=1 ; j<=10 ; j ++)
{
System.out.print(i*j +" ");
}
System.out.println();
}
}
}
PROGRAMIN ÇIKTISI:
ÖRNEK 3: FAKTÖRİYELLİ TERİMLERDEN OLUŞAN SERİ TOPLAMI
Aşağıdaki seri toplamını hesaplayacak bir Java programı yazalım:
1/ 2! + 1/3! + 1/4! +...+ 1/10!
Bu seri toplamını hesaplamak istediğimizde, iç içe iki döngü kullanmak gerektiğini hemen anlarız:
- Her adımda, bir toplama işlemi gerektiren, terimlerin toplanmasının gerekli olduğu bir döngü (Yukarıdaki tek döngü örneklerindeki 1 + 2 + 3 + ... + n toplamı örneğini hatırlayalım.)
- Yukarda belirtilen döngünün her parametre değeri için, o adımdaki faktöriyeli hesaplatmak zorunda olduğumuz ve o nedenle yukarıdaki döngünün içinde yer alması gereken bir döngü.
KOD BLOĞU:
public class FaktoriyelliSeri
{
public static void main(String args[])
{
double s,fakt;
int i,j;
s=0;
for (i=2;i<=10;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);
}
}
PROGRAMIN ÇIKTISI:
Programın çalıştırılması sonucu i, j, s ve fakt değişkenlerinin alacağı değerlerle ilgili tabloya göz atalım:
| DIŞ ÇEVRİM | İÇ ÇEVRİM | FAKTÖRİYEL | TOPLAM |
|---|---|---|---|
| i | j | fakt | s |
| 0 | |||
| 2 | 1 | 1 | 0 |
| 2 | 2 | 2 | 1/2 |
| 3 | 1 | 1 | 1/2 |
| 3 | 2 | 3 | 1/2 |
| 3 | 3 | 6(1.2.3=3!) | 1⁄2+1/6 |
| 4 | 1 | 1 | 1⁄2+1/6 |
| 4 | 2 | 2 | 1⁄2+1/6 |
| 4 | 3 | 6 | 1⁄2+1/6 |
| 4 | 4 | 24(1.2.3.4=4!) | 1⁄2+1/6+1/24 |
| ... | ... | ... | ... |
| 10 | 10 | 10! | 1⁄2+1/6+1/24+.. +1/20! |
SORU: Yukarıdaki seri toplamını, sadece bir for döngüsü kullanarak hesaplatabilir miyiz?
CEVAP: Evet. Yukarıdaki seri toplamını tek bir for döngüsü ile hesaplatan ve aynı sonuçları elde eden Java programının kod bloğu şöyledir:
public class FaktoriyelliSeri2
{
public static void main(String args[])
{
double s,fakt;
int i;
s=0;
fakt=1;
for (i=2; i<=10; i++)
{
fakt=fakt*i;
s=s+1/fakt;
System.out.println(s);
}
System.out.println("Seri toplami: "+s);
}
}
PROGRAMIN ÇIKTISI
break Deyimi
break deyiminin Java programları içinde iki farklı kullanım alanı vardır:
- switch yapısındaki case seçeneklerinden birinde switch yapısını terk etmek ve switch’i izleyen deyime geçmek için kullanılır. (Bu tip kullanımla ilgili örnekler switch deyimi anlatılırken verilmiştir.)
- Bir döngü (loop) yapısı içinden, döngüyü kontrol eden koşul ifadesini beklemeksizin döngü dışına çıkmak için kullanılır.
break deyimi bir döngü içinde yer almışsa bu durumda break deyimi ile karşılaşır karşılaşmaz döngü dışına çıkılır ve döngüyü izleyen deyime geçilir.
ÖRNEK PROGRAM:
import java.util.Scanner;
public class BreakClass{
public static void main(String args[]) {
Scanner giris = new Scanner(System.in);
double ort;
int sayac, toplam, sayi;
toplam = 0;
sayac = 0;
System.out.println("Alt alta pozitif sayilar gireceksiniz ve negatif sayi");
System.out.println("girene kadar onlar toplanacak. Negatif girdiginizde");
System.out.println("toplama isleminin sonucu size verilecektir.");
while (true) {
System.out.print("Sayi giriniz: ");
sayi = giris.nextInt();
if (sayi < 0) {
break;
}
toplam += sayi;
sayac++;
}
ort = toplam / sayac;
System.out.println("Toplami "+toplam+" olan "+sayac+" tane sayi girdiniz.");
System.out.println("Sayilarin ortalamasi da "+ort);
}
}
PROGRAMIN ÇIKTISI:
continue Deyimi
continue deyimi, döngü içinde belirli bir koşulun kontrolüyle bir sonraki döngü adımına gidilmesini gerçekleştirir.
ÖRNEK:
Aşağıdaki programda for döngüsünün parametresi olan i değişkeni 3 ile tam bölünemeyen bir değer alınca, bu değer ile işlem yapılmayıp bir sonraki adıma geçilmesi continue deyimi ile sağlanıyor. Böylece program, kullanıcı tarafından girilen bir üst limite kadar, 3 ile bölünebilen sayıların toplamını ve bu tip sayıların adedini buluyor.
ÖRNEK PROGRAM:
import java.util.Scanner;
public class Cont{
public static void main(String args[]) {
Scanner giris = new Scanner(System.in);
int toplam, i, ustlimit, sayac;
System.out.println("Gireceginiz ust limite kadar olan ve");
System.out.println("3'e bolunebilen sayilar bulunacaktir.");
System.out.println();
System.out.println("Ust limiti giriniz: ");
ustlimit = giris.nextInt();
toplam = 0;
sayac = 0;
for (i = 1; i <= ustlimit; i++) {
if (i % 3 != 0) {
continue;
}
System.out.println("3'e bolunebilen sayi: " + i);
toplam += i;
sayac++;
}
System.out.println("3-" + ustlimit + " arasindaki 3 ile bolunebilen "+sayac+" tane sayi var.");
System.out.println("Bu tur sayilarin toplami " + toplam);
}
}
PROGRAMIN ÇIKTISI:
Yorumlar
Yorum Gönder