/**
* BÖLÜM 1 - JAVA VE NESNEYE YÖNELİM
* Enterprise projeler için olmazsa olmaz iki kavram modülerlik ve soyutlamadır.Nesneye yönelik uygulama geliştirme ile nesneye yönelik olmayan yöntemler arasındaki en çok dikkat çeken fark şudur
*
* Nesneye yönelik olmayan geleneksel uygulama geliştirme tarzında önceden tanımlanarak sınırlandırılmış soyutlama yöntemleri bulunurken nesne yönenimli uygulama geliştirme tarzında geliştirici tanımlı soyutlama yöntemleri bulunmaktadır.
* Neden Nesne ? Java bunun için 4 sebep göstermiş :
* 1) Modülerlik : Bir nesnenin kaynak kodu diğer nesnelerden ve programdan bağımsız olarak yazılabilir, değiştirilebilir.
* 2) Bilgi Saklama : Dış dünya bir nesnenin sadece metotlarına erişebilir. Böylelikle nesneye ait özel kalması gereken detaylar gizli kalır. Böylece uygulamalarda beklenmedik durumların ortaya çıkması engellenir.
* 3) Kodu Tekrar Kullanabilme : Eğer bir nesne daha önceden herhangi bir geliştirici tarafından yazılmış ve beklenen sonuçları vermekte başarılı ise sonradan geliştirilen uygulamalarda gönül rahatlığıyla kullanılabilir.
* 4) Hata Ayıklama Kolaylığı : Tüm kod değil, sadece ilgili kısım düzeltilerek uygulamaların bakım ve hata ayıklamalarda performans sağlanır. Nesne yönenimli yaklaşımda "is a" ve "has a" ilişkisi esas alınmaktadır.
* is a ilişkisi => Alt sınıf - üst sınıf yani alt küme-üst küme hiyerarşisini ifade eder. Örneğin otomobil bir kara taşıtıdır.
* has a ilişkisi => Bir sınıfa ait özellikleri yani sınıfa ait verilerin tutulmasını açıklar. Örneğin otomobil bir direksiyona sahiptir.
*
* BÖLÜM 2 - JAVA TEMEL BİLGİLER
* Derleyici : Tüm kaynak kodun çalıştırılmadan önce makine koduna çevrilmesi işlemine derleme, bu işlemi yapan programa da, derleyici -compiler- denir. Bu işlemin bir avantajı bir de dezavantajı vardır. Avantajı proje bir kere derlenip çalıştırıldığından dolayı sağladığı performanstır. Dezavantajı ise derlenen kod belirli bir işlemci türü ve işletim sistemine göre yapılacağından her platformda çalışmaz.
* Yorumlayıcı : Kaynak kodunun, makine koduna çevrilme ve çalıştırılma işleminin aynı anda olmasına yorumlama, bu işlemi yapan programa da yorumlayıcı -interpreter- denir. Az biraz yavaştır ama Java her işletim sistemi için bir yorumlayıcıya sahip olduğundan platform bağımsızlığı sağlar.
* Java derleme ve yorumlama yöntemlerini bir arada kullanır. İlgili kaynak kod bir ara dile(bytecode) çevrilir yani derlenir, sonra bu arada kalmış kodlar çalışma zamanında çalıştırılır, yani yorumlanır. Bu işlemleri Java için Java Sanal Makinesi - JVM(Java Virtual Machine) yürütür.
* Paket Kavramı : Paket, birbirleri ile mantıksal olarak ilişkili olan ilişkili sınıfların aynı klasör altında toplanmasıdır.
* Nesne Kavramı : Nesne(object) yapısal bir değişken kümesidir ve içerisinde kendisine ait değişkenler ve kendi durumunu değiştirmek için kullanılan metotları vardır.
* Sınıf Kavramı : Sınıfın içerisinde nesneye ait olan değişkenlerin ve metotların tanımlanması yapılır. Yani nesnelerin neler yapabilecekleri hangi işlemleri yapmaya yetkili oldukları belirlenir.
* Metot Kavramı : Nesnelerin davranışları metotlarla gerçeklenir. Metotlar bildiğimiz fonksiyon ve prosedürlerdir.
*
* Java Dilinin Temel Özellikleri:
* - Platform bağımsızdır. Farklı donanım ve yazılım sistemlerinde kod üzerinde değişiklik yapmadan çalışır.
* - Nesneye yönelik bir programlama dilidir.
* - Java dili içerisinde birçok amaç için tasarlanmış kütüphaneler ve sınıflar bulunmaktadır.
* - Söz dizimi C++'a benzemektedir.
* - İşaretçiler (Pointer) yoktur.
* - Kullanılmayan değişkenler otomatik olarak bellekten silinir. Bu işlemi çöp toplayıcı(garbage collector) adındaki bir program yapar.
* - Java yorumlanan ve derlenen bir programlama dilidir.
* Bir Java programı herhangi bir editörde yazılır ve uzantısı ".java" olacak şekilde kaydedilir. Bu kod Java derleyicisi tarafından bytecode haline getirilir. Oluşturulan derlenmiş dosyanın uzantısı ".class" dır. Oluşturulan bytecode'lar Java Sanal Makinesi(JVM) tarafından yorumlanır.
* JDK: Java Developer Kit, Java ile geliştirdiğimiz uygulamaları derleyip çalıştırmamızı sağlayan kütüphaneler paketidir.
* JRE: Java Runtime Enviroment, Java ile daha önceden yazılmış ve derlenmiş uygulamaları çalıştırmak için kullanılır. JDK kurulumu yapıldığında otomatik olarak bilgisayara kurulmaktadır.
* JVM: Java Virtual Machine, Java sanal makinesi yani geliştirdiğimiz uygulamaları bilgisayar üzerinde çalıştıran ve işletim sistemi bağımsızlığı sağlayan sanal araç. Bu paket derlenmiş kodları makine diline çevirip yani derlenmiş bytecode'ları yorumlayıp her işletim sistemine uygun komut kümelerinine dönüştürerek platform bağımsızlığı sağlar. JVM ilk yorumlama işleminde gerekli kütüphaneler için JRE'ye başvurmaktadır.
*/
package programlama.hafta1;
public class ProgramlamaHafta1
{
public static void main(String[] args)
{ //KOD YAZILMAYA BURADAN BAŞLANIYOR !
System.out.println("Merhaba KSU");
System.out.println("MerhabaKSU");
System.out.println("Merhaba" + "KSU");
System.out.println("15"+15);
System.out.println();
//print komutundan sonra imleç aynı satırda kalır.
System.out.print("Merhaba");
System.out.print("KSU");
System.out.println("Mühendislik ve Mimarlık Fakültesi");
//println den sonraki gelen ifade bir alt satıra yazılacaktır.
System.out.println("aradaki farka dikkat edelim");
System.out.println();
/*
String ile başlayan ve onu izleyen veri tipleri kendiliğinden String tipine dönüştürülür.
System.out.println("15"+15) ya da System.out.println("Merhaba"+"Java") da olduğu gibi söz diziminin çıktısı 1515 şeklinde olacaktır.
Normalde + bir aritmetik operatördür ve toplama işlemini gerçekleştirir. Ancak "15" String bir ifade olduğundan, + toplama işlemini yapmaz sadece rakamları yan yana getirir.
System.out.print() Deyimi Ekrana yazı yazmak için kullanılan ifadedir.
System.out.print(); , System.out.println(); , System.out.printf() gibi üç ayrı şekilde kullanılır.
System.out.println(); ifadesi ekrana yazdırılanları satır atlatarak yazdırır.
System.out.print(); ifadesi ekrana bitişik yazılar yazdırır.
System.out.printf(çıkış formati, çıktı alınacak ifade); kalıbına uygun çalışır.
*/
/* BÖLÜM 4 - TEMEL - İLKEL (PRİMİTİF) VERİ TİPLERİ
Veri Tipleri gerçek hayatta kullandığımız tamsayılar, ondalıklı sayılar, harfler, isimler gibi verilerin bilgisayar-Java ortamındaki görüntüleridir. Primitif veri tipleri bellekte sabit yer tutarlar.
Tam Sayılar
Byte : -128 ile 127 arasında değer alabilir.8-bit
Short : -32768 ile 32767 arasında değer alabilir.16-bit
Integer: -2 Milyar ile +2 Milyar arasında değer alabilir.32-bit (En çok kullanılan veri tipidir)
Long : -9 Katrilyon ile 9 Katrilyon arasında değer alabilir.64-bit
Ondalıklı-Kayar Noktalı Sayılar
Float : Bu veri tipi vigülden sonra 7 haneye kadar yeterli duyarlılıktadır.Kullanacağımız çoğu ondalıklı değer için yeterli duyarlılıktadır.32-bit.Tek duyarlıdır.
Double : Bu veri tipi virgülden sonra 17 haneye kadar yeterli duyarlılıktadır.Çift duyarlı 64-bit.
Karakter
Char : Bu veri tipi Java'da karakter temsil eder.16-bit yer kaplarlar.Gerçekte işaretsiz bir tamsayı değerine sahiptir.(Unicode)
Mantıksal
Boolean : Bu veri tipi sadece true-false değerini alabilir.Mantıksal işlemin sonucu doğru ise true,yanlış ise false değerini alırlar.
Başlangıç Değerleri
Değişkenlere başlangıçta değer atanmamış ise string tipinde olanlar null değerini,boolean tipinde ise false değerini diğer tüm ilkel tipler 0 değerini alırlar.
*/
// Değer Atama - Karakter Atama
byte byteSayi=(byte) 15;
short shortSayi=(short) 7;
int intSayi=12345;
long longSayi=1234567890;
float floatSayi=1.1234567f;
String isim="Bilgehan";
boolean dogruMu;
dogruMu=false;
boolean yanlisMi=true;
System.out.println(intSayi);
System.out.println("intSayi =" +intSayi);
System.out.println(longSayi);
System.out.println("longSayi =" +longSayi);
System.out.println(floatSayi);
System.out.println("floatSayi" +floatSayi);
System.out.println('e');
System.out.println(isim);
System.out.println("isim :" + isim);
System.out.println("Yıl 2017 :" +yanlisMi);
System.out.println("Yıl 2018 :" +dogruMu);
// Wrapper'lar : int,float,byte,short,long,double gibi değişkenler Java tarafından performans kaygıları nedeniyle nesne olarak algılanmamaktadır.Java bu değişkenleri ilkel veri tipleri diye adlandırmaktadır.Ancak ilkel veri tiplerinin Java'da birer sınıf karşılığı bulunmaktadır. Bu karşılıklara kapsayıcı -wrapper sınıf adı verilmektedir. int==Integer, double==Double gibi büyük harfle başlarlar. Nesneye yönenimde oldukça sık kullanılırlar.
}
}
package programlama.hafta2;
public class ProgramlamaHafta2 {
public static void main(String[] args)
{
/* BÖLÜM 5 - TİP DÖNÜŞÜMLERİ, CASTING
Java uygulamalarında kullanılan veri türleri arasında uyumsuzluk oluştuğunda boyutu küçük olan veri tipi otomatik olarak boyutu büyük veri tipine dönüştürülür. Örneğin int veri tipinin long veri tipine dönüştürülmesi vb.Çünkü bu dönüşümler esnasında veri kaybı olmaz.Yani tamsayılar kendi aralarında,gerçel sayılar kendi aralarında küçük tipten büyüğüne otomatik dönüştürülür. Tam tersi durumda ise VERİ KAYBI OLACAKTIR. Aslında tip dönüşümleri genelde büyükten küçüğe uygulamalarda ve tamsayı-gerçel sayı dönüşüm uygulamalarında kullanılmaktadır diyebiliriz.
*/
int intSayi;
float floatSayi=3.23f;
double doubleSayi=12.12;
//intSayi=floatSayi; kod çalışmaz.
intSayi=(int) floatSayi;
System.out.println("floatSayi = "+floatSayi);
System.out.println("intSayi = " +intSayi);
//aşağıda int-double arasında casting yapalım
int intSayi2=15;
double doubleDonusum;
doubleDonusum=(double) intSayi2;
System.out.println("doubleDonusum " +doubleDonusum);
//Primitif Veri Tipleri ve Karakter Katarları Dönüşümleri (String veri tipinin sayısal veri tiplerine dönüştürülmesi)
/*String veri tipinin sayısal veri tiplerine dönüştürülmesi için iki yöntem kullanabiliriz.
...............valueOf(String);
...............parse..(String);
noktalarla boş bırakılan alanlarda dönüştürülecek veri tiplerinin nitelikleri vurgulacaktır.
*/
String s1="12";
String s2="13";
int intDonusum1= Integer.valueOf(s1);
int intDonusum2=Integer.parseInt(s2);
int islem=intDonusum1+intDonusum2;
System.out.println("intDonusum1 = " +intDonusum1);
System.out.println("intDonusum2 = " +intDonusum2);
System.out.println("Toplam : " +islem);
//Primitif Sayısal Veri Tiplerinin String Veri Tipine Dönüştürülmesi
/*
Bunun için üç yöntem kullanabiliriz.
String stringDonusum=donustureceğimiz değer +"";
yada
""+donustureceğimiz değer;
String stringDonusum1=String.valueOf(sayi);
String stringDonusum2=......toString(sayi);
*/
int donusum=15;
float donusumf=15.15f;
double donusumd=15.15;
String stringDonusumInt="" +donusum;
String stringDonusumInt1=String.valueOf(donusum);
String stringDonusumInt2=Integer.toString(donusum);
String stringDonusumFloat=donusumf+"";
String stringDonusumFloat1=String.valueOf(donusumf);
String stringDonusumFloat2=Float.toString(donusumf);
System.out.println("stringDonusumInt =" +stringDonusumInt);
System.out.println("stringDonusumInt1=" +stringDonusumInt1);
System.out.println("stringDonusumInt2=" +stringDonusumInt2);
System.out.println("stringDonusumFloat =" +stringDonusumFloat);
System.out.println("stringDonusumFloat1=" +stringDonusumFloat1);
System.out.println("stringDonusumFloat2=" +stringDonusumFloat2);
/* BÖLÜM 6 - JAVA OPERATÖRLERİ
Günlük hayatımızda matematiksel işlemleriçin kullandığımız ifadelerin (=,+,-,*,/,%) Java'da ifade ediliş halleridir.
*/
}
}
package programlama.hafta3;
public class ProgramlamaHafta3
{
public static void main(String[] args)
{
/* BÖLÜM 9 - KONTROL YAPILARI ve BÖLÜM 10 - Java SE7 (String İfadeler ve Switch Yapısı)
Kontrol deyimleri bir kod parçacığının yürütülmesi sırasında, program akışını yönlendiren kalıplardır. Aksi belirtilmedikçe uygulama ilk ifadeden son ifadeye doğru çalışır. Ancak programlama dilleri bu akışı değiştiren ya da akış içerisindeki ifadenin kaç kere çalıştığını belirleyen bazı cümleciklere sahiptirler.
Javada 4 çeşit kontrol yapısı vardır.
1.Karşılaştırma ifadeleri : if, if-else, switch case
2.Döngü ifadeleri : while, do-while, for
3.Dallanma ifadeleri : break, continue, label: ,return
4.İstisna ifadeleri : try, catch, finally, throw
*/
/* 1.Karşılaştırma İfadeleri : if,if-else,switch-case deyimleri veya Seçimli yapılar(Selection Structure) olarak da adlandırılırlar. Uygulamada bir şart ya da seçime bağlı yapılardır. Bu yapıların hepsinin koşul kısmında mutlaka karşılaştırma operatörlerinden bir tanesi bulundurulmalıdır. (==,!=,<,>,<=,>=,)
*/
//İf Deyimi :Tek seçimli yapı olarak ifade edebiliriz. Koşula bağlı olarak tek bir işlemi yerine getiren yapıdır.İşlem sırasında boolean sonuç döndürür.Koşul doğru(true) ise işlem yapar, koşul yanlışsa işlem yapmaz.if cümlesinden sonra {} parantez gelmelidir.Bu parantez uzun kod bloklarında anlaşılabilirliği sağlayacaktır.
int birinciSayi=8;
int ikinciSayi=5;
if(birinciSayi<ikinciSayi)
{
System.out.println("birinciSayı ikinciSayıdan kucuktur");
}
if(birinciSayi>ikinciSayi)
{
System.out.println("birinciSayi ikinciSayıdan buyuktur");
}
if(birinciSayi !=ikinciSayi)
{
System.out.println("birinciSayı ikinciSayı ya eşit değildir");
}
System.out.println();
//Birden fazla önermeyi bir if cümleciğinde birleştirme
int yas =20;
int dogumTarihi=1997;
if(yas==20 && dogumTarihi==1997)
{
System.out.println("Yazılanlar doğrudur");
}
if(yas==20 && dogumTarihi==2007)
{
System.out.println("Yazılanlar doğru değildir");
}
if(yas==20 || dogumTarihi==2000)
{
System.out.println("yazılanların bir kısmı doğrudur");
}
System.out.println();
//Kenar uzunlukları verilen herhangi bir üçgenin tipini belirleyelim
int a=5;
int b=4;
int c=4;
if(a==b && b==c)
{
System.out.println("Üçgenimiz,eşkenar üçgendir");
}
if(a==b || b==c)
{
System.out.println("Üçgenimiz, ikizkenar üçgendir");
}
if(a!=b && b==c)
{
System.out.println("Üçgenimiz, ikizkenardır");
}
System.out.println();
/* if-else Deyimi, Çift Seçimli Yapı
if cümleciğini kodumuza uyguladığımızda sadece true durumlar için değerler üretebiliriz. Ancak bazı şartlarda false durumlar için de değerler üretmemiz gerekecektir. if-else deyimi burada devreye girmektedir.
if(kosul)
{
durum true olduğunda çalışacak kod blogu
}
else
{
durum false olduğunda çalışacak kod blogu
}
*/
// Basit if-else örneği
int Sayi3=15;
int Sayi4=25;
if(Sayi3>Sayi4)
{
System.out.println("birinci sayı ikinci sayıdan büyüktür");
}
else
{
System.out.println("ikinci sayı birinci sayıdan küçüktür");
}
System.out.println();
/* ! UYARILAR !
- Her else deyimi bir if cümleciğinin sonrasında gelmelidir.
- Else deyimi if cümlesinin kapsamadığı diğer tüm durumları kapsar.
- if-else deyimlerine ait kod bloklarından sadece birisi çalışır.Her ikisine ait kod blokları aynı anda çalışmaz.
- Birden fazla if deyimi ve bir tane else deyimi varsa else deyimi kendinden önce gelen if deyimine aittir.
*/
//else-if Deyimi
int puan=85;
char sonuc;
if(puan>=88)
{
sonuc='a';
}
else if(puan<=90)
{
sonuc='b';
}
//aşağıdaki c seçeneği daha kesin olsa da bu yapı şartları sağlayan ilk kod bloğunu çalıştırmaktadır.
else if(puan==85)
{
sonuc='c';
}
else
{
sonuc='d';
}
System.out.println("sonuc : " +sonuc);
System.out.println();
/*if-then-else
değişken=(değer1==değer2)?0:(değer3/değer4);
Java yukarıdaki kalıpla oluşturulan kod parçasını değerlendirmeye aldığında,ilk olarak soru işaretinin sol tarafındaki ifadeye bakar. Eğer karşılaştırma doğru ise soru işareti ve iki nokta arasındaki ifade döndürülür.Yani iki noktanın solundaki değer tüm ifadeye de atanır. Eğer soldaki karşılaştırma doğru değil ise iki noktadan sonra gelen ifade çalıştırılır ve sonuç tüm ifadenin değeri olarak atanır.
*/
int x=24;
int y=3;
int z=99;
int w=1;
int e=(y>=3)? 111:(x/y);
int f=(w<=1)? 0:(x/y);
int g=(w==0)? 0:(x/y);
System.out.println("e= "+e);
System.out.println("f= "+f);
System.out.println("g= "+g);
/*Switch-Case Yapısı- Çok Seçimli Yapı
Verilen değişkenin değerlerine göre yapılacak farklı işlemlerin seçimlerinde kullanılır.Tamsayıları karşılaştırarak doğru koşulların elde edilmesini sağlar.Double Float gibi ondalıklı veri tipleri veri kayıplarına neden olma ihtimali sebebiyle kullanılmaz. Java, switch deyimi ile başlayan cümlelerde sıra ile tüm case bloklarını tarar.Uygun bir case işlemi bulduğunda çalıştırır.Her koşuldan sonra break deyimi kullanılmalıdır.Aksi halde sağlanan koşuldan sonraki tüm koşullar java tarafından doğruluğu kontrol edilmeksizin çalıştırılır.
!! Java SE7'ye kadar, switch yapısında sadece sayısal ve char değerleri kıyaslayabiliyorduk, Java SE7 den itibaren String ifadeleri de kıyaslayabiliyoruz.
*/
//Haftanın günlerini sorgulayalım
int gun=5;
switch(gun)
{
case 1: System.out.println("Pazartesi"); break;
case 2: System.out.println("Salı"); break;
case 3: System.out.println("Çarşamba"); break;
case 4: System.out.println("Perşembe"); break;
case 5: System.out.println("Cuma"); break;
case 6: System.out.println("Cumartesi"); break;
case 7: System.out.println("Pazar"); break;
}
System.out.println();
//break deyimi kaldırılırsa
int gun2=5;
//haftanın 5.gününden sonra bütün günleri döndürür.
switch(gun2)
{
case 1: System.out.println("Pazartesi");
case 2: System.out.println("Salı");
case 3: System.out.println("Çarşamba");
case 4: System.out.println("Perşembe");
case 5: System.out.println("Cuma");
case 6: System.out.println("Cumartesi");
case 7: System.out.println("Pazar");
}
System.out.println();
//hiçbir koşulun sağlanmaması (default) durumu
int gun3=8;
switch(gun3)
{
case 1: System.out.println("Pazartesi"); break;
case 2: System.out.println("Salı"); break;
case 3: System.out.println("Çarşamba"); break;
case 4: System.out.println("Perşembe"); break;
case 5: System.out.println("Cuma"); break;
case 6: System.out.println("Cumartesi"); break;
case 7: System.out.println("Pazar"); break;
default: System.out.println("Hiçbir koşul sağlanmıyor.");
}
System.out.println();
//Java SE7 ile gelen String ifadenin sorgulanması
String gun4="Cumartesi";
switch(gun4)
{
case "Pazartesi" : System.out.println("Bugün Pazartesi"); break;
case "Salı" : System.out.println("Bugün Salı"); break;
case "Çarşamba" : System.out.println("Bugün Çarşamba"); break;
case "Perşembe" : System.out.println("Bugün Perşembe"); break;
case "Cuma" : System.out.println("Bugün Cuma"); break;
case "Cumartesi" : System.out.println("Bugün Cumartesi"); break;
case "Pazar" : System.out.println("Bugün Pazar"); break;
}
System.out.println();
/*2.Döngü İfadeleri-Tekrarlı Yapılar : Döngüler belirli ifadeleri ya da kod bloklarını tekrar tekrar çalıştıran yapılardır. Tekrarlama işlemi sayısının belirli-sınırlı olduğu yapılara Tekrar Sayıları Belirli Döngüler denir (for). Tekrarlama işleminin koşula bağlı olduğu ya da koşul sağlanıncaya kadar tekrarlanan yapılara Tekrar Sayısı Koşula Bağlı Döngüler denir (do-while,while).
*/
//While Döngüsü : if cümleceğinde olduğu gibi koşul çalıştırıldığında true döndürmelidir. Önerme daima doğru olmalıdır.Kod ya da kod blokları koşul sağlandığı müddetçe tekrar tekrar çalıştırılır.
//Belirli Sayılar için döngü oluşturalım
int sayi=5;
while(sayi>=0)
{
System.out.println("5 kere döndüreceğiz");
sayi--;
}
System.out.println();
// 1 den 10'a kadar sayıların ekrana yazdırılması
int sayac=0;
while(sayac<=10)
{
System.out.println("sayac=" +sayac);
sayac++;
}
System.out.println("Sayac doğru sayıyor...");
System.out.println();
/* Do-While Döngüsü : Bu yapı diğerlerinden farklı olarak koşulu döngü sonunda kontrol eder. Yani döngü tamamen kontrol edilene kadar kod bloğu en az bir kere çalıştırılmış olur. Koşul sağlanıyor -true dönüyor ise kod bloğu tekrar çalıştırılır.
do
{
çalıştırılacak kod bloğu
}
while(koşul);
Noktalı virgüle dikkat edin ! Bu döngüde mutlaka kullanılmalıdır, diğerlerinde kullanılmaz !
*/
System.out.println("***** D0 WHILE DONGUSU*****");
int sayi2=0;
do
{
System.out.println("sayı = " +sayi2);
}
while (sayi2<0);
int sayac2=1;
do
{
System.out.println("ben bir do-while döngüsüyüm");
sayac2++;
}
while (sayac2<=0);
int sayac3=1;
do
{
System.out.println("ben bir do while döngüsüyüm");
sayac3++;
}
while(sayac3<=5);
/* For Döngüsü : While ve do-while döngülerine oranla daha sade bir görünümde yapılmak istenenler yazılır. For döngüsünde değişken ifadeleri, koşul ifadeleri ve değişken değerleri üzerinde yapılan işlemler daha net çizgilerle ifade edilir.
for(başlangıç değeri;koşul;artırma-azaltma)
{
Çalıştırılacak kod bloğu
}
Döngü içerisinde 3 parametre yer alır: Değişkenler, koşul ifadesi, artırım-azalım miktarı
*/
System.out.println();
System.out.println("***** FOR DONGUSU*****");
for(int sayi5=0;sayi5<5;sayi5++)
{
System.out.println("sayi = "+sayi5);
}
System.out.println();
for(int x2=0,y2=0;x2<5;x2++,y2++)
{
x2*=y2; //x2=x2*y2 demek
System.out.println("x2= "+x2+" y2= "+y2);
}
System.out.println();
//Örnek2
for(int k=5,l=6;k*l<50;k++,l+=3)
{
System.out.println("k değişkeninin ilk değeri : "+k);
System.out.println("l değişkeninin ilk değeri : "+l);
System.out.println("çarpma işleminin sonucu : " +k*l);
}
System.out.println();
for(int m=5,n=6;m*n<50;m++,n-=3)
{
System.out.println("m değişkeninin ilk değeri : "+m);
System.out.println("n değişkeninin ilk değeri : "+n);
System.out.println("çarpma işleminin sonucu : " +m*n);
System.out.println();
}
/*
3.Dallanma İfadeleri : Break, continue, return gibi deyimlerdir.
*/
//Break Deyimi :Etiketli ve etiketsiz olmak üzere iki başlık altında toplanabilir. Etiketsiz Break deyimi aynen switch case yapısındaki gibi koşul sağlandıktan sonra döngüden çıkılmasını sağlar. Etiketli Break deyimi ise hangi döngünün başına gelmiş ise o döngüyü sona erdirir.Tüm döngülerde kullanılabilirler.
System.out.println("***** Break Deyimi*****");
for (int h=2;h<50;h++)
{
if(h==9)
{
break;
}
System.out.println("h = "+h);
}
System.out.println("dongu sonlandırıldı");
System.out.println();
//etiketli break deyimi, etiket kirilmaEtiketi ifadesi olsun.
kirilmaEtiketi:
for(int i=0;i<5;i++)
{
//break deyimi ile baştan etiketlediğimizden üstteki kod bloğu çalıştırılmadı.
//kod bloğunun henüz kapatılmadığına dikkat !
for(int o=0;o<50;o++)
{
if(o==7)
{
break kirilmaEtiketi;
}
System.out.println("o= "+o);
} //bu alan kırılan for döngüsünün bloğuna dahildir
System.out.println("dongu kırıldığında ekrana birşey yazdırılmaz ");
System.out.println("i= " +i);
} //kırılan döngü sonu
//Continue Deyimi : İşlevsel olarak break deyimi benzeridir. Fark olarak break deyimi uygulandığı döngüden çıkılmasını sağlarken continue deyimi uygulandığı döngünün pas geçilmesini sağlar. Etiketli continue döngü başına uygulanır ve uygulandığı döngünün pas geçilmesini sağlar. Etiketsiz continue döngü içerisinde uygulanır, uygulandığı komutun pas geçilmesini sağlar.
//Etiketsiz Continue'a örnek
System.out.println("***** Continue Deyimi*****");
for(int p=0;p<8;p++)
{
if(p==6)
{
continue;
}
System.out.println("p= "+p);
}
System.out.println("dongu sonlandırıldı");
//etkiketli continue deyimi örneği
pasGec:
for (int r = 0; r < 5; r++)
{
for (int s = 0; s < 6; s++)
{
if(s==4)
{
continue pasGec;
//kod bloğu çalıştırıldığında dongunun s=3 sayısına kadar ekrana yazdıracak ve bu işlemi yukarıdaki döngünün sınırı olan 5 e kadar yapacak.
}
System.out.println("s = " +s);
}
System.out.println(" Döngü Pas Geçildiğinden ekrana birşey yazdırmaz");
System.out.println("r: " +r);
}
//Return Deyimi : Öncelikle bir fonksiyon ya da metodun değerlerini geri döndürmek için kullanılır.Bazı durumlarda ise metotlardan çıkış işlemlerinde kullanılır. Aslında metot tipi geri döndürme işlemine izin vermiyorsa(void gibi) return deyimi ile metodu terk edebiliriz.
//void bir metot içerisinde for döngüsünün terk edildiği uygulama
System.out.println("***** Return Deyimi*****");
for(int t=0;t<10;t++)
{
if(t==5)
{
return;
//for döngüsünden 0 da 10 a kadar sayıları döndürmesini istedik, return komutu ise t=5 olduğu durumda metot void olduğundan döngüden çıkılmasını sağlayacak yani 5 e kadar sayacak sonra çıkacak.
}
else
{
System.out.println("t: " +t);
}
}
}
}
package programlama.hafta4;
import java.util.Scanner; //Giriş-Çıkış İşlemleri İçin Eklendi
public class ProgramlamaHafta4 {
public static void main(String[] args)
{
/* BÖLÜM 11 - Klavyeden Basit Giriş - Çıkış İşlemleri
(Giriş-Okuma, Çıkış-Yazma) Klavyeden veri girilmesi, girilen verilere çeşitli işlemler uygulandıktan sonra ekrana yazdırılması ya da herhangi bir yazıcıdan çıktı alınması gibi işlemlerdir.
Paket Kavramı : Birbiriyle işlevsel olarak ilişkili sınıflar (class'lar) paketlerin (package'lerin) alt birimleri olarak yer alırlar. Bir sınıfın ait olduğu paketi tanımlamak için java.paketAdi.sinifAdi kalıbı kullanılır (java.util.scanner vb). Java API'si çok fazla sınıftan meydana gelmektedir.Bu sınıflar çeşitli paketler altında gruplandırılmışlardır.Bu paketler genelde Java ya da Javax ön ekleri ile başlarlar.Java öneki ile başlayanlar standart API'ye dahil olan sınıflardır.Javax öneki ile başlayanlar sonradan ekleme(extension) sınıflardır.
Import Kavramı : Bir sınıf; kendisi ile aynı pakette olmayan bir sınıfı kullanacaksa, kendisinden önce o sınıf import edilmelidir.
Kullanışı => import paketAdi.sinifAdi; şeklindedir. (import.java.util; gibi)
Joker Kavram.* import java.util.* şeklinde kullanılabilen ifadedir. Bu komut(.*) ile java.util paketindeki tüm sınıflar çağrılmaktadır.
Scanner Kavramı : Giriş-çıkış işlemleri için java.util.scanner sınıfına ait yöntemler kullanılmaktadır.Bu sınıfa ait işlemlerin kullanılabilmesi için uygulamaya import edilmesi gerekmektedir.
import java.util.scanner;
veya
import java.util.*
İfadelerinden bir tanesi ilgili sınıfın önüne import edilmelidir.
Bazı Scanner Yöntemleri
next() : Klavyeden girilen ifadenin ilk kelimesini okur. (boşluğa kadar olanı)
nextLine() : Klavyeden girilen tüm ifadeyi okur.
findInLine(".") charAt(0) : Klavyeden girilen ifadeyi karakterlere ayırarak okur.
nextInt() : Klavyeden girilen ifadeyi integer tipine çevirir.
nextFloat() : Klavyeden girilen ifadeyi float tipine çevirir.
nextDouble() : Klavyeden girilen ifadeyi double tipine çevirir.
Bilgi Giriş-Çıkışı
System.in : Klavyeden veri girileceğinde
System.out : işlem ve mesajların ekrana yazdırılacağında
System.err : hata mesajlarında kullanılmaktadır.Mesajları kırmızı yazdırır.
*/
//Klavyeden girilen ifadenin ekrana yazdırılması örneği
String ifade; // String - metin tipinde ifade isimli değişkeni tanımlıyoruz.
Scanner tara=new Scanner(System.in); // tara isminde yeni bir Scanner nesnesi oluşturulmaktadır.
System.out.print("İsim Soyisim : ");
ifade=tara.nextLine(); //nextLine() yöntemi ile klavyeden girilen tüm karakterler ifade isimli değişkenimize aktarılır
System.out.println("İsim Soyisim : " + ifade);
System.out.println();
// Klavyeden girilen iki sayıyı toplayan programı yazalım
System.out.println(" // Örnek 2 //");
Scanner tara2=new Scanner(System.in);
int x,y,toplam;
System.out.print("x sayısını giriniz : ");
x=tara.nextInt();
System.out.print("y sayısını giriniz : ");
y=tara.nextInt();
toplam=x+y;
System.out.println("x+y : "+toplam);
}
}