ICQTurk Forum

public class isim
{
//deklarasyonlar
String first;
String last;
String middle;
// A class constant
static final String SEP=",";
.
public void ismiyaz(String etiket)
{// a local variable
String name;
name=last+SEP+first+SEP+middle;
System.out.println(label+name);
}//method declarasyonunu sonlandir
}//class declarasyonunu sonlandir.



//constuctori cagiriyoruz.
//isim classi icin bir object olusturuyoruz once
isim doverim=new isim("ananda","reynolds","fiona");
//isim mi cagiran bir ornek
doverim.ismiyaz(Name is:);
System.out.println("bitti!")
baska bir ornekle devam edecegiz.

Program
Classlar arasi gecis ile alakali.

iki classtan olusan bir ornek asagida verilecektir.
program
//bu Cat classina ait

public cat
{
String name,color;
float weight;
//constructors
public Cat()
{
name=" ";
color=" ";
weight=0.0;
}


public Cat(String newName,String newColor,float newWeight)
{
name=newName;
weight=newWeight;
color=newColor;
}
public String getName()
{
return name;
}

public float getWeight()
{
return weight;
}
public String getColor()
{
}
return }
}


//Driver classina ait.
public class CatDriver
{
public static void main(String [] args)
{
Cat myCat=new Cat("meow","ginger',10.5);
Cat cat=new Cat();
System.out.print("myCat");
System.out.println(myCat.getName()+" "+myCat.getColor()+" "+myCat.getWeight());
Sysem.out.print("cat");
System.out.println(cat.getName()+" " +cat.getColor()+" "+cat.getweight())
}

Value-Returning Method
Javada Stringler
String bir dizi karakterin birlesimidir.
Herhangi bir programlama dilinde stringler, kullanicilarin veri almadan tutun yazlimin cikti(output)olarak verdigi veriye kadar pekcok islemde sikca kullanilir.Stringler degismez neslenelerdir(immutable object)burada degismez dememizdeki kasit,olusturdugumuz string nesnelerin karakterlerini daha sonra degistiremeyiz.Ornek olarak,uygulamanizda olusturudugunuz Java stringini,daha sonra jawa bicimine ceviremesiniz.
Java'da stringlerin degismez olmasi stringlerin bir defa olusturulup daha sonra duzenlenmesinin imkansiz oldugu anlamina gelmiyor tabiki.Stringler uzerinde yaptiginiz herhangi bir degisilikte java,yeni bit string nesnesi oluturarak referans degiskeninize bu yeni nesneyi atiyor.
Stringlerin Olusturulmasi
Java'da stringler nesne oldugu icin,stringleri herhangi bir nesne olurtururken kullandigimiz new anahtar sozcugu ile olusturabiliriz.String sinifi,pekcok farkli ve kullanili yapilandirici(constructor)method sunar ve bircok farkli bicimde string nesneleri olusturmamiza olanak saglar.
String olusturmak icin kullanilan en basit yontem,bir string literal ile referans degiskene atama yapmaktir.Literaller, java tarafindan goruldugu yerde string nesnesine cevrilir.Bu sayede literal kullanarak acik olmayan bir sekilde aslinda bir string nesnesi olurturmus olursunuz.

String abc="merhaba";

bir diger yontemde,herhangi bir string degerini yapilandirici methot aktarmaktir.

String abc=new String("DOGAN");

String karakterlerin birlesimi oldugu icin,bir karakter dizisi kulalanarak da,string olusturabilirsiniz.
String sinifi bu yapiyi saflamak icin gereken yapilandirici methodu sunar.

char[] cahrArray={'J','A','V','A'};
String abc=new String(charArray);//"Java" stringi

Bu tur kullanimlar, Java'da string olusturmak icin en cok kullanilan temel bicimlerdir.Ancak String sinifi,daha pekcok farkli yapilandirici method sunar ve cok daha gelismis islemler icin bu yapilandiricilari kullanabilirsiniz.
String Literaller

Literaller, Java'da sabitlerdir,3,5.3, "Java" gibi her yapi Java'da literal olarak adlandirilir.Ancak Java,program kodu uzerinde gordugu her string literali,otomatik olarak string nesnelrine cevirir.
String lireralleri de aynen bir nesne gibi uygulamanida kullanabilirsiniz.

System.out.printf("%d","Java".length());
//cikti

STRING METHODLARI

Java, stringler uzerinde her turlu islemi yapabilmek icin pekcok kullanili method sunar.

lenght()Methodu

String sinifinin sundugu length() methodu ile,stringin uzunlugunu alabilirisniz.

String abc="Java Programlarama";
System.out.println("Javada Programlama stringinin uzunlugunu bulacagiz"+abc.length());
//cikti
Java Programlama stringinin uzunlugu 16

charAt() Methodu

Bu method ile string icinde,verilen pozisyondaki karakteri dondurebilirsiniz.Diziler uzerinde islem yapmaya benzer.Stringler icerisindedeki karakterlerin 0 dan basladinigini hesaba katar.

String abc="Java Programlama";
System.out.println(abc.charAt(0));
System.out.println(abc.charAt(5));
//cikti
J
P

indexOf()
indexOf methodu ile, verilen bir karakterin yada stringin(substring),ana sring icinde kacinci sirada bulundugunu bulamak icin kullanilir.Pek cok farkli bicimi vardir.

String abc="Java Programlarama";
System.out.println(" a harfi ilk olarak:"+abc.indexOf('a')+"sirada bulundu");
// a harfi aramaya 2. indexden basla
System.out.println(" a harfi 2. indexten sonra:"+abc.indexOf('a',2)+"sirada bulundu");
//"gram" stringinin nerede basladigini bul
System.out.println("gram altstringi"+abc.indexOf("gram")+"sirada bulundu");

toUpperCase()

String tum karakterlerini buyuk harfe cevirir.

String abc="Javada String";
System.out.println(abc.toUppurcase());
//cikti
JAVADA STRING

getChars() Methodu

Bu method ile,string icindeki karakterleri, bir karakter dizisine aktarabilirsiniz.4 parametre alir.1.
parametre,kopyalanacak karakterlerin String icinde kacinci siradan baslanacagini belirtir.2.parametre,
en son kacinci karaktere kadar kopyalancagini belirtir..3.parametre,karakterlerin aktarilacak karakter dizisi degiskenin adini,4.ve son parametre ise, karakterlerin dizi icerisinde hangi indisden baslanarak kopyalanacgini belirtir.

string abc="Java Programlama";
char[] charArray=new char[4];
abc.getChar(0,4,charArray,0);
//charArray icerigi
//'J','a','v','a'

String karsilastirilmasi

javada sringler nesne oldugu icin,string icerigini == operatoru ile karsilastiramayiz.primitive tiplerde isedigimiz skeilde calissada stigleri kasilastirmak icin bu operator,beklenen yaniti vermez.referanslar ile == operatour kullanildiginda degikenlerin ayni nesneye referans edilip edilmedigini kontrol edilir.bu yuzden string degerlerini karsilastiriken,String sinifinin sundugu equals() methoduny kullanmak gerekmektedir.

String abc=new String("Java");
String abc2="Java";

if(abc.equals("Java"));
{
System.out.println("strintler esit");
}
else System.out.println("strintler esit degil");
if(abc2=="Java")
{
System.out.println("ayni nesne");
}
else System.out.println("ayni nesne degil");
if(abc=="Java")
{
System.out.println("ayni nesne");
}
else System.out.println("ayni nesne degil");
if (abc2.equals(abc))
{
System.out.println("strintler esit");
}
else System.out.println("strintler esit degil");
// cikti
stringler esit
ayni nesne
ayni nesne degil
stringler esit

STRING VE SAYISAL DEGERLER

stringler ile ilgili degibilmesi gereken bir diger nokta da sayidal degerler be stringler arasindaki donusum islemleri.string bicimindeki sayisal degerleri, o tipe uygun sayisal degerlere cevirmek ve sayisal degerleri, string bicimine dondurmek hava kutuphaneleri sayesinde cok kolay bir sekilde halldiliyor.
bir kac yontem vardir.birincisi java derleyiciye birakmak

String abc=""+5
System.out.println("abc);

ikinci olarak,string sinifinin sunmuz oldugugu valueOf() methodunu cagirarak,degerini stringe donusturecegimiz sayisal veriyi bu methoda gecirmek.

float fl=(float)5.2;
String abc= String.valueOf(fl);

toString() methodu ile sayisal degerleri string tipini dounsturebiiriz.

int a=5;
double b= 2.3;
String abc=integer.toString(a);
String abc2=double.toString(b);

System.out.println(abc+" " +abc2);
//cikti
5 2.3
9.3

diziler(array)

diziler basitce ayni tipe sahip bir dizi elemani,tek bir noktada gruplayarak bu verilere daha kolay bir sekilde ulasilmasin saglayarak, yazilim gelistirme surecini dah absit ve yonetileblir bir hale soka
javada bu tip islemler icin cok gelismis bir dizi(array) mekanizmasi sunar.daha once kullanilmis yazlimcilar, javadaki dizileri inclerken dikkat etmesi gerkiyor cunku javada diziler. c den farklidir.havada dizler nesnedir.

javada diziler.
javada diziler nesne oldugu icin, dizi olusturmak icin kullainlan yoontem aynen nesnlerin olusturulmasi gibidiir.new anahtar sozcugu kullarak dizi olusturulur.
tek fark sadece derleyiciye bir dizi oustrucagmizi bil
[] dizi operoturu degisken tanimlamisinda belirtilir.
javada diziler hakkinda bilinmesi gerken en onemli noktalardan biri havada dizi elamanlar 0 dan baslar.yani 10 luk bir dizi olusturdugumuz zaman, dizinin ilk elamanin = indisden, son elamanina 9/indisden ulasiriz.

DIZIlERI OLUSTURMAK

in[]dizi;
int baskaDizi[];

yukaridaki kodda, int tipinde 2 farkli tek boyutlu dizi referansi olusturduk.dizi olusturulmasinda kullanilan [] operatoru tip belirtecinde sonra ya da degisken tanimlamaindan sonra kullanilir.
dizi referanslarin atama dizi icin bir nesne olusturularak, kod icinde hehangi bir yerde yapilabilr.
in[]dizi new int[10];//10 elemanlik bir int dizisi
int baskaDizi[];
baskaDizi=new int[5];//5 elamanlik baska bir dizi

int tipinde oldugu gibi javada primitive tiplerden nesne tiplerine kadar her veri tipinde dizi olusturabilirisiniz.

int[] intDizisi;
byte[] byteDizisi;
String[] stringDizisi;
object[]objectDizisi;

DIZILERE DEGER ATAMAK

javada dizilere 2 turlu deger atayabiliyoruz.birinci yontem, dizi referance olustrudgumuz satirda sizi elamanlarina acikca atama yapabiliriz.bu yonde dikkat edilmesi gereken bokta, nesne referansi olustrudugumuz satirda bu atamayi yapmamiz sart.nesne referanse olusturduktan sonra bu atamayi kodun baska yetinde yapmak deleme hatisna neden olur.

Strin[] sitringDizisi={"Java","c","pytohon","haskell"};//gecerli
Strinf[] baskaDizi;
baskaDizi = {"Php", "Perl", "Ruby"}; // Error : Derleme Hatasi


baska bir yontemde,dizi nesnesini olusturup atama yapmaktir.dizi boyutunu belirledikten sonra, dizi elamanlarini kodun herhangi bir yerinde atayabiliyoruz.

int[] intDizisi;
inDizisi=new int[10]//10 luk bir int dizisi olustur
intDizisi[0]=1;
intDizisi[1]=2;
//..
intDizisi[9]=10;
dizi elamanlarina dizi operatoru olan [] operatoru ile ulasabiliyoruz. yukaridaki kodda goruldugu gibi 10 lik bir dizi
olusturduk ve dizi elamanlarina [] operatorunu kallanarak knolayca ulasabiliyor sanki normal bir degidken gibi atama yapabiliyoruz.hatirlayin havada dhiz elamanlrai 0 dan baslar. u yuzden ilk elaman intDizisi[0], son elana intDizisi[9] sekilide atama yapiyoruz.

DIZI UZUNLUGU
javada diziler birer nesne oldugu icin, siniflarin sagladigi tum esnekligi ve gucu diziler ile de kullababiliyoruz.ornegin hava , dizi boyutyotunu dondutrn length adinda bir ozellik
sunar.bu ozelligi kullanarak hehangi bir dizi boyutunu kolayca bulabiliriz.dizi.length seklinde dizi adindaki dizinin uzunlugunu bulabiliriz.
simdi olustrudugumuz 10 luk bir int dizisine 30 dan buyuk 10 cift sayiyi atayalim

int[] dizi;
dizi=new int[10];
int altSinir=30;

for (int i=0; i<dizi.length; altSinir++)
{
if (altSinir%2==0)
{
dizi=altSinir;
i++;
}
}
//dizi icerigini ekrana yazdiralim.
}
for (int i=0; i<dizi.length;i++)
System.out.printf("%d",dizi);
}
//program ciktisi
30 32 34 36 38 40 42 44 46 48

dizi boyutu ile ilgili soylemesi gerken bir diger nokta dizinin uzunlugu disinda bir islem yapmaya calisirsaniz hava, indexOutOfBoundsException ini gonderir.yani 10 luk bir dizi olusturdugunuzda dizinin son elanina diz[9] ifadesi ile ulabilirsiniz.bunun disinda islem yapmaniza izin vermez.
int [] dizi=new dizi[10];
dizi[0]=5;//gecerli
dizi[9]=45//gecerli
dizi[10]=56 //hata dizi boyutu 10 olarak tanimlandi

JAVADA COK BOYUTLU DIZILER

javada dizilerinde bahsetmek gerekn bir diger nokta,javada diziler istenile boyutta tanimlanabilir,iki,3 boyutlu.cok boyutlu diziler basitce, dizilerin dizileri olarak dusunulebilir.ancak uygulama kodunun basitlig ve kodu kisilerin kodda donen olaylari daha iyi anlayabilmesi icin 3 boyutdan dha yuksek boyutda dizlerin kulanilmasi pek onerilmez.nadiren 3 boyutlu kullanilamkdadir.

String[][] dizi={
{"musa","sun"},
{"bey","hanim"}
};
System.out.println(dizi[0][0]+" " dizi[1][0]);
//program ciktisi
ali bey
sun hanim

usteki ornekte,cift boyutlu bir string dizisi olusturduk.cok boyutlu dizi olustururken yapilamasi gereknlerden biri olustrucagimiz dizi boyutu kadar diz operatorunu[] tip yada degisken deklarasyounun basina eklemek.ornekte biz bir dizi olustrudumuz icin bu tanimlayi, string[][] dizi seklide ifade ettik.
cok boyutlu diziler, bazen kafa karstirici olsada asil matigi caok basittir. bir dizi olustrulur.o dizinin elamanlari da badka bir dizidir.bu sekilde istenildigi kadar deinlikte dizi olustrulur.
ornege bakacak olursak dizi elamanlarina ulaskam bu mantik cercevsinde oludkca basittir.dizi[] ifadesi ile dizi icerisindeki 1.elamana ulasiyourz, o elemaninda badka bir dizi oldugunu bildigimiz icin o dizinin ilk elanina da dizi[][] seklinde,ikinci elanada ayni sekilde dizi[][] sekilde ulasabiliyoruz.
ornekteki dizinin hanim elanina ulasamak icin yapmamiz gerekenler sirasiyla sunlar hanim elanin dizi ismindeki 2. ekanina ait bir elaman. bu 2. elaman da kendi icinde bir dizi oldugu icin hanim elanin bu dizinde 2.elanidir.bu yuzden bu elana bu mantik cercevizinde dizi[1][1] seklide basitce ulasabiliyoruz.

COK BOYUTLU DIZI UZUNLUKLARI
dizi adindaki dizinin uzunlugunu asagidaki gibi blabiliriz.cikti dizinin elaman sayisini beklendigi gibi verecektir.
System.out.println(dizi.length);
//cikti
2

dizi adindaki diznin elemanarida bir dizi oldugu icin,dizi[] seklinde bir ifade dizi icerisindeki ilk diziyi verecketir.yine ayni sekilde bu dizilerin uauznlarinda asagidaki sekilde ulabiliriz.
dizi[0].length
dizi[1].length

//elamanlari dizi olan bir dizi referansi olustur
//cok boyutlu dizi yani
String[][] dizi;
//bu dizinin elamanri dizi olan 2 elani olsun
dizi=new String[2][];
//dizinin ilk elamani 2 elemanli bir dizi olsun
dizi[] =new String[2];
//ilek eleman olan dizinin ilk elamain"bir"olsun
dizi[][]="bir";
//diger elamanida "iki" olsun
dizi[0][1]="iki";
//dizi ismindeki dizinin ikinci elemani uzunlugu 3 olan bir dizi olarak tanimlar.
dizi[1]=new String[3];
//ikinci elanin ilk elamani"uc"olsun
dizi[1][0]="uc";
dizi[1][1]="dort";
dizi[1][2]="bes";

System.out.println(dizi[1][2]);
System.out.println(dizi[0][1]);
//cikti
bes
iki

if (boolean)
true ise
else
false ise

Görüldügü üzere denetim boolean ifade üzerine kurulu. Boolean bir ifade iki degerden birini alir: true ya da false. Deger true ise sunu yap, degilse bunu yap. Burada dikkat edilmesi gereken en önemli sey boolean bir ifade kullanmak.
Örneklere geçmeden önce, hayati önem tasiyan karsilastirma ifadelerine kisaca deginmek istiyorum.
<, <=, >, >=, == (esitse), =! (esit degilse)

Örnek:
int sayi=5;
if (sayi==5)
System.out.println("sayi=5");

Simdi akla söyle bir soru gelebilir: “Ben bu örnekte boolean bir degisken göremiyorum!”. Evet, boolean bir degisken yok, fakat if parantezi icerisinde bir karsilastirma var: sayi==5;. Bu ya dogrudur ya da yanlis.
Not: Eger sayi=5; demis olsaydik program hata verecekti. Cünkü '=' karsilastirma ifadesi degil, atama ifadesidir. Sayi=5; dedigimiz anda sayi degiskeninin degeri 5 olarak atanir. String'lerde karsilastirma equals ile yapilir.

Örnek: if
String ad="Yazilim mutfagi";
if (ad.equals("Ahmet"))
System.out.println("karsilastirma dogru yapildi");

Bu örneklerde else bölümünü kullanmadan yaptik. Kodlar tek tek isleme tabi tutulurken if bloguna girecek ve sayi degiskeninin kosula (sayi==5;) uyup uymadigina bakacak, uymuyorsa baska bir islem yapmadan okumayi kesip blogun disina çikacak.

Örnegimizi else ekleyerek biraz açalim: If-else
int sayi=5;
if(sayi>5)
System.out.println("sayimiz 5'ten büyük");
else
System.out.println("sayimiz 5 veya 5'ten küçük");
program çiktisi: sayimiz 5 veya 5'ten küçük.



/*bilgisayarin karar vermesi .sen bir test vereceksin.
parentest icinde condition var.su anda bizim bir degerimiz var.==bu bizim test icin kullanilir.eger esit deilse!= veya <,>=
if then sonra bizim statemente ihtiyacimi z var biz bunu body olarakta adlandiriyoruz.eger test dogruysa print etsin bize.ilk yapacagimiz.eger test it deil ise.bize bir ekstra bir firsat verecek.
*/

class izmir{
public static void(String args[]){
int test=6;
if (test<11){
System.out.println("evet");
}else{
System.out.println("sonuc baska birsey ")
}
}
}
/*if ile else arasinda birden fazla satir olmadigi için süslü parantez {} kullanmadim, ama kullansam da olurdu.

ve ve veya operatörleri.
Bazen de bir komutu birden fazla sart kosarak veririz. “Sayi 10'dan büyuk ve 20'den küçükse” gibi.
Bunlar için ve && ve veya || operatörlerini kullanacagiz.

Örnek: && - || operatörleri

int puan=55;
String ders="Java";

if(ders.equals("Java") || ders.equals("C#") && puan>=45)
{
System.out.println("Geçtin");
}
else
System.out.println("kaldin");



mutiple testi nasil kullanacagimizi gorecegiz.bir chat website yapalim bu programicin.&& yani ve yi kullanacagiz.
if in icindeki her iki durumun dogru olmasi gerekiyor.birinci durumdaki mesagin yayinlanmasi icin.aksi takdirde ikinci olay ekrana yazilacaktir.
ayrica || ikisinden biri dogru olursa ik mesaj print edilecek.veya ikisi dogru olursa birinci mesaj
goruntulenecektir. */
class izmir{
public static void main(String args[]){
int erkek,kiz;
erkek=9;
kiz=66;

if(erkek>10 || kiz<60){
System.out.println("giris yapabilirsin");
}else{
System.out.println("giris yapamassin");
}
}
}

/*bu boulumdede switch statementini gorecegiz
bize bircok secenek verir.bir cok if statementi kullanmak yerine switch statementi kullanacagiz.
bize bir cok secenek verir.degeri bulur.bir cok if yerine case kullaniriz.case den sonra kolon isaretini koyariz.sonra break kullaniyoruz.break eger ihtiyac yoksa
sonladir diyoruz.ensonunda default statementini kullanacagiz.eger hepsi yanlissa.bu bize baska bir secenek verir.sonra tabiki break isareti kullanacagiz.*/

class apples{
public static void main(String args[]){
int yas;
yas=7;
switch (yas){
case 1:
System.out.println("emekliyebilirsin");
break;
case 2:
System.out.println("konusabilirsin");
break;
case 3:
System.out.println("basin derde girebilir");
break;
default:
System.out.println("kac yasinda oldugunu bilmiyorum");
break;
}
}
}
//cikti
kac yasinda oldugunu bilmiyorum

while loop gorecegiz.
/*body yanin parantezin icinde ne varsa ekrana yaz diyoruz.
tekrar tekrar tekrar yazmak yerine bir defa yazmamiz yetiyor.*/

class izmir{
public static void main(String args[]){
int say=0;
while(say<1){
System.out.println(say);
say++;
}
}
}//cikti
0
1
2
3
4
5
6
7
8
9
bu programdada Nested if satement ve else if statementi gorecegiz.
/*sadece bir olay icin deilde,bir kac olay icin bir kac
if else kullanilmasi olayina nested deniyor*/

class izmir{
public static void main(String args[]){
int yas=60;

if(yas<50){
System.out.println("gencsin");
}else{
System.out.println("yaslisin");
if(yas>75){
System.out.println("sen gercekten yaslisin!");
}else{
System.out.println("uzulme cokta yasli deilsin");
}
}
}
}//cikti
yaslisin
uzulme cokta yasli deilsin

else if statementi

/*bir cok durum icin kullanilir.if ve else statementi sana sadece iki durum verir.else if sana ucuncu bir ektra secenenk verir.bir cok else if statementi kullanrak secenekleri artirabiliriz.
sadece bir durumu print edicektir.bir cok test vermenin yolu else if statementi kullanrak mumkun olur*/

class izmir{
public static void main(String args[]){
int yas=45;
if(age>=60)
System.out.println("emeklisin");
else if (age>=50)
System.out.println("50li yaslarindasin");
else if (age>=40)
System.out.println("40li yaslarindasin");
else
System.out.println("baya gencsin");
}
}

conditional operators
//once testi vereceksin.sonrasinda ? sonrasinda iki secenek vereceksin.ama genelde if else statment kullanilir.soru isaretini koymaniz lazim.ve kolon isareti koymaniz lazim.iki degerin arasina
class izmir{
public static void main(String args[]){
int yas=20;
System.out.println(yas>50? "yaslisin" : "gencsin" );
}
}//cikti
gencsin

Basit bir ortalama programi.while loop kullanicagiz.
/*10 rakam girecegim bana ortalamayi verecek
system.in keyboard oldugunu unutmayin.nelere ihtiyacimiz varsa
bast girecegiz.while burda 10 sayi girmemizi saglayacak.input.nextInt()bize depolama gorevi yapacak girdigimiz rakamlari.*/

import java.util.Scanner;

class apples{
public static void main(String[]args){
Scanner input=new Scanner(System.in);
int toplam=;
int not;
int ortalama;
int say=0;

while(say<10){
not=input.nextInt();
toplam=toplam+grade;
counter++;
}
ortalama=toplam/10;
System.out.println("Senin ortalaman"+ortalama);
}
}

bu programda for loop u gorecegiz.
/* for 3 durum icerir birinci loopun yani dongunun nerde baslayaci,ikincisi nerde bitecegi,ucuncusu nekadar artirmak istiyorsun.
birermi artiracaksin ikisermi artiracaksin.verilen degeri 3 yerde kullanacagiz.
yapmamiz gereken birinci durum.loopun baslacagimiz rakam 1,durum <=10 kadar
gitsin.ucer artiralim.3 durumu girmis olduk.suan*/

class izmir{
public static void main(Strin[] args){
for (int say=1;say<=10;say+=3){
System.out.println(say);
}
}
}
faiz hesaplama
compound interest program

/*burda % kac faiz oldugunu girmemiz lazim.miktari girmemiz lazim.
su formulu kullanacagiz.M=B(1+R)^y B baslangic parasi,R yuzdelik faiz,n ilse yil
bunu cevirmemiz lazim.burda Math.pow formulunu kullanacagim.20 gunluk bana faizi ver gun gun olsun.
parantezin icinde yuzdeligi,ve gunu veriyoruz.*/

class izmir{
public static void main(Strin[] args){
double miktar;
double baslangic=10000;
double yuzdelik=.01;

for(int gun=1,gun<=20;gun++){
miktar=baslangic*Math.pow(1+yuzdelik,gun);
Systme.out.println(gun+" "+miktar);
}
}
}

do while loop u kullanmasini ogrenecegiz.
Do While Döngüsü Kodu


do..while



while döngüsü farkettiginiz gibi, ileri sürdügümüz sarti, iyi yapmadan önce sinar; ve bu sart ortadan kalkmamissa (yani henüz dogru/true ise) yapacagi isi yapar; baska bir deyisle while döngüsünün yapacagi is hiç yapilmayabilir. Fakat sinamanin is yapildiktan sonra yerine getirildigi bir sekli de vardir: do..while.. Bu döngü ise söyle yazilir:



do {



Kosul dogru ise yapilacak islere iliskin komutlar



}



while (kosul);



Burada gördgünüz gibi do..while döngüsü en az bir kere icra edilir; çünkü sartin sinanmasi yapilacak ise iliskin komutlardan sonra gelmektedir.
Bu döngünün aradigi sartin döngünün yaptigi islerin sonucu veya kod bölümünde bizim tarafimizdan gerçeklestirilmesi için igerekli komutlarin bulunmasina dikkat etmelisiniz.
Yoksa, bu döngü de sonsuzluga erisir! Yukarida örnegi, bu yöntemle yazalim:



//birincide degerleri girecegiz.do en az birdefa dongunun goruntulenmesini saglar ama while loop dogru ise calisir.

class izmir{
public static void main(Strin[] args){
int say=15;

do{
System.out.println(say);
say++;
}while(say<=10);
}
}

//rastgele sayi secme,import java.util.Random; komutunu kullanacagiz.kac surumunuz var onun parentezin icine yazacaksin.biz 6 yaziyoruz.
//burda dikkat edilmesi gereken cikti 0 basliyor 5 kadara.biz 1 den balamasini istiyoruz.Onun icin bas tarafa 1+dice.nextInt(6)
//seklinde kullanacagiz.


import java.util.Random;

class izmir{
public static void main(String[] args){
Random dice=new Random();
int sayilar;

for(int sayi=1;sayi<=10;sayi++){
sayilar=1+dice.nextInt(6);
System.out.println(sayilar+" ");

}
}
}




ARRAY Nedir?

ayni tipten cok sayida degisken tanimlamak icin kullailir.soyut bir veri yapasidir.matematikteki sonlu diziye benzer.java dilinde array bir siniftir.her sinifin soyut bir veri tipi oldugunu biliyoruz.array sinifi array yaratma,arraylerle islem yapma,array icinde bilesen arama ve array in bilesenlerin siralama gibi array ile ilgili islemleri yapmaya yarayan ogeleri iceren bir siniftir.

Array olusturma

1.array sinifinin bildirimi
2.array sinifinda nesneleri olusturma
3.arrayin bilesenlerine deer atama

birinci asama:

int[] sicilNo;

ikinci asama:
sicilNo=new int[5];

sicilNo[0]
sicilNo[1]
sicilNo[2]
sicilNo[3]
sicilNo[4]

[] Operatörü
Array adının sonuna gelen [] parantezleri, arrayin bileşenlerini, yukarıda gösterildiği gibi, damgalarıyla (indis, index) belirler.

Array'in Bileşenleri
sicilNo (i=0,1,2,3,4) ler söz konusu nesne içinde birer değişkendir. Bu değişkenler sayesinde, array beş tane int tipi veriyi bir arada tutabilme yeteneğine sahip olur. Bu değişkenlere array'in bileşenleri ya da öğeleri denir. 0,1,2,3,4 sayıları bileşenlerin sıra numaralarıdır; damga (index) adını alırlar. Sıra numaraları (index) daima 0 dan başlar, birer artarak gider. n tane bileşeni olan bir array'in ilk bileşeninin damgası 0, son bileşeninin damgası (n-1) olur. Bir array'in uzunluğu onun bileşenlerinin sayısıdır.

Eğer new int[5] yerine new int[500] yazsaydık, 5 bileşen yerine 500 bileşen elde ederdik.

Arrayin işaret ettiği nesne olusturunca, onun bileşenleri kendiliğinden başlangıç değeri alırlar. Bunlara öndeğer (default value) denir. Öndeğerler bileşenlerin veri tipine bağlı olarak değişir. Java dilinde bütün sayısal değişkenlerin öndeğerleri daima 0 dır. Boolean tipin öndeğeri false olur. Referans tiplerde ise null olur. O nedenle, yukarıda sicilNo referansının işaret ettiği nesne içindeki SicilNo[0], sicilNo[1], sicilNo[2], sicilNo[3] , sicilNo[4] bileşenlerinin (değişken) öndeğerleri kendiliğinden 0 olur.

Üçüncü aşama:

sicilNo[2] = 1453;

ataması, array'in üçüncü bileşenine 1453 değerini atar.
int [] sicilNo = new int[] {123, 26, 1453, 832, 109};


Java dilinde her veri tipinden array olusturulabilir. Örneğin,

String [] ad = new String [] {“Ayla”, “Esra”, “Gülsah”, “dogan”, “sinan”};

deyimi String tipinden bir array sınıfı bildirmiş, onun bir nesnesini olusturmus ve o nesnenin bileşenlerine String tipi değerler atamıştır. Bu atama

ad[0] = “Ayla” ; ad[1] = “Esra” ; ad[2] = “Gülsah” ; ad[3] = “dogan” ; ad[4] = “sinan” ;



Arrayin Bileşenlerine Değer Atama Yöntemleri

Aşağıdaki üç yöntem aynı işi yapar.

1.Yöntem. Arrayin uzunluğunu belirleyip seçkili (random) değer atama

int[] arr;

arr = new int[10];

arr[6]=75; arr[1]=25; arr[2]=35; arr[7]=85; arr[4]=55;

arr[3]=45; arr[0]=15; arr[8]=95; arr[9]=105; arr[5]=65;


2.Yöntem. Nesneyi istemli olusturup sıralı değerler atama

int[] arr;

arr = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

deyimi 10 bileşenli bir array yaratır ve bileşenlerine sıralı değerler atar. New int[] ifadesi arrayin uzunluğunu belirlemez; ancak {} bloku içine sırayla yazılan değerler array uzunluğunu ve her bileşene atanan değeri kesinkes belirler. {} içindeki değerlerin yazılış sırası ile bileşenlerin sırası uyumludur. Örneğin, {} içindeki 7-inci değer 7-inci bileşene aittir. Tabii, 7-inci bileşenin damgasının 6 olduğunu biliyoruz; çünkü damgalama işlemi 1 den değil 0 dan başlar. O nedenle arr[6] = 75 dir. Arraylerde bu özeliği daima anımsamalıyız.


3.Yöntem. Nesneyi istemsiz yaratıp sıralı değerler atama

int[] arr { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

deyimi yukarıdaki deyimin yaptığı işin aynısını yapar; ancak new operatörünü istemli (explicit) kullanmaz, nesne istemsiz (implicit) olarak yaratılır.

Array01.java

class Array01

{

public static void main(String[] args)

{

int[] çarpan = new int[10];

for (int i = 6; i < 10; i++)

{

çarpan = i * i;

}

for (int i = 0; i < 10; i++)

{

System.out.print(çarpan);

System.out.print("\t");

}

}

}

Çıktı:

0 0 0 0 0 0 36 49 64 81

Array02.java

class Array02

{

public static void main(String[] args)

{

int[] intSayı = new int[5];

for (int i = 0; i < intSayı.length; i++)

intSayı = i * 10;

for (int i = 0; i < intSayı.length; i++)

System.out.println("intSayı[" + i + "] = " + intSayı);

}

}




Çıktı

intSayı[0] = 0

intSayı[1] = 10

intSayı[2] = 20

intSayı[3] = 30

intSayı[4] = 40

Arrayin bilesenlerine Erisim

Arrayin bilesenleri degisken olduklarinda,onlara istaendiginde deger atanabilecegi
istenirse atanan degerlerin dgistirilebilegi aciktir.yukaridaki sicilNo[2]=
1453 atama deyimi,arraylerin ustun bir nigeligini ortaya koyar.arrayin istenen bile
senine damga sayisi ile dogrudan erismek mumkundur.her birlesen bir degisken oldu
gu icin ,o bilese tipiyle yapilabilen her islem onlar icinde yapilabilir,degis
kenlerle ilili kurallar bilesenler icinde aynen gecerlidir.SicilNo[2]=1453;
deyimi indeksi 2 olan bilesene 1453 degerini atamistir.
Bilesen degeri ayni veri tinden baska degiskenlere aktarilabilr ve tabii bu isin
tersi de yapilabilir.ornegin,x ayni tipten bir degisken ise
x=sicilNo[2];
atamasi,sicilNo[2] bileseninin degerini x degiskenine aktarir;oyleyse, bu artama
deyimi
x=1453;
atamasina denktir.
tersine olarak, y ayni tipten bir degisken ise degeri bilesene aktarilabilir.ornegin,
int y=123;
sicilNo[2]=y;
aramasi gecerlidir.bu atama y nin degerini sicilNo[2] bilesebibe aktarir;dolayisiyla
siciNo=123; atamasina denktir.

Bir arrayin bir bileşeninin değeri başka bir bileşenine aktarılabilir. Örneğin,

sicilN0[3] = sicilNo[2];
Aynı veri tipinden iki arrayden birisinin bir bileşeninin değeri ötekinin bir bileşenine aktarılabilir. Örneğin,

short[] a,b ;

a = new short[] {10,20,30};

b[2] = a[0];

ataması geçerlidir.

Aynı veri tipinden iki arrayden birisi ötekine aktarılabilir. Örneğin,

short[] a,b ;

a = new short[] {10,20,30};

b = a
ataması geçerlidir. Bu atama, b referansının a ile aynı yeri işaret etmesinei sağlar. Dolayısıyla, aşağıdaki bileşen atamalarının birer birer yaptığı işi tek başına yapar.

b[0] = a[0];

b[1] = a[1];

b[2] = a[2];

class VergiHesaplama
{
public static void main(String[] args)
}
double[] aylikUcret=new doluble[3];
aylıkÜcret[0] = 2782.45;

aylıkÜcret[1] = 9346.74;

aylıkÜcret[2] = 10867.83;



double[]gelirVergisi=new double[3];
for(int i=0; i<aylikUcret.length;i++)
{
gelirVergisi=aylikUcret*30/100;


System.out.println("aylik"+aylikucret+"tl ucretin gelir vergisi="+gelirVergisi);
}
}
}




Çıktı

2.782,45 TL ücretin gelir vergisi = 834,74 TL

9.346,74 TL ücretin gelir vergisi = 2.804,02 TL

10.867,83 TL ücretin gelir vergisi = 3.260,349 TL


class Array04

{

public static void main(String[] args)

{

short[] a = { 1, 2, 3, 4 };

int[] b = { 5, 6, 262141, 8, 9 };

System.out.println("b[2] = " + b[2]);

b[2] = a[3];

System.out.println("b[2] = " + b[2]);

}

}

Çıktı

b[2] = 262141

b[2] = 4

Aynı aktarmayı tersinden yapmak isteyelim. Yukarıdaki programda b[2] = a[3] deyimi yerine a[2] = b[3] yazarsak, derleyiciden şu hata mesajını alırız:

... java:8: possible loss of precision

Bu hata mesajı bize programın 8-inci satırında yapılan a[2] = b[3] atamasında veri kaybı olacağını söylüyor. Çünkü 8-inci satırda yaptığımız bu atama ile 32 bitlik bir adrese yazılan int değerini 16 bitlik bir adrese yazılan short tipine aktarmak istedik.

Derleyicinin istemsiz (implicit casting) yapmadığı dönüşümü zorla yaptırmak istersek, istemli dönüşüm (explicit casting) yapabiliriz:



Java'da array'in avantajları şunlardır:

arrayin uzunluğu kessinkes sabittir; değiştirilemez. [Arrayin uzunluğu önceden bilinemiyorsa, array yerine Vector ya da ArrayList kullanılmalıdır.]

Arrayin bütün bileşenlerine ancak aynı tipten veri atanabilir. [Farklı veri tipleri ile uğraşmak gerekiyorsa, array yerine Collection kullanılmalıdır.]

Toplam.java

public class Toplam

{

public static void main(String[] args)

{

int[] x = new int [101];

for (int i = 0; i<x.length; i++ )

x = i;

int Toplam = 0;

for(int i = 0; i<x.length; i++)

Toplam += x[i];

System.out.println(Toplam);

}

}

ArrayKopyala.java

/* Bu program

* arrayopy() metodunu kullanmaktadır

*/

public class ArrayKopyala {

public static void main(String[] args){

char[] neredenKopya = {'a','b','c','d','e','f','g','h','i','j'};

char[] nereyeKopya = new char[5];

System.arraycopy(neredenKopya, 2, nereyeKopya, 0, 5);

System.out.println(new String (nereyeKopya));

}

}

For-each Döngüsü

Bir arrayin bütün bileşenlerini sırayla istenen bir işleme sokan döngüye for-each (enhanced for) döngüsü denilir. Bu döngü for döngüsünün yaptığı işi yapar. Sözdizimi daha kısa ve kolaydır. Aşağıdaki tablo iki döngünün sözdizimlerini karşılaştırmaktadır.

For-each döngüsü
Eşdeğer for döngüsü

for (type var : arr) {
body-of-loop
}
for (int i = 0; i < arr.length; i++)
{
type var = arr[i];
body-of-loop
}


Örnekler:

public class ForArray {




public static void main(String[] args){

int[] squares = {0,1,4,9,16,25};

for (int i=0; i< squares.length; i++){

System.out.printf("%d nin karesi %d dir.\n",i, squares[i]);

}

}

}

Çıktı:

0 nin karesi 0 dir.

1 nin karesi 1 dir.

2 nin karesi 4 dir.

3 nin karesi 9 dir.

4 nin karesi 16 dir.

5 nin karesi 25 dir



"bu kisim baskent.edu.tr den alinmistir"




Array tanimlama

class izmir{

public static void main (String[] args){

int dogan[]={2,4,5,6,9};

System.out.println(dogan[3]);
}
}

program
Javada bir dosyanin icindeki satirlar nasil sayilir ?
bu program icin basit bir for loop kullanacagiz.burdaki loop(dongu) sadece dosyanin adini
yazacak ve kactane satir bulundugunu yazacak sonuc olarak.

for(int i=0; i<args.length;i++)
{
System.out.print(args+":");
countLines(args);
}

countLines() hatalari yakalamak icin kullaniliyor.eger hata cikarsa ekranda satirin yerine hata vericek.
probrami hasara ugratmayaca veya durdurmayacak diger satirlarin okumasin sirasinda.

countLines() bir TextReader olusturacak dosyamizi okumak icin.bu islemi getln() hal edecek bizim icin.sonra herhangi bir hatayi yakalamasi
icin try catch kullanacagiz.
cozum asagidaki gibi
burdaki dongu(loop) okuma ve sayma islemini yapiyor TextReaser,in, den

while(in.peek()!='\0')
{//siradaki satiri oku ve say
in.getln();
lineCount++;
}

burdaki in.peek()gorevi bir sonraki karakteri gorur,sonuna ulastiginda '\0' karakterine doner sifir kodu ile.Aslinda baska bir komutta kullanilabilir.eof() gibi.

while(in.eof()==false)
{//satiri oku ve say
in.getln();
lineCount++;
}

/*bu program belirtigimiz dosyalarin satir sayisini sayicak
eger dosya icermiyorsa hata komutu vericek.ama bu islem
sayma islemi diger satirlar icin devam edicek
*/

import java.io.*;
public class LineCount
{
public static void main(String[]args)
{
//The main() routine simply gets the file names from the
// command line and calls the countLines() routine to process
// each name. Since any errors are handled in the countLines()
// routine, the main program will continue after an error occurs
// while trying to process one of the files.
if(args.length==0)
{
// en az birtane satir olmak zorunda
//argumentle calismasi icin
System.out.println("Usage:java LineCounts<file>");
return;
}
for(int i=0; i<args.length; i++)
{
System.out.print(args+":");
countLines()args);
}
}
//islemin sonu

Static void CountLines(String fileName)
{
//dosyanin icindeki satirlari say
//ve herhangi bir hata cikarsa try...catc komutuyla
//her biri icin ayri bir hata komutu ver.
TextReader in;//dosyayi okumak icin
int lineCount;//satrilari saymak icin.

try
{
in=new TextReader(new FileInputStream(fileName));
}
catch(Exception e)
{
System.out.println("eror.can't open file.");
}
lineCount=0;
try
{
while(in.peek()!='\0')
//say ve oku satirlari
in.getln();
lineCount++;

}
}
catch(Exception e)
{
System.out.println(lineCount);

}// satir sayma sonu

}//satir sayma sinifinin sonu

program alistirmalari

1.

//***************************************************************************************************
//SongTime sinifimizda girecegiz su degerler a double, an int, and a String
//name i tanimlar, int the price, the seconds that a song plays,
//ve cikti olarakta name, price, and time farkli bir sekilde elde edecegiz.
import java.util.Scanner;
public class SongTime {
public static void main(String args [])
{
//tanimlayacagiz degerler
int seconds;
double price;
String name;
Scanner in=new Scanner(System.in);
//girecegiz degeri cagiralim.
System.out.println("fiyati,sarki suresini saniye olarak gir:");
System.out.println("ve sarkinin ismini gir,arada bosluklar olusturarak:");
//degerleri okumak icin
price=in.nextDouble();
seconds=in.nextInt();
name=in.nextLine();
//cikti olarak sarkinin adi,fiyati ve zamani dakika ve sani olarak verecek
System.out.println();
System.out.println(name+"cost $"+price+"and is "+seconds/60+"minutes, and " + seconds%60+" seconds long.");
double costPerMinutes=price/((double)seconds/60.0);
System.out.println("cost per minutes is $"+costPerMinutes);
in.close();
}

}

cikti
fiyati,sarki suresini saniye olarak gir:
ve sarkinin ismini gir,arada bosluklar olusturarak:
0.99 119 my song

my songcost $0.99and is 1minutes, and 59 seconds long.
cost per minutes is $0.4991596638


2.

//**************************************
// TimeDemo sinifinda zamani dakika ve saniyeyi cinsinden
//arada bir colon koyarak ayir,ve cikti olarak saniyeyi double cinsinden ver
//**********************************************
import java.util.Scanner;
public class TimeDemo
{
public static void main(String[]args)

{
Scanner inTime=new Scanner(System.in);
System.out.print("enter a time as minutes:seconds:");
String in=inTime.nextLine();
in=in.trim(); //beyaz bosluklari sil
int colon=in.indexOf(':'); //:bul
String minStr=in.substring(0,colon); //dakikayi bul
String secStr=in.substring(colon+1,in.length());//saniyeyi bul
Scanner minScan=new Scanner(minStr); //dakika scannerini olustur
Scanner secScan=new Scanner(secStr); //saniye scannerini olustur
System.out.println("time in seconds is"+(minScan.nextDouble()*60.0+secScan.nextDouble()));


}
}


cikti
enter a time as minutes:seconds:23:45.6
time in seconds is1425.6


3.

/*******************************************************************************
//bu sinifta gecen zamani hesaplayacagiz
//burda ondalik sayilar kullanacagiz,toplamasini cikarmasini yapacagiz ayrica
//**************************************************************************
public class Time
{
double seconds; //saniyeyi double olarak tutuyoruz
//constructors kullaniyoruz bu sinif icin
public Time()
{
seconds=0.0;
}
public Time(double newSeconds)
{
seconds=newSeconds;
}

public Time(int hours,int minutes,double newSeconds)
{
seconds=(double)(hours*3600+minutes*60)+newSeconds;
}


//izleyiciler bu sinif icin

public double getTime()
{
return seconds; //zamana geri don
}
public int getHours()
{
return (int) seconds/3600; //saati saniye cevir


}
public int getMinutes()
{
int remainingSeconds=(int)seconds%3600;//saatten sonra geriye kalan saniyeler icin
return remainingSeconds/60; //dakikadan sonra kalanlar
}

public double getSecond()
{
return seconds % 60.0; //saniden sonra geriye kalanlar
}
public String toString() //don HH:MM:SS.F
{
int hours=(int)seconds/3600;
int minutes=(int)seconds%3600/60;
return hours+ ":"+minutes+":"+seconds%60.0;
}
//Time sinifi icin islemler

public Time plus(Time otherTime)
{
return new Time(seconds+otherTime.seconds);
}
public Time minus(Time otherTime){

return new Time(seconds-otherTime.seconds);
}
}

4.

//matematikte yaklasik degeri bulmak icin
//burda while loop kullanacagiz.



public class NewMath
{
static double squareRoot(double square)
{
double guess=square/4.0;
boolean goodEnough=false;
while(!goodEnough) //durumu girdik.eger yeterli deilse
//asagidaki islemi yapacak.

}
guess=((square/guess)+guess)/2.0;
goodEnough=Math.abs(square-guess*guess)<0.001;//Math.abs mutlak deger icin kullanirli
//0.001 kucukse dongumuz guess geri donup
//ayni islemi yapacak taki 0.001 yakalayana kadar

}
return guess;
}
}

5.

//***************************************************
//bir dosyadan kandegerleri okunacak bu sinifimizda
//***************************************************

public class ReadFile
{
public static void main(String args[])throws IOException //dosya yoksa hata gonder
{
int count=0;
Scanner in=new Scanner(new FileReader("BP"));//in in icine filereader icindeki BP dosyasini atiyor
int thisBP; //thisBP tanimladik while in icinde kullanacagiz
System.out.println(Blood pressures on file BP:");
while (count<=100) //100 esit ve kucuk degeri oku
thisBP=in.nextInt(); //degerleri okuyor
System.out.print(thisBP+" ") //okunan degerleri ekrana yaziyor
count++; //sayiyor 100 yakalayanakadar
}
System.out.println();
in.close();
}
}

6.

//**************************************************
//yukardaki programin aynisini farkli bir sekilde
//yapacagiz burda in.hasNextInt() yardimiyla sayma
//sayma islemi yapcagiz.Bu komut dosyanin icindeki
//tum sayilari otomatik olarak sayar bizim icin
//ayrica saymamiza gerektirmez.
//**************************************************



public class ReadFile
{
public static void main(String args[])throws IOException //dosya yoksa hata gonder
{
int count=0;
Scanner in=new Scanner(new FileReader("BP"));//in in icine filereader icindeki BP dosyasini atiyor
int thisBP; //thisBP tanimladik while in icinde kullanacagiz
System.out.println(Blood pressures on file BP:");
while (in.hasNextInt())
{
thisBP=in.nextInt(); //degerleri okuyor
System.out.print(thisBP+" ") //okunan degerleri ekrana yaziyor

}
System.out.println();
in.close();
}
}

7.


//**************************************************
//flag controlled loop kullanacagiz.boolean yardimiyla
//dikkat edilmesi gereken nokta en basta kontrol eder
//islemi uygunsa devam ettirir
//**************************************************

public class ReadFile
{
public static void main(String args[])throws IOException //dosya yoksa hata gonder
{

Scanner in=new Scanner(new FileReader("BP"));//in in icine filereader icindeki BP dosyasini atiyor
int thisBP; //thisBP tanimladik while in icinde kullanacagiz
bloolean flag=in.hasNextInt(); //dosya icindeki ondalik sayilari sayar
System.out.println(Blood pressures on file BP:");
while (flag)
{
thisBP=in.nextInt(); //degerleri okuyor
flag=thisBP<200&&in.hasNextInt(); //dosyanin icinde sayilar var ise ve sayilar 200 kucuk olursa
if(flag) //dogruysa isleme devam et.
System.out.print(thisBP+" ") //okunan degerleri ekrana yaziyor

}
System.out.println();
in.close();
}
}

8.

//************************************************************
//siradaki programimiz satirlari okuyacak ve buyuk harfleri sayacak
//burda iki tane ic ice while dongusu kullancagiz.
//************************************************************

public static void main(String[] args)throws IOException
{
String line;
int count;
int index;
char letter;
Scanner inFile=new Scanner(new FileReader("text"));
while (inFile.hasNextLine())
{
line=inFile.nextLine();
count=0;
index=0;
while(index<line.length())
{
letter=line.charAt(index);
if(Character.isUpperCase(letter))
count++;
index++;
}
System.out.println("uppercase characters:"+count);
}
inFile.close();
}

Javada switch statementin kullanimi.


belkide ingilizcesi daha faydali olur diye asagidaki bilgilerin ingizce versiyonu:
Switch statement
A selection control structure for multiway branching
Switch label
"case"+constant which labels a code segment
Switch expression
the integral expresion whose value determines which switch label is selected

switch(digit)
{
case1:Statement1;
break;
case2:
case3:Statement2;
break;
case4:Statement3;
break;
default:Statement4;
}
Statement5;
the calue of integralexpression that determines which brach is executed must be of types byte,char,short,or int
case labels are constant possibly amed integral ezpressions;several case labels can be associated with a statment



Switch (anahtar) ifadesi sadece Java’da degil, çogu programlama dilinde kullanilan bir ifadedir. Temel amaci bir degisken degeri ile programin çalismasini çesitli sekillerde kontrol etmektir. Bu if-else ile de yapilsa da switch daha az kod yazma ve jump table gibi yapilarindan dolayi tercih edilmekte.

Switch ifadesinde öncelikle belirlenmis bir int, short, byte ya da char degiskeni olmalidir, çünkü switch ancak bunlarla kullanilir ve böyle bir deger var olmadan switch çalismaz. Bundan sonra switch baslatilir ve degiskenin olasi degerine karsilik gelecek degerler yazilir ve bunlarla karsilastiginda sanal makinenin ne yapacagi ile ilgili kurallar yazilir. Ayrica durumdan sonra da isteniyorsa break ifadesi kullanilir ki switch daha sonra devam etmesin. Derleyici de bu kodu jump table (siçrama tablosu) gibi kendine özgü bir sekle sokup saklar.

Örnek bir switch ifadesi söyle olur.

int Sayi = 5;//degiskenimiz
switch (Sayi) {//Burada Sayi degiskeninin karsilastirilacagi söylenir
case 1 : System.out.println(“bir”);break;
case 2 : System.out.println(“iki”);break;
case 3 : System.out.println(“üç”);break;
case 4: System.out.println(“dört”);break;
case 5: System.out.println(“bes”);break;
case 6: System.out.println(“alti”);break;
default:System.out.println(“yedi”);break;
}

Burada switch ifademizi Sayi adindaki int degerimiz ile kullandik. Bu kodu çalistirirken sanal makinemiz switch ifadesine verdigimiz int degerini alacaktir. Sonra da sirasiyla yazdigimiz durumlarla (case 1: ) karsilastiracaktir. Ilk duruma bakacak ve bunun ona verilen int degeri ile ayni olmadigini anlayinca sonrakine atlayacaktir. Bu sekilde 5 rakamimiza kadar gidecek ve burada aradigini bulunca yapmamizi istedigimiz seyi yapacak yani yazdigimiz System.out.println(“bes”); kodunu çalistiracak, bundan sonra da bakacak ki devaminda break ifadesi kullanilmis, hemen alttaki anaharlara gitmeden duracak. Eger hiçbiri ile eslesmezse en sondaki default cümlecigi çalistirilacaktir.

Kodda case ile ifade edilen durum degisken degerimize esitse takip eden : isaretinden sonra gelen kodlar çalistirilir ve break kelimesi varsa switch durdurulur. Yoksa sonraki durumlar da karsilastirilmaya devam edilir.

Java’da switch kullanilabilse de diger dillerdeki kadar gelismis degildir. Mesela diger diller case kelimesi için sinirlar belirleyebilmekte ( Ör; case 10 – 20 : kod();break; ) . Veya string gibi kullanisli tipler Java’da switch ile kullanilamaz.

Alistirma

double weightlnPounds=165.8;
char weightUnit;
System.out.print("weight in");
switch(weightUnit)
{
case'P':case'p':
System.out.println("pound is"+weightlnPounds);
break;
case'O':case'o':
System.out.println("ounces is"+16.0*weightlnPounds);
break;
case'K':case'k':
System.out.println("kilos is"+16.0*weightlnPounds/2.2);
break;
case'G':case'g':
System.out.println("grams is"+454.0*weightlnPounds);
break;
default:
System.out.println("that unit is not handled!");
break;