AnaSinif.java
[IMG]
import javax.swing.*;
public class AnaSinif{
public static **** main(String arg[]){ boolean deger1 = true; boolean deger2 = false;
boolean sonuc1 = deger1 && deger2;
JOptionPane.showMessageDialog(null, "deger1: " +deger1+"deger2: "+deger2+ "deger1 && deger2 ->"+ sonuc1);
boolean sonuc2 = deger1 || deger2;
JOptionPane.showMessageDialog(null, "deger1: " +deger1+"\ndeger2: "+deger2+
"\ndeger1 || deger2 -> "+ sonuc2);
deger2 = true;
sonuc1 = deger1 && deger2;
JOptionPane.showMessageDialog(null, "deger1: " +deger1+"\ndeger2: "+deger2+ "\ndeger1 && deger2 -> "+ sonuc1);
deger1 = false; deger2 = false;
sonuc1 = deger1 || deger2;
JOptionPane.showMessageDialog(null, "deger1: " +deger1+"\ndeger2: "+deger2+
"\n\ndeger1 && deger2 -> "+ sonuc1);
}
}
[IMG]
>, <, >=, <= operatöleri:
Bu operatörler de çift taraflı çalışırlar ve eğer sağ sol değerleri gerçeklenirse true aksi taktirde false değerini üretirler. Örneğin:
3 > 5 //false
4 < 10 //true
3 >= 3 //true
() Tür Dönüştürme Operatörü
Şu ana kadar öğrendiğimiz kadarıyla belli bir türe ilişkin değerleri aynı türden değişkenler içerisinde saklıyor ve kullanabiliyorduk. Ancak bazı durumlarda farklı türlerin birbirleriyle işleme girmeleri ve bir türe ilişkin bir değerin aynı olmayan türde bir değişkene atanması gibi işlemler gerekebilir. İşte bu gibi durumlarda bir tür dönüşümü söz konusu olabilir.
Tür dönüşümleri de belirli kurallar dahilinde ve belirli bir hiyerarşi ile olmaktadır. Tür dönüşümleri sırasında bazen bilgi kaybının da olabileceğini unutmamak gerekir. Bunun nedenin her türün ifade ettiği bilginin sınırlarının ve hafızada kapladığı alanın farklı olmasından kaynaklandığını hatırlayınız. Aşağıda bilgi legal olan tür dönüşümleri özetlenmektedir:
byte -> short (bilgi kaybı yok)
short -> int (bilgi kaybı yok)
char -> int (bilgi kaybı yok)
int -> long, double (bilgi kaybı yok), float (bilgi kaybı olabilir)
long -> float, double (bilgi kaybı olabilir)
float -> double (bilgi kaybı yok)
Bilgi kaybı, dönüşümlerde hedef veri tipinin sınırlarının dar olmasından kaynaklanır. Mesela
int n = 123456789; float f = n; //f in degeri 1.2345692E8 olur.
Yukarıdaki dönüşüler otomatik olarak gerçekleşen dönüşümlerdir. Ancak kasıtlı olarak da tür dönüşümü yapılabilir.Bir değerin türünü dönüştürmek için değerin soluna parantez içerisinde değiştirmek istediğiniz türün adını yazmanız gerekir.
[IMG]
public class AnaSinif{ public static **** main(String arg[]){ double k = 12.96;
System.out.println("k nin deeri: "+ k); int c;
c = (int)k; //burada double türünden bir deer int türünden bir degiskene
atanyor.
System.out.println("c nin degeri: "+c); }
}
[IMG]
Bu örnekte gördüğümüz gibi k değişkeninin içerisindeki değer c değişkenine atandığı için c nin değerinin de 12.96 olmasını beklerdik. Ancak atama sırasında ( ) operatörü ile bir tür dönüşümü yaptık ve bilgi kaybından dolayı c nin değeri 12 oldu. Çünkü int türünden bir değişken virgülden sonra değer alamaz.
Tür Dönüşümlerine İlişkin Özel Metodlar
Tür dönüşümlerini ( ) operatüörü ile yapabileceğimiz gibi bu iş için yazılmış bazı özel metodları da kullanabiliriz.
Mesela String olarak verilmiş olan 12 değerini 12 sayısı gibi kullanamayız. Çünkü bu değer çift tırnak içerisinde verilmiştir ve bir String'dir. Yani siz bu değerle bir sayıyı toplamaya kalkarsanız sonuç da otomatik tür dönüşümünden dolayı bir String olacaktır. Şu örneğe dikkat edelim:
[IMG]
public class AnaSinif{
public static **** main(String arg[]){
String a = "12"; int b = 13; String c = a + b;
System.out.println("Sonuc: "+c);
}
}
[IMG]
Gördüğünüz gibi java a+b işleminin sonucunu bir String türü olarak belirlemek konusunda bizi zorlamaktadır. Sonucu string olarak hesapladığımzda da bu sefer cevap 25 olması gerekirken 1213 tür. Aslında bu sonuç bir sayı değil bir Stringdir. Yani bir görüntüdür. O halde sayı gibi verilmiş bir Stringi nasıl sayıya çevireceğiz? Bunun için kullanılacak metod Integer isimli bir sınıfın parseInt() isimli metodudur. Mesela kullanıcıdan
JOptionPane.showInputDialog() metodu ile yaşını isteylelim ve girdiği yaş ile 3 sayısını çarpıp sonucu bulalım.
Ancak biliyoruz ki bu şekilde alınan girişler sayı olarak değil String olarak algılanıyorlar. O halde bu String'i de Integer.parseInt() metodu yardımıyla int türüne dönüştürelim:
import javax.swing.*; public class AnaSinif{ public static **** main(String arg[]){
String yas = JOptionPane.showInputDialog(null, "Yasinizi
giriniz: "); int sonuc = Integer.parseInt(yas) * 3;
JOptionPane.showMessageDialog(null, "Hesap sonucu: "+sonuc); }
}
Buna benzer diğer metodlar:
Integer.toString(12); --> parantez içerisinde verilen int türünü String'e çevirir.
Double.parseDouble(12); --> parantez içerisinde verilen int türünü double türüne çevirir. Double.toString(12.45); --> parantez içerisinde verilen double türünü String'e çevirir.
Bunlar gibi daha birçok metod vardır. Bunların kullanımı yeri geldikçe dökümantasyon yardımıyla öğrenilebilir.
Stringler
Daha önce sözdizimi olarak da bahsettiğimiz bu tür aslında bir karakter dizisidir. Stringler çift tırnak içerisinde yazılır ve kendilerine ait bir takım özel metodlara sahiptir. Bu bakımdan diğer türlerden biraz daha farklıdır. Burada istenen, Stringlerin metodlara sahip olduğu kavramını vurgulamak ve gerektikçe bu metodları kullanabileceğimizi göstermektir. Bu amaçla bütün metodlar burada anlatılmayacaktır:
string.length Değişkeni
Bu değişken bir stringin kaç karakterden oluştuğunu yani uzunluğunu verir.
string.equals(diger string) Metodu
İki String türüne ilişkin değerlerin eşitliğini sayısal değerlerde kulandığımız == operatörü ile kontrol edemeyiz. Bunun yerine String.equals metodunu kullanırız. Bu metod, kendisine parametre olarak verilen diger string değeri eğer string degerine eşitse true, degilse false degerini üretir.
string.compareTo(diger string) Metodu:
Bu metod kendisine parametre olarak verilen diger string ile string değerini kıyaslar. Eğer iki string eşitse metod 0 değerini, string büyükse 1 değerini, diğer string büyükse de -1 değerini üretir.
import javax.swing.*; public class AnaSinif{ public static **** main(String arg[]){
String isim = JOptionPane.showInputDialog(null, "Lutfen adnizi
giriniz"); int uzunluk = isim.length;
String mesaj = "Isminiz "+uzunluk+" tane karakterden
olumaktadir";
JOptionPane.showMessageDialog(null, mesaj);
String gercekSifre = "kkVVuuNN";
String girilenSifre = JOptionPane.showInputDialog(null, "Sifreyi
giriniz: "); boolean sonuc = gercekSifre.equals(girilenSifre);
JOptionPane.showMessageDialog(null, "Girdiiniz sifre: "+sonuc); }
}
Yukarıdaki örnekte, JOptionPane sınıfının showInputDialog() isimli metodu yardımıyla kullanıcının klavyeden girdiği string, isim değişkenine atılmakta ve daha sonra da girilen bu stringin uzunluğu öntanımlı isim.length değişkeni ile alınıp uzunluk değişkenine atanmaktadır. Biz aslında length isminde bir değişken yaratmadığımız halde, yukarıda anlatıldığı gibi isim değişkeni aslında bir String olduğu için, kendi bünyesinde otomatik olarak bu length değişkenini ve diğer String metodlarını barındırmaktadır. Nitekim örnekte de gördüğümüz gibi; gercekSifre isimli String değişkeni ile equals isimli öntanımlı metodu kullanarak, iki stringi birbirleriyle kıyaslayabilmekteyiz.
Vazgeçilmez Kaynağınız: Java Dökümantasyonu!
Daha önce de sık sık Java'da bir çok sınıfın kullanım amacı ile daha önceden yazılmış olduğuna ve bu sınıfların içerisinde de, kullanabileceğimiz bir çok değişken ve metod olduğuna değinmiştik. Hangi sınıfların ne işe yaradıklarını, ve içlerinde hangi metod ve değişken barındırdıklarını ve bunları nasıl kullanabileceğimizi ezbere bilmek imkansızdır. İşte bu yüzden, her java programcısnın vazgeçemeyeceği java dökümantasyonunu kullanmak gerekir.
Dökümantasyonu online olarak Oracle Technology Network for Java Developers | Oracle Technology Network | Oracle adresinde bulacağınızı ilk dersimizde söylemiştik.
[IMG]
Bu sayfayı açtığınızda karşınıza üç çerçeveden oluşmuş bir ekran gelmektedir. Bu ekranda, sol üst kısımda All Classes isimli bağlantıyı tıkladığınızda, sol at kısma Java'da öntanımlı tüm sınıfları temsil eden bağlantılar yüklenecektir. Hakkında bilgi almak istediğiniz sınıf ismini bulup üzerine tıkladığınızda da sağdaki kısma bu sınıf hakkındaki tüm metodlar, değişkenler ve bilgiler gelecektir. Resim 7'de çok sık kullandığımız JOptionPane isimli sınıfın showMessageDialog isimli metoduna ilişkin bölümü görmekteyiz.
Bu dökümantasyonu online olarak görüntüleyebileceğiniz gibi, bilgisayarınıza indirip offline olarak da kullanabilirsiniz. Bu işlem için Oracle Technology Network for Java Developers | Oracle Technology Network | Oracle sayfasından dökümantasyonu indirebilir ve yine aynı sayfada bulacağını kurulum talimatları ile (Installation Instructions) sisteminize yükleyebilirsiniz.
Java ile Programlama Bölüm 3:
Bundan önceki dersimizde Java programlama dilinde değişkenlerin nasıl kullanıldıklarını operatörleri ve vazgeçilmez kaynağınız olan Java Dökümantasyonu'nu nasıl kullanacağımız öğrenmiştik. Bu sayımızda işi biraz daha ileri götürecek ve program akışını kendi isteğimiz doğrultusunda yönlendirebileceğimiz deyimler ve döngüleri öğreneceğiz.
Yeni bir dil öğrenmenin en zor yanı, dilin temel kurallarını öğrenme aşamasının oldukça yoğu ve sıkıc geçmesidir.
Bunun nedeni de öğrenme aşamasında sınırlı bilgiyle henüz ele avuca sığar uygulamalar geliştiremiyor olmamızdır. Sizlerin de şu aşamada aynı sıkıntıyı çektiğinizi tahmin ederek, motivasyonunuzu artırmak amacıyla java içerisinde yer alan demoları göstermek istiyorum. Az sonra nasıl çalıştırabileceğinizi anlatacağım bu uygulamaları inceleyerek, ileride varacağınız noktayı görme şansına sahip olacaksınız:
Okumaktan Sıkılanlar İçin
Demolar sdk ana dizini içerisinde bulunan demo isimli dizinde bulunmaktadır. Sdk ana dizininiz sizin java'yı ilk yüklediğiniz yerdir ve ismi de muhtemelen j2sdk.1.3.1 ya da j2dk1.4.2 şeklinde olacaktır. Benim linux sistemimde ana dizinin tam yolu: /opt/j2sdk_nb/j2sdk1.4.2/ şeklindedir. Buradaki demo isimli dizinin içinde de, jfc ve onunda için de SwingSet2.jar adındaki uygulamayı önce jfc dizini içerisine girerek şu şekilde çalıştırabilirsiniz:
java -jar SwingSet2.jar
Bu uygulamayı dilediğiniz gibi karıştırabilir hatta j2sdk dizini içerisindeki demo dizinin ve altındaki diğer tüm uygulamaları da inceleyebilirsiniz.
[IMG]
Java'da Deyim ve Döngüler:
Program yazarken, yazdığımız kodların yukarıdan aşağıya doğru sırasıyla çalıştırıldığını biliyoruz. Ancak bazen bu kodların bu sırada değil de belirli şartlara bağlı olarak birkaç satırın atlanıp ileriden devam edilmesi ya da aynı satırların birden fazla sayıda çalıştırılması gibi isteklerimiz olabilir. İşte bunun için kullnacağımız bazı deyimler ve döngüler vardır. Bu deyim ve döngüler sayesinde normalde her satırdan bir defa geçen ve yukarıdan başlayarak aşağı satırlara doğru ilerleyen program akışını, bazı satırları belli durumlarda okumadan, ya da bazı satırları birden fazla defa okuyacak şekilde yönlendirmemiz mümkün hale gelir.
Ancak bu deyim ve döngülerin daha iyi anlaşılması açısından öncelikle faliyet alanı kavramına değinmekte yarar var.
Faliyet Alanı Nedir Ne İşe Yarar?
Faliyet alanı, yazdığımız program içerisinde belirli bölgeleri temsil eden ve nesnelerin etkin olduğu sınırları belirleyen alanlardır. Bir nesnenin etkin olduğu bölgeye, o nesnenin faliyet alanı denilmektedir.
Faliyet alanı kod içerisinde { ve } ile belirlenmektedir. Bu iki parantez arasında mevcur bir faliyet alanı vardır. Bir değişken eğer { ve } arasında tanımlanmışsa bu değişken bu iki parantez dışında kullanılamaz. Buna göre değişkenin faliyet alanı da bu iki parantez içerisinde ya da yaratıldığı alan içerisinde sınırlıdır.
/**** Main.java ****/
import javax.swing.*;
class Main {
public static **** main(String[] args) { int k = 10;
{
int c = 20;
JOptionPane.showMessageDialog(null, "k nin degeri: "+k+ "\nc nin degeri: "+c);
}
System.exit(0);
}
}
/*******************/
Bu örnekte iki tane faliyet alanı görmekteyiz. Birinci faliyet alanı sınıfımızın kendisidir ve sınıf adı Main yazıldıktan hemen sonra { ile açılmış ve tüm satırlardan sonra da } ile kapatılmıştır. Bu faliyet alanının içinde de k değişkeni tanımlandıktan sonra yine { ile başka bir faliyet alanı açılmış ve bu yeni faliyet alanında da sadece c değişkeni yaratılmıştır. Ancak dikkat ederseniz bu örnekte, sınıfın faliyet alanı, içeride açılan faliyet alanını kapsamaktadır. Bu yüzden k değişkeni tanımlanmamış olduğu içerideki faliyet alanı içerisinde de kullanılabilir. Ancak tersi mümkün değildir. Yani c değişkenini k'nin tanımlı olduğu faliyet alanında kullanmaya kalksaydık hata mesajı alacaktık.
/**** Main2.java ****/
import javax.swing.*;
class Main2 {
public static **** main(String[] args) { int k = 10;
{
int c = 20;
}
JOptionPane.showMessageDialog(null, "k nin degeri: "+k+
"\nc nin degeri: "+c);
/*c degiskeni bu faliyet alanında tanımlı degildir*/
System.exit(0);
}
}
//bu program çalışmayacaktır
/*******************/
Faliyet alanına ilişkin unutulmaması gereken bir şey daha vardır: Aynı faliyet alanı içerisinde, aynı isimli birden fazla değişken tanımlanamaz. Bu örnekte k nın faliyet alanı, c nin faliyet alanını da kapsadığından, c nin tanımlandığı yerde k adında başka bir değişken daha tanımlayamazsınız. Çünkü başka faliyet alanı olsa da, içerideki faliyet alanında yukarıda tanımlanan k değişkeni hala geçerlidir. Buna dikkat ediniz.
Faliyet alanına ilişkin bu bilgilerle artık deyim ve döngüleri inceleyebiliriz.
if Deyimi:
if deyimi belli bir şart sağlanması durumunda program akışını kendi faliyet alanı içerisine yönlendirir. Kendi faliyet alanının en son satırına kadar kodları çalıştırır ve daha sonra da program akışı if deyiminin faliyet alanının bittiği yerden devam eder.
[IMG]
/***** Deyimler1.java ********/
import javax.swing.*;
class Deyimler1 {
public static **** main(String[] args) {
String notStr;
int not;
notStr = JOptionPane.showInputDialog(null, "Notunuzu giriniz: ");
not = Integer.parseInt(notStr);
if(not > 50) {
JOptionPane.showMessageDialog(null, "Tebrikler. Bu dersten gectiniz
");}
System.exit(0);
}
}
/**********************/
[IMG]Daha teknik söylemek gerekirse, şartın sağlanması demek, aslında if deyiminin kontrol parantezleri içerisindeki ifadenin true olması demektir. (Bundan önceki sayıda anlattığımız, boolean türü ve boolean operatörleri konusunu hatırlayınız!). Aynı şekilde bu şartın sağlanmaması ise ifadenin false değerini üretmesi anlamına gelir. Yukarıdaki örnekte not > 50 ifadesi eğer false olursa ekrana hiç bir mesaj gelmeyecektir. Ancak true olursa Tebrikler. Bu dersten geçtiniz mesajını alırsınız. Burada girdiğiniz notun aslında bir String türünde olduğunu ve bu değerin Integer sınıfının parseInt metoduyla sonradan integer türüne dönüştürlüp kullanıldığına dikkat ediniz. (Bundan önceki sayıda yer alan Tür Dönüşümlerine İlişkin Özel Metodlar konusunu hatırlayınız.)
Peki ya eğer kullanıcı notu 50'den küçük olsa da bir mesaj almak istiyorsa ne yapacak. İşte bu durumda
.....
if(ifade) {
....
[IMG]} else { ....
}
kalıbını kullanmak gerekecektir. Bu kalıba göre program akışı, eğer if içerisindeki ifade true ise if deyiminin, değilse else deyiminin faliyet alanı içerisine yönlencektir. Az önceki örneği genelleştirelim:
/***** Deyimler2.java ********/
import javax.swing.*;
class Deyimler2 {
public static **** main(String[] args) {
String gectiMesaji = Tebrikler! Bu dersten gectiniz!;
String kaldiMesaji = Malesef bu dersten kaldiniz.;
String notStr;
int not;
notStr = JOptionPane.showInputDialog(null, "Notunuzu giriniz: ");
not = Integer.parseInt(notStr);
if(not > 50) {
JOptionPane.showMessageDialog(null, gectiMesaji);
}
else {
JOptionPane.showMessageDialog(null, kaldiMesaji);
}
System.exit(0);
}
}
/**********************/
[IMG]Aktif olarak projelerde çalıştığınız zaman kullanıcı isteklerinin bitmediğini göreceksiniz
Diyelim ki bu sefer de kullanıcı programa girdiği nota göre bir harf ile derecesini öğrenmek istiyor olsun. Bu durumda girilen not belli aralıklara göre belli dereceler alacaktır ve bu dereceler 2 taneden fazla olabilir. O zaman da if else kalıbı işe yaramayacaktır. Bu durumlarda if, else if, else if, .... , else kalıbını kullanmak gerekir. Örneği inceleyiniz:/****** Deyimler3.java ******/
import javax.swing.*;
class Deyimler3 {
public static **** main(String[] args) {
String kaldiMesaji = "Dereceniz F: Bu dersten kaldiniz.";
[IMG] String yanlisNot = "Yanlis not girisi! Tekrar deneyiniz.";
String notStr; int not;
notStr = JOptionPane.showInputDialog(null, "Notunuzu giriniz: ");
not = Integer.parseInt(notStr);
if(not > 100 || not < 0) {
JOptionPane.showMessageDialog(null, yanlisNot );
}
else if(not <= 100 && not > 86) {
JOptionPane.showMessageDialog(null, "Dereceniz: A");
}
else if(not <= 85 && not > 71) {
JOptionPane.showMessageDialog(null, "Dereceniz: B");
}
else if(not <= 70 && not > 66 ) {
JOptionPane.showMessageDialog(null, "Dereceniz: C");
}
else if(not <= 65 && not > 50) {
[IMG] JOptionPane.showMessageDialog(null, "Dereceniz: D");
}
else {
JOptionPane.showMessageDialog(null, kaldiMesaji);
}
System.exit(0);
}
}
while Döngüsü:
[IMG]Kullanıcı istekleri hala bitmiyor
Şimdi de kullanıcımız bizden program çalıştığında sürekli notu sormasını ve buna karşılık düşen dereceyi bize vermesini istiyor. Ne zaman ki giriş Q karakteri olur, o zaman program sonlansın diyor. Bu durumda not girişi bir döngü içerisine sokulmalıdr. Bu döngünün en başında önce girişin Q olup olmadığına bakılmalı sonra ya döngü tekrar dönmeli ya da sonlandırılmalıdır. Bunun için en uygun döngü while döngüsü olacaktır. while, eğer içerisindeki ifade true ise program akışını kendi içine yönlendirir. Program while faliyet alanının en sonuna geldiğinde tekrar while döngüsünün ilk satırına döner ve ifadeyi yine kontrol eder. Bu işlem, while içerisindeki ifade false olana kadar devam eder.[IMG]
Not: Bu tür döngülerde, eğer döngünün faliyet alanı içerisindeyken, while içerisideki
ifadeyi değiştirecek bir komut yazmazsanız, ilk durumda bu ifade hep true olduğu için
ve döngü içinde de hiç değişmediği için sonsuz bir döngüye girersiniz.
while(ifade) { satir 1 satir 2
...
satir n
/*şSimdi akisş tekrar while(ifade) satirina yönlenecek ve kontrol yapılacaktır. eğer
ifade false olmussa program akışı
satir n+1 den devam etmektedir.*/
} satir n+1
Bu durumda kullanıcımızın yeni isteğine göre örneği tekrar düzenleyelim:
/**** Deyimler4.java ****/
import javax.swing.*;
class Deyimler4 {
public static **** main(String[] args) {
String yanlisNot = "Yanlis not girisi! Tekrar deneyiniz.";
[IMG] String giris = "Bir not giriniz (0 - 100)\nÇikis için notu -1 giriniz";
String notStr; int not;
notStr = JOptionPane.showInputDialog(null, giris);
not = Integer.parseInt(notStr);
while(not != -1) {
if (not > 100) {
JOptionPane.showMessageDialog(null, yanlisNot);
}
else if (not <= 100 && not > 86) {
JOptionPane.showMessageDialog(null, "Not: " + not + " Derece: A");
}
else if (not <= 85 && not > 71) {
JOptionPane.showMessageDialog(null, "Not: " + not + " Derece: B");
}
else if (not <= 70 && not > 66) {
JOptionPane.showMessageDialog(null, "Not: " + not + " Derece: C");
}
else if (not <= 65 && not > 50) {
JOptionPane.showMessageDialog(null, "Not: " + not + " Derece: D");
} else {
JOptionPane.showMessageDialog(null, "Not: " + not + " Derece: F");
}
[IMG] notStr = JOptionPane.showInputDialog(null, giris ); not = Integer.parseInt(notStr);
}
JOptionPane.showMessageDialog(null, "Program Sonlandi.");
System.exit(0);
}
}
/**************************/
break Anahtar Sözcüğü:
[IMG]Bazen bir döngü içerisindeyken, aslında döngünün bitmesine neden olacak şart sağlanmadığı halde özel olarak döngüyü sonlandırmak istediğimiz durumlar doğacaktır. Bu durumların sağlanması neticesinde program break komutunu gördüğü yerde içerisinde bulunduğu ilk döngüyü (çünkü iç içe döngüler de olabilir) sonlandıracak ve döngüden sonraki satırdan itibaren çalışmaya başlayacaktır.
/**** Sifre.java ****/
import javax.swing.*;
public class Sifre {
public static **** main(String arg[]) {
String kontrol_isim = "elvantasbas";
[IMG] String k_adi = JOptionPane.showInputDialog(null, "Lutfen kullanici adini giriniz:");
boolean x_flag = false;
while(!k_adi.equals(kontrol_isim)) {
if(k_adi.equals("x")) {
[IMG] JOptionPane.showMessageDialog(null, "Islem sonland?r?l?yor.."); x_flag = true; break;
}
k_adi = JOptionPane.showInputDialog(null, "Girdiginiz isim yanlis. Tekrar
giriniz:");
}
if(x_flag) {
JOptionPane.showMessageDialog(null, "Hoscakalin");
}
else {
[IMG] JOptionPane.showMessageDialog(null, "Merhaba "+k_adi); }
System.exit(0);
}
}
/********************************/
Programda while parantezi içerisinde yazılı olan while(!k_adi.equals(kontrol_isim) komutuna göre eğer k_adi kontrol_isim'e eşit olursa k_adi.equals(kontrol_isim) metodu true değerini üretecektir. Ancak bu metodun başında yazılı olan ! operatörü bu değerin değilini alacak ve false değeri üretecektir. Demek ki kullanıcı adı doğru girilmediği sürece bu while parantezi içerisinde true değeri olacak, doğru girldiği zaman ise false değeri olacak ve dolayısı ile while bloğuna girilmeyecektir.
[IMG]Bu örnekte kullanıcı, kullanıcı adını yanlış girdiği ama x girmediği sürece while döngüsü bloklarında kullanıcıdan tekrar isim girmesi istenecektir. İsim yanlış girildiğinde ve x girildiğinde program while içerisindeki if bloğuna girecek ve burada işlem sonlandırılıyor mesajı ile döngüden break sayesinde çıkacaktır. Döngüden çıkmadan hemen önce x_flag değişkeninin değeri de true yapıacaktır. Bu değişken döngüden x ile çıkılıp çıkılmadığı bilgisini tutmak için kullanılan bir ara değişkendir. Döngüden çıkıldıktan sonra eğer x değişkeninin değeri true ise while blokları bitimindeki if bloklarına girilecek ve ekrana hoşçakalın mesajı yazılacaktır. Eğer döngüden x yazıldığı için değil de kullanıcı adı doğru girildiği için çıkılmış ise x değişkenin değeri false kaldıdğı için if bloğuna girilmeyecek onun yerine else bloğuna girilecektir. Buradaki mesaj ekrana geldikten sonra else bloğundan da çıkılacak ve System.exit(0) metodu çalıştırılarak program sonlandırılacaktır.
for Döngüleri:
Şu ana kadar bir koşul sağlandığı sürece otomatik olarak döngüye girilmesini while deyimi ile yapabileceğimizi gördük. Ancak bu döngü koşul sağlandığı sürece, belli bir tekrar sayısı kadar değil her zaman devam ediyordu. Koşul sağlansa bile belirli bir tekrar sayısı da belirlemek istiyorsak o zaman for döngüsünü kullanmak gerekir. for döngüsü şöyle çalışmaktadır:
for( <ilk deger> ; <kosul> ; <ifade> ) {
...
}
Buna göre ilk değer ile başlayan döngü ile program for bloğuna girdikten sonra bloğun sonuna geldiğinde koşulun
sağlanıp sağlanmadığını kontrol edecek ve koşul sağlanıyorsa ifade yi gerçekleyip tekrar döngüye girecektir
.
Örneğin:[IMG]
/**** ForDongusu.java ****/
public class ForDongusu {
public static **** main(String arg[]){
for(int i = 0; i < 10; i++) {
System.out.println("i nin degeri: "+i);
}
}
}
[IMG]/***********************/
Bu program çalıştığında ekrana 10 satır boyunca
i nin degeri: 0 i nin degeri: 1
...
i nin degeri: 9
yazacaktır. Program akışı her döngüye girişinde i nin değeri ekrana yazılmakta ve blok sonunda i++ ifadesinden
dolayı bu değer bir artırılmakta ve koşulun sağlanıp sağlanmadığına bakılmaktadır.
switch Deyimi:
switch deyimi kullanımı da, birden fazla else if kullanımına alternatiftir. Mesela yazdığınız programda kullanıcıdan bir giriş isteyebilirsiziniz. Kullanıcının gireceği bu değer 4 tane değerden birtanesi olabilir ve siz olası her değer içöin bir işlem yapmak istiyor olabilirsiniz. Bunun için
if(deger 1) {
}
else if(deger 2) {
} ... else {
}
yapısını kullanabilirsiniz. Ancak böyle durumlarda switch daha iyi bir alternatif olacaktır. switch deyimi de şöyle çalışmaktadır:
switch( <degisken> ) { case deger1: ifade ya da islemler;
break;
case deger2: ifade ya da islemler;
break;
...
... case deger n: ifade ya da islemler;
break;
default: ifade ya da işlemler; break;
}
Bu yapıya göre program akışı, degisken içindeki değere göre case anahtar sözcüğü ile belirlenmiş uygun satıra atlar. O satudaki ifade ya da işlemler gerçekleştirilikten sonra switch deyiminden çıkılır. Aşağıdaki örnek programımızda kullanıcıya bir menü sunalım ve bu menüden bir seçeneği seçmesini isteyelim. Bu seçim neticesinde de seçime uygun bir mesajın ekrana gelmesini sağlayalım. Örneğimizde ilk başta yaratılan secim_flag adındaki boolean değişken ilk değer olarak true olduğu için, program akışının ilk seferde while döngüsüne gireceğini garanti etmiş oluyoruz. Eğer kullanıcı listede olmayan bir seçim girecek olursa, secim_flag değişkeni tekrar true değerini alacak ve kullanıcıdan tekrar bir giriş yapması istenecektir. Kullanıcı listede olan bir giriş yaparsa program sonlanacaktır. Bu durumda listede olmayan girşler girldiği sürece program çalışmaya devam edecektir.
/**** Menu.java ****/
import javax.swing.*;
public class Menu {
public static **** main(String arg[]){
boolean secim_flag = true;
while(secim_flag) {
String secim = JOptionPane.showInputDialog(null, "Bir sayi giriniz: (1, 2, 3,
4)");
int sayi = Integer.parseInt(secim);
secim_flag = false;
switch(sayi) { case 1:
[IMG] JOptionPane.showMessageDialog(null, "Sectiginiz sayi: bir"); break; case 2:
JOptionPane.showMessageDialog(null, "Sectiginiz sayi: iki"); break; case 3:
JOptionPane.showMessageDialog(null, "Sectiginiz sayi: uc"); break; case 4:
JOptionPane.showMessageDialog(null, "Sectiginiz sayi: dort"); break; default:
secim_flag = true;
JOptionPane.showMessageDialog(null, "Beklenenden farkli bir sayi girdiniz"); break;
}
}
System.exit(0);
}
}
/****************************/
continue Anahtar Sözcüğü
Herhangi bir döngü içerisine girildğinde, daha döngü bloğunun sonuna gelinmeden o andaki adım için işlemleri sonlandırıp bir sonraki döngü adımına hemen geçilmek isteniyorsa continue anahtar sözcüğünü kullanmak gerekir. Mesela yazdığımız programda 1'den 10'a kadar olan sayılar toplamak istiyoruz ama bu toplam içerisine 3 ve ün katlarını eklemek istemiyoruz. Bunun için bir for döngüsü kullanmak gerekir. Ancak bu döngüyü 3 ve 3'ün katlarına gelindiğinde durdurup bir sonraki değerle döngüye devam etmek gerekmektedir:
/**** Toplama.java ****/
public class Toplama {
public static **** main(String arg[]){ int toplam = 0;
for(int i = 0; i < 10; i++) {
if(i % 3 == 0) { continue;
}
toplam += i;
}
JOptionPane.showMessageDialog(null, "Toplam: " + toplam);
System.exit(0);
}
}
[IMG]Bu örnekte % operatörünü kullandık. Bu operatör soldaki sayının sağdaki sayıya bölümünden kalan değeri üretir. Yani i sayısı o anda hangi değere sahipse, bu değerin 3'e bölümünden kalan sayının 0'a eşit olup olmadığı kontrol edilmektedir. Eğer bu kalan sayı 0'a eşit ise demek ki sayımız ^ya da 'ün bir katıdır. Bu yüzden if parantezi içerisindeki == kontrolü sağlandığından dolayı true değeri üretilecek ve dolayısı ile if bloğu içerisine girilecektir. If bloğu içerisinde continue anahtar sözcüğü sayesinde o andaki for adımı sonlanacak ve bir sonraki i değeri ile for bloğunun en başına dönülecektir.
Diziler
Bu ana kadar programla içerisinde kullanacağımız değişkenler olduğunu ve bu değişkenlerin de belirli türelere sahip olduklarını görmüştük. Ancak biliyoruz ki her değişken sadece bir değer tutmaktadır. İçerisinde değer tutan bu değişkenler de bellekte farklı yerlerde saklanmaktadır.
Dizi denilen değişkenler ise içlerinde birden fazla değer tutarlar ve diğer değişkenler gibi belirli bir türe sahiplerdir. Ayrıca bu değerler de bellekte ardışıl biçimde saklanırlar ve hepsi aynı türe ilişkin olmak zorundadır. Buna göre bir diziyi aslında arka arkaya sıralanmış bir değişken paketi olarak düşünebiliriz.
Ancak şunu unutmamalıyız: Dizilerin içlerinde tutacakları eleman sayısı sahiptir. Bazı elemanlara siz değer vermesseniz bile bu elemanlar için bellekte yer ayrılır. Ayrıca dizinin içerisinde saklanan değerlerin türü ile dizinin türü aynı olmak zorundadır.
Dizilerin Yaratılması:
Normalde değişkenleri yaratırken değişkenin türünü ve sonra da adını yazıyorduk. (int b; ya da double a; gibi) Dizilerin yaratılması ise biraz daha farklıdır. Bir dizinin yaratılması iki adımdan oluşur. Birinci adım bildirim dediğimiz ve dizinin türünü ve dizi değişkeninin adını belirlediğimiz adımdır:
int [] sayilar;
Burada sayilar adinda ve içerisinde integer değerler tutacak olan bir dizi bildirimi yapmış olduk. Ancak bu dizi bildiriminin değişken bildiriminden farkının [ ] karakterlerinin eklenmesi şeklinde olduğuna dikkat ediniz.
İkinci adım ise tahsisat denilen ve dizi değişkenin kaç tane değer tutacağını belirlediğimiz adımdır:
sayilar = new int[10];
Bu örnekte, daha önce bildirimini yaptığımız sayilar dizisine 10 tane integer sayı tutabilecek kadar alanı tahsis etmiş olduk. Bu işlem aslında new anahtar sözcüğü sayesinde yapılmış oldu. Ancak, bu adımdan sonra dizi değişkenimiz belirlenmiş ve değerleri saklayabileceği alan tahsis edilmiş olsa bile, dizimizin içerisinde hala hiç bir değer saklanmamaktadır. Dizilerin içerisinde elemanlara erişmek ve yeni elemanlar eklemek için indeks numarası denilen bir kavram kullanılmaktadır. Indeks operatörü [ ] ile gösterilir ve dizinin adının yanına ekleneek kullanılır. Bir dizinin ilk elemanın indeks numarası 0 dır. Buna göre dizimize değer atamak için:
sayilar[9] = 12; sayilar[0] = 3; şeklinde [ ] ve bir indeks numarası kullanılarak atama yapılabilir.
NOT: Burada dikkat edilmesi gereken şey, dizimizin uzunluğundan daha fazla eleman ataması yapmamaktır. Bu örneğimize göre sayilar dizisinin son elemanına sayilar[9] ile erişebiliriz. Sayilar[10] = 23; hatalı bir atama olacaktır çünkü 10 nolu indekste 11. eleman olur. Ancak dizimiz sadece 10 eleman tutacak alan tahsis edilmişti!
Şimdi kullanıcıdan gelecek olan isimleri bir dizide saklayan bir program yazalım:
/**** Kayit.java ****/
1 import javax.swing.*;
2
3 public class Kayit {
4 public static **** main(String arg[]){
5
6 String kayit_str = JOptionPane.showInputDialog(null, "Kac tane kayit gireceksiniz:");
7 String cikisMesaji = "Hernagi bir anda cikmak icin "
8 int kayit = Integer.parseInt(kayit_str);
9
10 String isimler[] = new String[kayit];
11 for(int i = 0; i < isimler.length; i++) {
12 int sayi = i+1;
13 String giris = JOptionPane.showInputDialog(null, sayi + ". kaydi giriniz:");
14 if(giris.equals(X))
15 break;
16 else
17 isimler = giris;
18 }
19
20 String mesaj = "isim Listesi\n********"; 21
22 for(int i = 0; i < isimler.length; i++) {
23 if(isimler != null)
24 mesaj += "\n"+i+" --> "+isimler;
25 }
26
27 JOptionPane.showMessageDialog(null, mesaj);
28 System.exit(0);
29 }
30 }
/******************/
Bu programda önce kullanıcının kaç kayıt gireceği sorulmaktadır. Çünkü dizilerin uzunluğu sabittir ve önceden bir defa yer ayrıldığından bu uzunluk bilinmelidir. Uzunluğu değişen dizileri için başka algoritmik çözümler vardır ancak değişmeyen şer bir dizinin uzunluğu sabittir ve sonradan uzatılıp kısaltılamaz.
Bu örnekte kullanıcının gireceği kayıt kadar yer tahsisati yapıldıktan sonra for döngüsü ile her adımda girilecek olan kayıt istenmekte ve diziye atılmaktadır. Eğer kullanıcı başta belirlediği kadar kayıt girmekten vazgeçip o anda işlemi sonlandırmak isterse isim yerine X girişi yapabilecektir. Programda her giriş yapıldıktan sonra bu değerin X olup olmadığına bakılmaktadır (14. satır). Eğer giriş X olursa döngü break ile sonladırılır (15. satır). Değilse giriş diziye yazılır ve döngü devam eder (16. satır).
NOT: String türünde diziler için tahsis edilen yerlerin içine birşey doldurulmaz ise, bu yerler otomatik olarak null denilen özel bir değerle doldurulur. null değeri , gibi boş bir String ya da 0 değildir. Kendi başına anlamlıdır.
Bu döngü bittikten sonra yeni bir for döngüsü ile de diziden her kayıt tek tek okunmakta (22. satır) ve mesaj adındaki String değişkeni içerisine atılmaktadır (24. satır). Daha sonra bu mesaj isimli değişken ekrana yazılacaktır (27. satır). Eğer kullanıcı diziye ayrılan yer kadar kayıt girmeyip arada X ile çıkış yapmışsa, bu durumda diziye girilmemiş olan elemanlar yerine null değeri olacaktır. Bu değerler varsa mesaj içerisine eklenmemektedir. Bu yüzden o andaki adımda, diziden gelen değerin null olup olmadığı kontrol edilmekte, değer null değilse mesaj değişkeninine eklenmektedir (23. satır).
Dizilere ilişkin temel bilgileri öğrenmeyi burada sonandırıyoruz. Siz de kendi yeteneklerinizi sınamak icin diğer dersimize kadar tüm öğrendiklerinizi kullanarak aşağıdaki uygulamayı yapmaya çalışınız. Bu uygulamanın cevabını diğer dersimiz içerisinde bulabileceksiniz :
Dizi Yaratma Şekilleri
1) int a[]; a = new int[3];
a[0] = 1, a[1] = 2, a[2] = 3;
2) int a[] = {12, 3, 6, 7}
3) new int[] {1,4,5,6}
