Java

2

Giris

Bu Egitim Kimler çin?

Java Platform Bagımsızdır

Java nesne yönelimli bir dildir

3

Java Multithread Programlamayı Destekler

Güvenli ve Saglamdır

Classloader ile gelen güvenlik

Enterprise Uygulamalar çin Gelistirlmistir.

Java Paketleri

4

5

6

7

8

9

10

11

Bugünkü çalısmamızı burada noktalıyoruz. Yukarıda anlatılan nesne kavramları, sınıf nesnesi tasarımı ve metodlara

iliskin açıklamaları aslında sadece iyi bir giris yapabilmeniz amacıyla inceledik. 1lerleyen dersler boyunca bu konuları

tek tek kendi içlerinde detaylandıracagız.

Degisken Kavramı

Tüm programlama dillerinde oldugu gibi Java'da da degiskenler kullanılmaktadır. Degisken; program yazılması

sırasında, içerisinde birtakım degerleri tutan ve kendine ait bir türü olan yapıdır. Bir degiskenin içerisinde tuttugu

deger, program akısı sırasında degistirilebilir. Ayrıca her degiskenin bir türü vardır ve degiskenlerin içlerinde

tuttukları bu degerler de aynı türden olmalıdır.

Kullanılmadan önce degiskenlerin özellikleri hakkında derleyiciye bilgi verilmesi islemine “bildirim” denir. Bir

degisken nesnesi su özelliklere sahip olur:

degisken ismi

degisken türü

degisken içerisindeki deger

degiskenin faliyet alanı

Degisken simlendirme

Degisken ismi, degisken nesneyi temsil eden karakterlerdir. Bu isim belli kurallar dahilinde verilmektedir. Bu

kurallar kısaca söyle açıklanabilir:

degisken isimlerinde bosluk olmamalıdır,

sayfa sayisi -> yanlis

sayfa_sayisi -> dogru

sayfaSayisi -> dogru

degisken isimlendirmede türkçe karakterler kullanılmamalıdır,

ÖzelDegisken -> yanlis

OzelDegisken -> dogru

Degiskenin türü

degisken ile ondalık sayı degerleri tutan degisken aynı türden degildir.

Bir degiskenin içerisinde degerler saklanarak aktarılır ve kullanılırlar. Degiskenler içerisinde saklanan degerlerin de

bir türe iliskin olduklarını ve içlerinde saklanacak degiskenin türü ile aynı türden olmak zorunda olduklarını

unutmayınız. Asagıdaki örnekte integer türünden bir degisken yaratıp içerisinde de 200 sayisini saklayacagız:

public class Degisken {

public static void main(String arg[]) {

int a = 200;

12

System.out.println("a degiskeninin sakladigi deger: " + a + " degeridir");

}

}

Bu kodu yazdıktan sonra daha önceki derslerimizde gösterdigimiz gibi çalıstırınız:

Kodun çalısması sonucunda ekranda su yazıyı göreceksiniz:

a degiskeninin sakladigi deger: 200 degeridir

Java’da “primitive type” denilen degisken türleri vardır. Bu türlere biz ilkel ya da temel türler diyoruz. Daha sonraki

derselerimizde görecegiz ki temel türlerin dısında bir de nesnel türler vardır.

Kullanılan temel veri tiplerini inceleyelim:

Sayısal Veri Tipi Hafızada kapladıgı alan (byte) Sınırları

int 4 -2.147.483.648, +2.147.483.647

short 2 -32.768, +32.767

long 8 -9.223.372.036.854.775.808L ,

+8.223.372.036.854.775.807L

byte 1 -128, 127

float 4 -+ 3.40282347E+38F

double 8 -+ 1.79769313486231570E+308

Ön Eklere liskin NOT:

Bunun nedeni bu veri tiplerinin eklerle birlikte ifade edilmesidir. Bu durum tür bilgilerinin birbirine karısmasını

engeller.

Sayısal Olmayan Veri Tipleri

Yukarıdaki tabloda incelemis oldugumuz veri tipleri sayısal bilgiyi ifade etmek için kullanaılır. Sayısal olmayan bilgiyi

ifade etmek için kullanılan veri tipleri de vardır. Simdi bunları incleyelim:

“char” Veri Tipi:

char veri tipi karakterleri temsil etmek amacıyla kullanılır. Bir karakter klavye ile sisteme tek tus ya da birkaç tus

kombinasyonu ile ama tek seferde girdigimiz sembollerdir.

Hafızada 2 byte yer kaplarlar.

Karakter Kümeleri ve Unicode

Aslında tüm dillerdeki sembolleri içine alan en geis karakter kümesi Unicode karakter kümesidir. Bu küme içerisinde

kullanılabilecek tüm karakterler yer alır ve her karakter hexadecimal olarak ifade edilir. 65536 tane karakteri

içerecek genislige sahiptir. Ancak halihazırda 35000 karakter kullanır.

\u0008 (backspace), \u0009 (tab) gibi...

ASCII karakter kümesi aslında Unicode karakter kümesinin bir alt kümesidir ve ASCII karakterleri 128 tanedir.

Hafızada 1 byte yer kaplarlar.

Bunun dısında bildigimiz ISO8859-9 (latin-5) gibi karakter kümeleri ASCII nin uzantıları olup aslında yine unicode

karakter kümesinin bir alt kümesidir.

13

“boolean Veri Tipi:

Bu veri tipi mantıksal bilgiyi ifade eder ve alacagı deger true ya da false olabilir. Bu degerler ileride görecegimiz

mantıksal operatörler içerisinde ve if, while, for gibi deyim ve döngüler içerisinde kullanılabilir.

Degisken Bildirimi:

Degisken bildiriminde, ilk önce bu degiskenin içerisinde tutacagı degerlerin hangi türden olacagı ve degiskenin

hangi isimle anılacagı bildirilir.

Örnegin:

int a;

double benim_degiskenim;

String isim;

System.out.println() metodu üzerine bir not:

Bu metod java tarafından tanınan ve daha önce yazılmıs bir metoddur. Bu metodu kullanırken parantezler içerisine

yazılan (parametre olarak yazılan) degisken ve sabitler ekranda görüntülenir. Eger parantez içerisine bir degisken

yazılmıs ise bu degiskenin içerisindeki deger ekrana yazılacaktır. Ayrıca + operatörü yardımıyla parantez içerisine

birden fazla tür yanyana yazilabilir. Örnegin:

Degiskenler.java

public class Degiskenler {

public static void main(String arg[]) {

int a; //satır 1

a = 200; //satır 2

int b, c; //satır 3

b = 100; //satır 4

c = 400; //satır 5

int d = 0; //satır 6

System.out.println("a nin degeri: " + a);

System.out.println("a nin degeri: " + a + " b nin degeri: " + b);

d = a + b + c;

System.out.println("Toplam deger: " + d);

}

}

Program çalıstıgında sunu göreceksiniz:

a nin degeri: 200

a nin degeri: 200 b nin degeri: 100

Toplam deger: 700

Bu örnekte aslında degisken bildirimine iliskin farklı yöntemleri görmekteyiz. Bir degisken satır 1'de oldugu gibi ilk

önce yaratılıp daha sonra satır 2'de oldugu gibi içerisine deger verilebilir. Ya da satır 6'da oldugu gibi aynı anda

yaratılıp ilk deger verilir. Bunun yanı sıra virgül kullanılarak aynı türe iliskin olmak üzere satır 3'de oldugu gibi tek

satırda birden fazla degisken yaratılabilir. Bu örnekte aynı zamanda System.out.println metodunun kullanımını

görmekteyiz.

Özel Karakterler liskin Bir Not:

C ve C++ programla dillerinde de oldugu gibi Java'da klavyeden girilen bir takım özel karakterlerin karsılıgı vardır.

Bu özel karakterler bip sesi, enter tusu, alt satır bası, tab tusu gibi karakterlerdir. Bu karakterler kullanılırken

baslarına \ isareti koyulur ve uygun sembol yerlestirilir. Buna göre:

\n : alt satır basına

\t : tab tusu

\\ : \ isareti

14

\” : “ isareti

\b : backspace (bir önceki karakteri silme)

\r : kendisinden önce gelen tüm karakterleri satır basına kadar silme

anlamına gelmektedir.

Simdi kullanıcıdan bir takım bilgileri alan ve daha sonra bu bilgileri ekranda gösteren bir program yazalım. Bu

program çalıstıgında Resim 6'daki gibi JOptionPane sınıfının showInputDialog isimli metodu yardımıyla meydana

gelen bir pencere aracılıgıyla bilgiler kullanıcıdan istenecek ve sonra bundan önceki dersimizde de gördügümüz

JOptionPane sınıfının showMessageDialog isimli metodunun meydana getirdigi mesaj penceresi aracılıgıyla girilen

bilgiler ekranda tekrar gösterilecektir.

Programımızı yazalım:

simGir.java

import javax.swing.*; //s1

public class IsimGir {

public static void main(String arg[]) {

String isim, yas; //s2

isim = JOptionPane.showInputDialog(null, "Lutfen isminizi giriniz: "); //s3

yas = JOptionPane.showInputDialog(null, "Simdi de yasiniz giriniz: "); //s4

String rapor = "Adiniz: "+isim+"\nYasiniz: "+yas; //s5

JOptionPane.showMessageDialog(null, rapor); //s6

//JOptionPane.showMessageDialog(null, "Adiniz:\t"+isim+"\nYasiniz:\t"+yas);s7

System.exit(0);

}

}

Bu örnekte görüldügü gibi ilk olarak kullanıcının girecegi bilgilerin tutulacagı degiskenler s2'de yaratılmaktadır. Eger

bu degiskenler olmazsa kullanıcının girecegi bilgiler bir yerde saklanamayacagı için kullanılamazdı. Daha sonra s3 ve

s4'de JOptionPane.showInputDialog() metodu yardımıyla ekranda giris yapılacak olan input dialog penceresi

çıkartılmaktadır. Ancak bu metodun özelligi, çagrıldıktan sonra geriye, kendisine girilen yazıyı deger olarak üretir ve

bu deger s3 ve s4'de sırasıyla isim ve yas degiskenlerine aktarılmıstır. s5'de ekranda en son bilgilerin gösterilecegi

pencereye yazılacak olan yazı hazırlanmıs ve rapor isimli degiskene aktarılmıstır. Daha sonra String türündeki bu

rapor degiskeni JOptionPane.showMessageDialog() metoduna parametre olarak gönderilerek mesaj penceresi

hazırlanmıstır. Aynı sekilde ekranda belirecek mesaj, s5'de oldugu gibi önceden hazırlanabilecegi gibi hemen o anda

s7'deki gibi parametre olarak da hazırlanabilir. Bu örnekte s5 ve s6 yerine sadece s7'de kullanılabilir.

Sabitler:

Degisken nesnelerin içlerindeki degerlerin degisebileceginden bahsetmistik. Bazı durumlarda tüm program boyunca

yanlıslıkla da olsa degerinin degistirilmemesi gereken nesnelere ihtiyaç duyabiliriz. Bu talebi karsılamak için sabitler

kullanılmaktadır. Sabitlerin bildirimi aynen degisken bildiriminde oldugu gibidir ancak tek fark sabitlerin bildiriminin

basına final anahtar sözcügü getirilmesidir:

Sabitler.java

public class Sabitler {

public static void main(String arg[]) {

15

final double BIRIM_UCRET = 200.5;

double sure = 2.3;

System.out.println(“Bu ay odeme bedeli: ” + BIRIM_UCRET * sure + “ liradir.”);

}

}

Bu örnekte gördügümüz gibi BIRIM_UCRET adında ve türü double olan bir sabit ile sure adında ve türü double olan

bir degisken tanımladık. Bu durumda siz isteseniz bile bu sabiti s1'de oldugu gibi degistiremezsiniz. Eger s1'in

basındaki // ifadesini kaldırırsanız programın hata verdigini göreceksiniz. Sonuç itibariyle sabitleri program içerisinde

bir degerle yaratıp, içerisinde hep bu degeri tutmasını garanti edebilirsiniz. Sabitin içerisinde tutacagı deger ancak

bilinçli olarak ve ilk defa verildigi yerde degistirilebilir.

Operator Kavramı ve Operatörlerin ncelenmesi:

Operatörler sayısal ya da mantıksal ifadelerin birbirleri ile isleme sokulmasını saglayan araçlardır. Program yazarken

bir çok defa hesap yapmak gerekecektir. Bu sayısal hesapların yapılabilmesi için çesitli sayısal operatörler

kullanılmaktadır. Ayrıca yine operatörler yardımıyla bazen de sayısal olmayan ve kelimelerin karsılastırılması,

esitliklerin saglanması ve bunun gibi birbirinden farklı mantıksal islemler de yapmak gerekmektedir.

= operatoru

Bilinen en genel operatörlerden olan esitlik operatörü çift taraflı kullanılır. Sag tarafında yer alan degeri sol

taraftaki degiskene atamaya yaramaktadır. Daha önce yaptıgımız IsimGir isimli örnekte s3 ve s4'de de oldugu gibi,

bazen metodlardan gelen degerleri de degiskenlere aktarmaya yarar. Aslında mantık hep aynıdır. Sagdaki deger

soldaki degiskene aktarılır. Bu operatör kullanıldıgında, ilk once sag taraf hesaplanmaktadır.

+, -, *, / operatorleri:

Bu operatörler klasik matematik islemlerinin hesabında kullanılmaktadır. Ancak istisna olarak + operatorünün daha

önce de gördügümüz IsimGir örnegindeki s5'de oldugu gibi Stringleri birbirleri ile ya da String ve degiskenleri

birbirleri ile baglamak gibi islemlerde de kullanılması mümkündür.

+=, -= /= ve *= operatörleri:

Bu operatörler birlesik operatörlerdir. Genellikle bir degiskenin degerini eski degeri ve yeni bir sabit artımının

toplamı, farkı, bölümü veya çarpımı seklinde degistirmek için kullanılır. Örnegin:

int x = 10;

x = x + 4;

isleminde x degiskeninin son degeri 14 olacaktır. Bu islem aynı sekilde += operatoru kullanılarak da yapılabilir.

Söyle ki:

int x = 10, sayi = 6;

x += 4; //x = x + 4 ile aynı anlamdadır.

sayi = sayi – 6; //sayi -= 6;

++ ve –- operatorleri:

Bu operatorlerin her ikisi de tamamen aynı mantıkta olup verinin degerini 1 artırmak ya da1 eksiltmek amacıyla

kullanılır. Ornegin x = x +1; yazmak yerine x++; yazabilirsiniz. Aynı sekilde x = x -1; yazmak yerine x--;

yazabilirsiniz.

boolean Operatörleri :

16

Daha önce de belirttigimiz gibi eger bir degisken boolean türünde ise alabilecegi sadece iki tane deger vardır. Bu

degerler “true” ya da “false” degerleridir. Bu iki degeri bilgisayar mantıgında 1 ya da 0 a benzetebiliriz.

Bu iki degeri içerisinde saklamak amacıyla kullanılan degiskenler de boolean türünden olacaktır. Bazı operatörler

kullanıldıkları zaman sonuç olarak bu iki degerden birtanesini üretirler. Bu operatörlere mantıksal operatörler denilir.

== ve != operatorleri:

Bu operatör aslında “esit mi? ” sorusunun cevabını üreten mantıksal bir operatördür. Çift taraflı olarak

kullanıldıgında sagdaki ve soldaki degerlerin esit olması durumunda “true” sonucunu üretir. Esitlik yok ise “false”

sonucu üretilecektir. Mesela 3 == 5 islemi false degerini üretir.

== operatorune benzer olan, ancak tam tersini yapan diger bir operatör de != operatörudur. Bu operatör de yine

çift taraflı olarak çalısır ve her iki tarafın birbirine esit olmaması durumunda “true”, esit olmaları durumunda da

“false” degerini üretir. Örnegin 3 != 5 islemi true degerini üretir.

&& ve || (and ve or) Operatorleri:

Bu iki operator mantık islemlerinde kullandıgımız and ve or operatörleridir. Bunlar da çift taraflı kullanılır.

&& operatoru her iki tarafındaki deger true ise true sonucunu üretecek ama sag ya da sol taraftan bir tanesi false

olması durumunda false degerini üretecektir.

|| operatoru de iki tarafındaki degerlerden en az bir tanesi true olması durumunda true degerini üretecek, her iki

tarafın da false olması durumunda false degerini üretecektir.

AnaSinif.java

import javax.swing.*;

public class AnaSinif{

public static void 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);

}

}

>, <, >=, <= operatöleri:

Bu operatörler de çift taraflı çalısırlar ve eger sag sol degerleri gerçeklenirse true aksi taktirde false degerini

üretirler. Örnegin:

3 > 5 //false

17

4 < 10 //true

3 >= 3 //true

() Tür Dönüstürme Operatörü

Su ana kadar ögrendigimiz kadarıyla belli bir türe iliskin degerleri aynı türden degiskenler içerisinde saklıyor ve

kullanabiliyorduk. Ancak bazı durumlarda farklı türlerin birbirleriyle isleme girmeleri ve bir türe iliskin bir degerin

aynı olmayan türde bir degiskene atanması gibi islemler gerekebilir. 1ste bu gibi durumlarda bir tür dönüsümü söz

konusu olabilir.

Tür dönüsümleri de belirli kurallar dahilinde ve belirli bir hiyerarsi ile olmaktadır. Tür dönüsümleri sırasında bazen

bilgi kaybının da olabilecegini unutmamak gerekir. Bunun nedenin her türün ifade ettigi bilginin sınırlarının ve

hafızada kapladıgı alanın farklı olmasından kaynaklandıgını hatırlayınız. Asagıda bilgi legal olan tür dönüsü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üsü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üsüler otomatik olarak gerçeklesen dönüsümlerdir. Ancak kasıtlı olarak da tür dönüsümü

yapılabilir.Bir degerin türünü dönüstürmek için degerin soluna parantez içerisinde degistirmek istediginiz türün adını

yazmanız gerekir.

public class AnaSinif{

public static void 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);

}

}

Bu örnekte gördügümüz gibi k degiskeninin içerisindeki deger c degiskenine atandıgı için c nin degerinin de 12.96

olmasını beklerdik. Ancak atama sırasında ( ) operatörü ile bir tür dönüsümü yaptık ve bilgi kaybından dolayı c nin

degeri 12 oldu. Çünkü int türünden bir degisken virgülden sonra deger alamaz.

Tür Dönüsümlerine liskin Özel Metodlar

Tür dönüsümlerini ( ) operatüörü ile yapabilecegimiz gibi bu is için yazılmıs bazı özel metodları da kullanabiliriz.

Mesela String olarak verilmis olan “12” degerini 12 sayısı gibi kullanamayız. Çünkü bu deger çift tırnak içerisinde

18

verilmistir ve bir String'dir. Yani siz bu degerle bir sayıyı toplamaya kalkarsanız sonuç da otomatik tür

dönüsümünden dolayı bir String olacaktır. Su örnege dikkat edelim:

public class AnaSinif{

public static void main(String arg[]){

String a = "12";

int b = 13;

String c = a + b;

System.out.println("Sonuc: "+c);

}

}

Gördügünüz gibi java a+b isleminin sonucunu bir String türü olarak belirlemek konusunda bizi zorlamaktadır.

Sonucu string olarak hesapladıgımzda da bu sefer cevap 25 olması gerekirken 1213 tür. Aslında bu sonuç bir sayı

degil bir Stringdir. Yani bir görüntüdür. O halde sayı gibi verilmis bir Stringi nasıl sayıya çevirecegiz? Bunun için

kullanılacak metod Integer isimli bir sınıfın parseInt() isimli metodudur. Mesela kullanıcıdan

JOptionPane.showInputDialog() metodu ile yasını isteylelim ve girdigi yas ile 3 sayısını çarpıp sonucu bulalım.

Ancak biliyoruz ki bu sekilde alınan girisler sayı olarak degil String olarak algılanıyorlar. O halde bu String'i de

Integer.parseInt() metodu yardımıyla int türüne dönüstürelim:

import javax.swing.*;

public class AnaSinif{

public static void main(String arg[]){

String yas = JOptionPane.showInputDialog(null, "Yasinizi

giriniz: ");

int sonuc = Integer.parseInt(yas) * 3;

JOptionPane.showMessageDialog(null, "Hesap sonucu: "+sonuc);

}

}

Buna benzer diger 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 ögrenilebilir.

Stringler

Daha önce sözdizimi olarak da bahsettigimiz 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 diger türlerden biraz daha farklıdır. Burada

istenen, Stringlerin metodlara sahip oldugu kavramını vurgulamak ve gerektikçe bu metodları kullanabilecegimizi

göstermektir. Bu amaçla bütün metodlar burada anlatılmayacaktır:

“string”.length Degiskeni

Bu degisken bir stringin kaç karakterden olustugunu yani uzunlugunu verir.

“string”.equals(“diger string”) Metodu

1ki String türüne iliskin degerlerin esitligini sayısal degerlerde kulandıgımız == operatörü ile kontrol edemeyiz.

Bunun yerine String.equals metodunu kullanırız. Bu metod, kendisine parametre olarak verilen “diger string” degeri

eger “string” degerine esitse true, degilse false degerini üretir.

“string”.compareTo(“diger string”) Metodu

19

Bu metod kendisine parametre olarak verilen “diger string” ile “string” degerini kıyaslar. Eger iki string esitse metod

0 degerini, “string” büyükse 1 degerini, “diger string” büyükse de -1 degerini üretir.

import javax.swing.*;

public class AnaSinif{

public static void 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 girdigi

string, isim degiskenine atılmakta ve daha sonra da girilen bu stringin uzunlugu öntanımlı isim.length degiskeni ile

alınıp uzunluk degiskenine atanmaktadır. Biz aslında length isminde bir degisken yaratmadıgımız halde, yukarıda

anlatıldıgı gibi isim degiskeni aslında bir String oldugu için, kendi bünyesinde otomatik olarak bu length degiskenini

ve diger String metodlarını barındırmaktadır. Nitekim örnekte de gördügümüz gibi; gercekSifre isimli String

degiskeni ile equals isimli öntanımlı metodu kullanarak, iki stringi birbirleriyle kıyaslayabilmekteyiz.

Vazgeçilmez Kaynagı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ıs olduguna ve bu sınıfların

içerisinde de, kullanabilecegimiz bir çok degisken ve metod olduguna deginmistik. Hangi sınıfların ne ise

yaradıklarını, ve içlerinde hangi metod ve degisken barındırdıklarını ve bunları nasıl kullanabilecegimizi ezbere

bilmek imkansızdır. 1ste bu yüzden, her java programcısnın vazgeçemeyecegi java dökümantasyonunu kullanmak

gerekir.

Dökümantasyonu online olarak http://java.sun.com/j2se/1.4.1/docs/api/ adresinde bulacagınızı ilk dersimizde

söylemistik.

20

Bu sayfayı açtıgınızda karsınıza üç çerçeveden olusmus bir ekran gelmektedir. Bu ekranda, sol üst kısımda “All

Classes” isimli baglantıyı tıkladıgınızda, sol at kısma Java'da öntanımlı tüm sınıfları temsil eden baglantılar

yüklenecektir. Hakkında bilgi almak istediginiz sınıf ismini bulup üzerine tıkladıgınızda da sagdaki kısma bu sınıf

hakkındaki tüm metodlar, degiskenler ve bilgiler gelecektir. Resim 7'de çok sık kullandıgımız JOptionPane isimli

sınıfın showMessageDialog isimli metoduna iliskin bölümü görmekteyiz.

Bu dökümantasyonu online olarak görüntüleyebileceginiz gibi, bilgisayarınıza indirip offline olarak da

kullanabilirsiniz. Bu islem için http://java.sun.com/j2se/1.4.1/download.html sayfasından dökümantasyonu

indirebilir ve yine aynı sayfada bulacagını kurulum talimatları ile (Installation Instructions) sisteminize

yükleyebilirsiniz.

Java ile Programlama

Bölüm 3:

Bundan önceki dersimizde Java programlama dilinde degiskenlerin nasıl kullanıldıklarını operatörleri ve vazgeçilmez

kaynagınız olan Java Dökümantasyonu'nu nasıl kullanacagımız ögrenmistik. Bu sayımızda isi biraz daha ileri

götürecek ve program akısını kendi istegimiz dogrultusunda yönlendirebilecegimiz deyimler ve döngüleri

ögrenecegiz.

Yeni bir dil ögrenmenin en zor yanı, dilin temel kurallarını ögrenme asamasının oldukça yogu ve sıkıc geçmesidir.

Bunun nedeni de ögrenme asamasında sınırlı bilgiyle henüz ele avuca sıgar uygulamalar gelistiremiyor olmamızdır.

Sizlerin de su asamada aynı sıkıntıyı çektiginizi tahmin ederek, motivasyonunuzu artırmak amacıyla java içerisinde

yer alan demoları göstermek istiyorum. Az sonra nasıl çalıstırabileceginizi anlatacagım bu uygulamaları inceleyerek,

ileride varacagınız noktayı görme sansı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üklediginiz yerdir ve ismi de muhtemelen

ana dizinin tam yolu:

onunda için de SwingSet2.jar adındaki uygulamayı önce jfc dizini içerisine girerek su sekilde çalıstırabilirsiniz:

java -jar SwingSet2.jar

Bu uygulamayı dilediginiz gibi karıstırabilir hatta j2sdk dizini içerisindeki demo dizinin ve altındaki diger tüm

uygulamaları da inceleyebilirsiniz.

Java'da Deyim ve Döngüler:

Program yazarken, yazdıgımız kodların yukarıdan asagıya dogru sırasıyla çalıstırıldıgını biliyoruz. Ancak bazen bu

kodların bu sırada degil de belirli sartlara baglı olarak birkaç satırın atlanıp ileriden devam edilmesi ya da aynı

satırların birden fazla sayıda çalıstırılması gibi isteklerimiz olabilir. 1ste bunun için kullnacagı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 baslayarak

asagı satırlara dogru ilerleyen program akısını, bazı satırları belli durumlarda okumadan, ya da bazı satırları birden

fazla defa okuyacak sekilde yönlendirmemiz mümkün hale gelir.

Ancak bu deyim ve döngülerin daha iyi anlasılması açısından öncelikle faliyet alanı kavramına deginmekte yarar

var.

Faliyet Alanı Nedir Ne se Yarar?

Faliyet alanı, yazdıgımız program içerisinde belirli bölgeleri temsil eden ve nesnelerin etkin oldugu sınırları belirleyen

alanlardır. Bir nesnenin etkin oldugu 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

degisken eger { ve } arasında tanımlanmıssa bu degisken bu iki parantez dısında kullanılamaz. Buna göre

degiskenin faliyet alanı da bu iki parantez içerisinde ya da yaratıldıgı alan içerisinde sınırlıdır.

/**** Main.java ****/

import javax.swing.*;

class Main {

public static void 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ıs ve tüm satırlardan sonra da } ile kapatılmıstır. Bu faliyet alanının içinde de k degiskeni

tanımlandıktan sonra yine { ile baska bir faliyet alanı açılmıs ve bu yeni faliyet alanında da sadece c degiskeni

yaratılmıstı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 degiskeni tanımlanmamıs oldugu içerideki faliyet alanı içerisinde de kullanılabilir. Ancak tersi mümkün

degildir. Yani c degiskenini

mesajı alacaktık.

/**** Main2.java ****/

import javax.swing.*;

class Main2 {

public static void 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ısmayacaktır

/*******************/

Faliyet alanına iliskin unutulmaması gereken bir sey daha vardır: Aynı faliyet alanı içerisinde, aynı isimli birden fazla

degisken tanımlanamaz. Bu örnekte k nın faliyet alanı, c nin faliyet alanını da kapsadıgından, c nin tanımlandıgı

yerde k adında baska bir degisken daha tanımlayamazsınız. Çünkü baska faliyet alanı olsa da, içerideki faliyet

alanında yukarıda tanımlanan k degiskeni hala geçerlidir. Buna dikkat ediniz.

Faliyet alanına iliskin bu bilgilerle artık deyim ve döngüleri inceleyebiliriz.

if Deyimi:

if deyimi belli bir sart saglanması durumunda program akısını kendi faliyet alanı içerisine yönlendirir. Kendi faliyet

alanının en son satırına kadar kodları çalıstırır ve daha sonra da program akısı if deyiminin faliyet alanının bittigi

yerden devam eder.

/***** Deyimler1.java ********/

import javax.swing.*;

class Deyimler1 {

public static void 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);

}

}

/**********************/

Daha teknik söylemek gerekirse, sartın saglanması demek, aslında if deyiminin kontrol parantezleri içerisindeki

ifadenin true olması demektir. (Bundan önceki sayıda anlattıgımız, “boolean türü ve boolean operatörleri” konusunu

hatırlayınız!). Aynı sekilde bu sartın saglanmaması ise ifadenin false degerini üretmesi anlamına gelir. Yukarıdaki

örnekte not > 50 ifadesi eger false olursa ekrana hiç bir mesaj gelmeyecektir. Ancak true olursa “Tebrikler. Bu

dersten geçtiniz” mesajını alırsınız. Burada girdiginiz notun aslında bir String türünde oldugunu ve bu degerin

Integer sınıfının parseInt metoduyla sonradan integer türüne dönüstürlüp kullanıldıgına dikkat ediniz. (Bundan

önceki sayıda yer alan “Tür Dönüsümlerine 1liskin Özel Metodlar” konusunu hatırlayınız.)

Peki ya eger kullanıcı notu 50'den küçük olsa da bir mesaj almak istiyorsa ne yapacak. 1ste bu durumda

.....

if(ifade) {

....

}

else {

....

}

kalıbını kullanmak gerekecektir. Bu kalıba göre program akısı, eger if içerisindeki ifade true ise if deyiminin, degilse

else deyiminin faliyet alanı içerisine yönlencektir. Az önceki örnegi genellestirelim:

/***** Deyimler2.java ********/

import javax.swing.*;

class Deyimler2 {

public static void 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);

}

}

/**********************/

Aktif olarak projelerde çalıstıgınız zaman kullanıcı isteklerinin bitmedigini göreceksiniz Diyelim ki bu sefer de

kullanıcı programa girdigi nota göre bir harf ile derecesini ögrenmek 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ı ise

yaramayacaktır. Bu durumlarda if, else if, else if, .... , else kalıbını kullanmak gerekir. Örnegi inceleyiniz

/****** Deyimler3.java ******/

import javax.swing.*;

class Deyimler3 {

public static void main(String[] args) {

String kaldiMesaji = "Dereceniz F: Bu dersten kaldiniz.";

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) {

JOptionPane.showMessageDialog(null, "Dereceniz: D");

}

else {

JOptionPane.showMessageDialog(null, kaldiMesaji);

}

System.exit(0);

}

}

while Döngüsü:

Kullanıcı istekleri hala bitmiyor Simdi de kullanıcımız bizden program çalıstıgında sürekli notu sormasını ve buna

karsılık düsen dereceyi bize vermesini istiyor. Ne zaman ki giris “Q” karakteri olur, o zaman program sonlansın

diyor. Bu durumda not girisi bir döngü içerisine sokulmalıdr. Bu döngünün en basında önce girisin Q olup

olmadıgı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, eger içerisindeki ifade true ise program akısını kendi içine yönlendirir. Program while

faliyet alanının en sonuna geldiginde tekrar while döngüsünün ilk satırına döner ve ifadeyi yine kontrol eder. Bu

islem, while içerisindeki ifade false olana kadar devam eder.

Not:

ifadeyi degistirecek bir komut yazmazsanız, ilk durumda bu ifade hep true oldugu için

ve döngü içinde de hiç degismedigi için sonsuz bir döngüye girersiniz.

while(ifade) {

satir 1

satir 2

...

satir n

/*sSimdi akiss tekrar while(ifade) satirina

yönlenecek ve kontrol yapılacaktır. eger

ifade false olmussa program akısı

satir n+1 den devam etmektedir.*/

}

satir n+1

Bu durumda kullanıcımızın yeni istegine göre örnegi tekrar düzenleyelim:

/**** Deyimler4.java ****/

import javax.swing.*;

class Deyimler4 {

public static void main(String[] args) {

String yanlisNot = "Yanlis not girisi! Tekrar deneyiniz.";

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");

}

notStr = JOptionPane.showInputDialog(null, giris );

not = Integer.parseInt(notStr);

}

JOptionPane.showMessageDialog(null, "Program Sonlandi.");

System.exit(0);

}

}

/**************************/

break Anahtar Sözcügü:

Bazen bir döngü içerisindeyken, aslında döngünün bitmesine neden olacak sart saglanmadıgı halde özel olarak

döngüyü sonlandırmak istedigimiz durumlar dogacaktır. Bu durumların saglanması neticesinde program break

komutunu gördügü yerde içerisinde bulundugu ilk döngüyü (çünkü iç içe döngüler de olabilir) sonlandıracak ve

döngüden sonraki satırdan itibaren çalısmaya baslayacaktır

/**** Sifre.java ****/

import javax.swing.*;

public class Sifre {

public static void main(String arg[]) {

String kontrol_isim = "elvantasbas";

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")) {

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 {

JOptionPane.showMessageDialog(null, "Merhaba "+k_adi);

}

System.exit(0);

}

}

/********************************/

Programda while parantezi içerisinde yazılı olan

kontrol_isim'e esit olursa

basında yazılı olan

girilmedigi sürece bu while parantezi içerisinde

dolayısı ile while bloguna girilmeyecektir.

Bu örnekte kullanıcı, kullanıcı adını yanlıs girdigi ama x girmedigi sürece while döngüsü bloklarında kullanıcıdan

tekrar isim girmesi istenecektir. 1sim yanlıs girildiginde ve x girildiginde program while içerisindeki if bloguna

girecek ve burada islem sonlandırılıyor mesajı ile döngüden

hemen önce

tutmak için kullanılan bir ara degiskendir. Döngüden çıkıldıktan sonra eger x degiskeninin degeri

blokları bitimindeki if bloklarına girilecek ve ekrana hosçakalın mesajı yazılacaktır. Eger döngüden x yazıldıgı için

degil de kullanıcı adı dogru girildigi için çıkılmıs ise x degiskenin degeri

onun yerine else bloguna girilecektir. Buradaki mesaj ekrana geldikten sonra else blogundan da çıkılacak ve

System.exit(0)

for Döngüleri:

Su ana kadar bir kosul saglandıgı sürece otomatik olarak döngüye girilmesini while deyimi ile yapabilecegimizi

gördük. Ancak bu döngü kosul saglandıgı sürece, belli bir tekrar sayısı kadar degil her zaman devam ediyordu.

Kosul saglansa bile belirli bir tekrar sayısı da belirlemek istiyorsak o zaman for döngüsünü kullanmak gerekir. for

döngüsü söyle çalısmaktadır:

for( <ilk deger> ; <kosul> ; <ifade> ) {

...

}

Buna göre ilk deger ile baslayan döngü ile program for bloguna girdikten sonra blogun sonuna geldiginde kosulun

saglanıp saglanmadıgını kontrol edecek ve kosul saglanıyorsa ifade yi gerçekleyip tekrar döngüye girecektir.

Örnegin:

/**** ForDongusu.java ****/

public class ForDongusu {

public static void main(String arg[]){

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

System.out.println("i nin degeri: "+i);

}

}

}

/***********************/

Bu program çalıstıgında ekrana 10 satır boyunca

i nin degeri: 0

i nin degeri: 1

...

i nin degeri: 9

yazacaktır. Program akısı her döngüye girisinde i nin degeri ekrana yazılmakta ve blok sonunda i++ ifadesinden

dolayı bu deger bir artırılmakta ve kosulun saglanıp saglanmadıgına bakılmaktadır.

switch Deyimi:

switch deyimi kullanımı da, birden fazla else if kullanımına alternatiftir. Mesela yazdıgınız programda kullanıcıdan bir

giris isteyebilirsiziniz. Kullanıcının girecegi bu deger 4 tane degerden birtanesi olabilir ve siz olası her deger içöin bir

islem 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 söyle çalısmaktadı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 islemler;

break;

}

Bu yapıya göre program akısı, degisken içindeki degere göre case anahtar sözcügü ile belirlenmis uygun satıra

atlar. O satudaki ifade ya da islemler gerçeklestirilikten sonra switch deyiminden çıkılır. Asagıdaki örnek

programımızda kullanıcıya bir menü sunalım ve bu menüden bir seçenegi seçmesini isteyelim. Bu seçim neticesinde

de seçime uygun bir mesajın ekrana gelmesini saglayalım. Örnegimizde ilk basta yaratılan secim_flag adındaki

boolean degisken ilk deger olarak true oldugu için, program akısının ilk seferde while döngüsüne girecegini garanti

etmis oluyoruz. Eger kullanıcı listede olmayan bir seçim girecek olursa, secim_flag degiskeni tekrar true degerini

alacak ve kullanıcıdan tekrar bir giris yapması istenecektir. Kullanıcı listede olan bir giris yaparsa program

sonlanacaktır. Bu durumda listede olmayan girsler girldigi sürece program çalısmaya devam edecektir.

/**** Menu.java ****/

import javax.swing.*;

public class Menu {

public static void 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:

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ügü

Herhangi bir döngü içerisine girildginde, daha döngü blogunun sonuna gelinmeden o andaki adım için islemleri

sonlandırıp bir sonraki döngü adımına hemen geçilmek isteniyorsa continue anahtar sözcügünü kullanmak gerekir.

Mesela yazdıgı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

gelindiginde durdurup bir sonraki degerle döngüye devam etmek gerekmektedir:

/**** Toplama.java ****/

public class Toplama {

public static void 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);

}

}

Bu örnekte % operatörünü kullandık. Bu operatör soldaki sayının sagdaki sayıya bölümünden kalan degeri üretir.

Yani i sayısı o anda hangi degere sahipse, bu degerin 3'e bölümünden kalan sayının 0'a esit olup olmadıgı kontrol

edilmektedir. Eger bu kalan sayı 0'a esit ise demek ki sayımız ^ya da 'ün bir katıdır. Bu yüzden if parantezi

içerisindeki == kontrolü saglandıgından dolayı true degeri üretilecek ve dolayısı ile if blogu içerisine girilecektir. If

blogu içerisinde continue anahtar sözcügü sayesinde o andaki for adımı sonlanacak ve bir sonraki i degeri ile for

blogunun en basına dönülecektir.

Diziler

Bu ana kadar programla içerisinde kullanacagımız degiskenler oldugunu ve bu degiskenlerin de belirli türelere sahip

olduklarını görmüstük. Ancak biliyoruz ki her degisken sadece bir deger tutmaktadır. 1çerisinde deger tutan bu

degiskenler de bellekte farklı yerlerde saklanmaktadır.

Dizi denilen degiskenler ise içlerinde birden fazla deger tutarlar ve diger degiskenler gibi belirli bir türe sahiplerdir.

Ayrıca bu degerler de bellekte ardısıl biçimde saklanırlar ve hepsi aynı türe iliskin olmak zorundadır. Buna göre bir

diziyi aslında arka arkaya sıralanmıs bir degisken paketi olarak düsünebiliriz.

Ancak sunu unutmamalıyız: Dizilerin içlerinde tutacakları eleman sayısı sahiptir. Bazı elemanlara siz deger

vermesseniz bile bu elemanlar için bellekte yer ayrılır. Ayrıca dizinin içerisinde saklanan degerlerin türü ile dizinin

türü aynı olmak zorundadır.

Dizilerin Yaratılması:

Normalde degiskenleri yaratırken degiskenin 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 olusur. Birinci adım “bildirim”

dedigimiz ve dizinin türünü ve dizi degiskeninin adını belirledigimiz adımdır:

int [] sayilar;

Burada “sayilar” adinda ve içerisinde integer degerler tutacak olan bir dizi bildirimi yapmıs olduk. Ancak bu dizi

bildiriminin degisken bildiriminden farkının [ ] karakterlerinin eklenmesi seklinde olduguna dikkat ediniz.

1kinci adım ise tahsisat denilen ve dizi degiskenin kaç tane deger tutacagını belirledigimiz adımdır

sayilar = new int[10];

Bu örnekte, daha önce bildirimini yaptıgımız sayilar dizisine 10 tane integer sayı tutabilecek kadar alanı tahsis

etmis olduk. Bu islem aslında

degiskenimiz belirlenmis ve degerleri saklayabilecegi alan tahsis edilmis olsa bile, dizimizin içerisinde hala hiç bir

deger saklanmamaktadır. Dizilerin içerisinde elemanlara erismek 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 deger atamak için:

sayilar[9] = 12;

sayilar[0] = 3;

seklinde [ ] ve bir indeks numarası kullanılarak atama yapılabilir.

NOT:

örnegimize göre sayilar dizisinin son elemanına

olacaktır çünkü 10 nolu indekste 11. eleman olur. Ancak dizimiz sadece 10 eleman tutacak alan tahsis edilmisti!

Simdi 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 void 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[i] = giris;

18 }

19

20 String mesaj = "isim Listesi\n********";

21

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

23 if(isimler[i] != null)

24 mesaj += "\n"+i+" --> "+isimler[i];

25 }

26

27 JOptionPane.showMessageDialog(null, mesaj);

28 System.exit(0);

29 }

30 }

/******************/

Bu programda önce kullanıcının kaç kayıt girecegi sorulmaktadır. Çünkü dizilerin uzunlugu sabittir ve önceden bir

defa yer ayrıldıgından bu uzunluk bilinmelidir. Uzunlugu degisen dizileri için baska algoritmik çözümler vardır ancak

degismeyen ser bir dizinin uzunlugu sabittir ve sonradan uzatılıp kısaltılamaz.

Bu örnekte kullanıcının girecegi 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. Eger kullanıcı basta belirledigi kadar kayıt girmekten vazgeçip o anda islemi

sonlandırmak isterse isim yerine X girisi yapabilecektir. Programda her giris yapıldıktan sonra bu degerin X olup

olmadıgına bakılmaktadır (14. satır). Eger giris X olursa döngü break ile sonladırılır (15. satır). Degilse giris diziye

yazılır ve döngü devam eder (16. satır).

NOT:

denilen özel bir degerle doldurulur.

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 degiskeni içerisine atılmaktadır (24. satır). Daha sonra bu mesaj isimli degisken ekrana yazılacaktır

(27. satır). Eger kullanıcı diziye ayrılan yer kadar kayıt girmeyip arada X ile çıkıs yapmıssa, bu durumda diziye

girilmemis olan elemanlar yerine

yüzden o andaki adımda, diziden gelen degerin

degiskeninine eklenmektedir (23. satır).

Dizilere iliskin temel bilgileri ögrenmeyi burada sonandırıyoruz. Siz de kendi yeteneklerinizi sınamak icin diger

dersimize kadar tüm ögrendiklerinizi kullanarak asagıdaki uygulamayı yapmaya çalısınız. Bu uygulamanın cevabını

diger dersimiz içerisinde bulabileceksiniz :

Dizi Yaratma Sekilleri

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}

Java ile Programlama:

Bölüm 4:

Dersimize son dersimizde verdigimiz uygulamanın çözümü ile baslayacagız. Uygulamamızı tekrar hatırlatalım:

Uygulama:

aldıgınız bir ismi aratınız. Eger isim dizinin içerisinde bulunursa bu ismin indeks numarasını ekrana yazdırınız.

Bulunamazsa ismin bulunamadıgına dair bir mesaj yazdırınız.

import java.awt.*;

import javax.swing.*;

public class Ara {

public static void main(String arg[]) {

String []isimler = {"Hakan Aykac", "Murat Akar", "Cenk Gündüz",

"Cem Daggeçen"};

String aranacak = JOptionPane.showInputDialog(null,

"Aradiginiz ismi giriniz: ");

int index = -1;

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

if(isimler[i].equals(aranacak)) {

index = i;

break;

}

}

if(index == -1)

JOptionPane.showMessageDialog(null, aranacak+" ismi dizide mevcut degildir.");

else

JOptionPane.showMessageDialog(null, aranacak+" isminin index numarasi:

"+index);

System.exit(0);

}

}

Metod Kavramı ve Java’da Metodlar

Daha önce bazı noktalarda metodlara deginmistik. Metod denilen kavramın, program içerisinde yazılmıs küçük

program parçaları oldugunu söyleyebiliriz. Metodlar aslında önceden tanımlanmıs birtakım islem sekilleridir. Bu

sekilde görevleri metodlar attında olusturarak gerektiginde çagırabiliriz. Bunu söyle bir örnekle hayalimizde

canlandıralım:

Yazmıs oldugumuz programımızı bir robota benzetelim. Bu robota çesitli görevler yükleyelim. Bunlardan bir tanesi

de “su getir” görevi olsun. Bu görev su sekilde tanımlansın:

Mutfaga git

Bardaga su doldur

Su dolu bardagı sahibine getir

1ste siz her su isteme islemi için bu üç komutu robota vermek yerine, sadece 1 defa “su getir” görevini

tanımlayabilirsiniz. Daha sonra da su istediginizde, sadece bu görevi robota vermeniz, bu üç komutun çalıstırılması

için yeterli olacaktır. Sonuçta, Java’da da metodlar bu sekilde birden fazla komutu tek seferde ve istenildigi zaman

çalıstırabilmek amacıyla tasarlanır.

Asagıdaki örnekte (Metod.java), ekrana sadece Merhaba yazan bir metod gösterilmektedir:

“

yaratılmıstır. Ancak bu metodun da tıpkı main metodu gibi sınıfın içerisinde yaratıldıgına dikkat ediniz. Metodun

yaratılması sırasında ilk satırda

public static void MesajGoster()

seklinde metodun adı ve daha sonra da

{

}

parantezleri içerisinde bu metodun gerçeklestirecegi komutlar yazılmaktadır.

Metodun adını yazdıgımız bu ilk satıra “metod bildirimi” denilir. Metod bildirimine iliskin ayrıntıları bilgilerimiz

arttıkça tamamlayacagız.

Not:

ismidir)

Not:

Metodların Çagrılması

Simdi bu Mesaj.java dosyasını çalıstırmaya kalktıgımızda, dosyanın düzgün bir sekilde çalıstıgını ancak ekranda hiç

bir mesaj yazılmadıgını göreceksiniz. Sakın sasırmayın! Böyle olması çok normal. Bir metod yazıldıgı zaman bu onun

aynı zamanda çalısacagı anlamına gelmez. Metodun çalısması için sizin onu çagrmanız gerekmektedir. Bunu robota

“su getir” emrini vermenize benzetebiliriz. Siz bu emri daha önce tanıtmıs olsanız bile, emri vermeden robot size su

getirmez. Aynı sekilde yazılmıs bir metodun çalısması için de metodun “program akısının oldugu yerde” çagrılmıs

olması gerekir. Bir metodu çagırmak için metodun yaratıldıgı sekilde adını ve adın yanına da ( ) parantezlerini

eklememiz gerekir:

...

MesajGoster();

...

gibi... O halde örnegimizde de metodun çalısmasını görmek için main metodu içerisinde MesajGoster isimli

metodumuzu çagıralım:

Programımız ilk çalıstırıldıgında her zaman main metodu “otomatik olarak çagrılır” Daha sonra main metodu

içerisinde yazılan her satırdaki komutlar sırasıyla çalıstırılır. Program akısı MesajGoster(); seklinde yazılmıs olan

metod çagırma komutuna geldiginde MesajGoster metodunun yazıldıgı yere atlar ve buradaki komutları sırasıyla

çalıstırırarak tekrar main metodunda kaldıgı yerden çalısmaya devam eder. Tabi ki metod ismi MesajGoster den

baska bir isim de olabilir. Sadece buradaki örnekte bir metod yazılmıs ve adı öyle konulmustur. Bu akıs prensibi her

metod için geçerlidir.

Simdi islerimizi daha da genellestirelim ve ekrana sadece Merhaba degil de, istedigimiz bir mesajı gönderen bir

metod olusturalım. Aslında bu isi zaten

yapabiliyorduk. Ancak bu metodun adı çok uzun olmakla beraber program içerisinde birden fazla yerde

çagırdıgımızda çok fazla yer kapladıgını görmekteyiz. Bu yüzden aynı isi yapan ve adı sadece “

yazalım. Ancak bu metoda her seferinde hangi mesajı yazacagını da göndermemiz gerekecektir. Çünkü her

seferinde ekrana baska bir mesaj yazılmasını isteyebiliriz. 1ste bu noktada karsımıza parametre kavramı çıkar.

Metodların Parametreler ile Kullanımı

Parametreler yardımıyla metodlara birtakım degiskenler göndermemiz mümkündür. Önceki örneklerimizde

MesajGoster isimli örnek metodumuzu parametresiz olarak kullandık. Asagıdaki örnekte M isimli metod parametre

ile çalısan bir metod olup, ekrana, kendisine parametre olarak gönderilen mesajı basmaktadır.

Burada dikkat edilirse 6. satırda çagrılan M metodu 10. satırda parametre ile bildirilmistir. Metod bildiriminde

parametreler metodun ( ) parantezleri arasında önce tür adı ve daha sonra da parametre adı yazılarak ve birden

fazla parametre arasında da virgul kullanılarak tanıtılabilir. Yani:

public static void Metod_Adi(<tür> parmaetre1, <tür> parametre2) {

...

}

seklinde bildirimi genellemek mümkündür. Örnegin:

public static void M(String mesaj):

içerisinde “mesaj” ile temsil eden bir metod bildirimi.

public static void Metod2(int x, double y):

türünde bir parametre alan ve kendi adı da Metod2 olan bir metodun bildirimi.

Bu sekilde bildirimi yapılan bir metodu çagırıken de metodun adı ve daha sonra da ( ) parantezleri içerisine

bildirimde verilen sırada ve türlerde degerle göndermemiz gerekir. Mesela M isimli örnek metodumuza her seferinde

String türünde farklı mesajlar gönderebiliriz. Gönderilen b her String degeri, metod bildiriminde “mesaj” isimli

degiskene kopyalanır ve metodun içerisinde de bu degisken aracılıgıyla ele alınır. Mesela bildirimi

public static void Islem(int sayi, String mesaj)

seklinde yapılmıs olan bir metodu su sekillerde çagırabiliriz:

Islem(6, “Bugun hava guzel”);

Islem(12, “Çok çalısmak lazım”);

Islem(4, “Java Ögrenmek Lazım”);

...

Burada yapılan sey aslında metodun çagrılması neticesinde gönderilen degerler, metod bildirimi ile tanımlanan

degiskenlere sırasıyla kopyalanır (ya da atanır.) Öyle ki;

Islem(6, “Bugun hava guzel”);

seklinde metodu çagırdıgımızda 6 degeri sayi degikenine ve “Bugün hava güzel” degeri de mesaj degiskenine atanır

ve metod içinde bu sekilde kullanılır.

Ancak Islem(“Selam”, 12); gibi bir çagrım geçerli degildir. 1slem isimli metodun bildiriminde önce int türünde

sonra da String türünde parametre yazılmıstır. Metodu çagırırken de aynı sıraya uymamız gerektigini unutmayalım.

ÖNEML NOT:

metodları çagırıken de parametreler yerine deger göndererek islem yapmaktayız. Bu iki islemi birbirine

karıstırmamalıyız.

Metodlarda Geri Dönüs Degeri Kavramı

Yukarıda da anlattıgım gibi, metodlara birtakım parametreler göndererek bazı islemler yapmalarını saglarız. Bu

islemler kendi içerisinde uygulanıp tamamlanan islemler olabilecegi gibi, sonunda bir sonuç üretilen islemler de

olabilir. 1ste sonuçta elde edilen bu degerleri kullanabilmemiz için, metodun bu degerleri bize geriye göndermesi

gerekir. Metodların islemlerinin tamamlaması neticesinde geriye gönderdikleri bu degere “geri dönüs degeri“

denilmektedir. Asagıdaki örnekte parametre olarak bir çemberin yarıçap degerini alan “alanHesapla” isimli metod,

çemberin alanını hesaplayarak geriye bu degeri bize göndermektedir:

Örnekte de görüldügü gibi, 9. satırda kullanıcıdan istenen yarıçap degeri 10. satırda metoda parametre olarak

gönderilmektedir. Ama aslında parametre olarak gönderilmeden hemen önce “Double.parseDouble()” metodu ile bu

String türündeki yarıçap degeri double türüne dönüstürülmekte ve dönüsüm sonucu gelen deger “alanHesapla”

isimli metoda parametre olarak gönderilmektedir. Gönderilen bu parametre, metod bildiriminde belirtilen “yaricap”

isimli degiskene aktarılmaktadır.

NOT: Bu aktarım neticesinde, gelen parametre artık metod içerisinde yaricap ismiyle kullanılacaktır.

Eger metod, 1'den fazla parametreli bir metod olsaydı, bu durumda gönderilen parametre degerleri

aynı sıra ile, metod bildiriminde tanımlanan parametre degiskenlerine aktarılacaktı.

Daha sonra “alanHesapla” metodu kendisine gelen bu parametre'nin, “Math” sınıfının “power” metodu yardımıyla

karesini alarak 3.14 (pi sayısı) ile çarpmakta ve üretilen sonucu da 17. satırda oldugu gibi alan degiskenine

atamaktadır.

NOT: “Math.power” metodu 1. parametre ile kuvveti alıncak sayıyı, 2. parametre ile de bu sayının

kaçıncı kuvvetini alacagını belirler. Geri dönüs degeri olarak da hesapladıgı sonucu gönderir.

return Anahtar Sözcügü

Alan.java örneginde, 18. satırda kullanılan “return” ifadesi, önündeki degisken degerini metodun çagrıldıgı yere

göndermektedir. Bu durumda hesaplanan alan degeri, return ifadesi ile metodun çagrıldıgı 9. satıra

gönderilmektedir. Buraya geriye gönderilen deger de “sonuc” isimli degiskene atanarak tutulmus olur.

Eger 9. satırda

sonuc = alanHesapla( Double.parseDouble(yrcp) );

ifadesi yerine sadece

alanHesapla( Double.parseDouble(yrcp) );

seklinde metodu çagırsaydık, metod içerisinden alan degeri gönderilecek, ancak bu degeri tutacak “sonuc” gibi bir

degisken olmadıgı için geriye gelen deger bosa gidecekti ve ele alınamayacaktı.

Bu örnekte dikkat edilmesi gereken bir diger konu da; geri dönüs degeri olan metodların bildirimlerinde void yerine

bir tür adı yazılması gerektigidir. Örnegimizde geriye gönderilen degerin türü “double” türünde bir deger oldugu için

oldugu için, 16. satırda yapılan metod bildiriminde metod isiminden hemen önce geri dönüs degerinin türünün

yazıldıgını görmekteyiz. Fakat önceki örneklerimizde geri dönüs degeri olmayan metodlarda bu kısma “void”

yazmıstık.

Dizilerin Metodlara Parametre Olarak Gönderilmesi

Daha önce dizilerin ne amaçla yaratıldıklarını ve nasıl kullanıldıklarını görmüstük. Dersimizin bu kısmında hem

metod kullanımını biraz daha pekistirmek, hem de diziler üzerinde pratik yapmak amacıyla dizilerin metodlara

aktarılmasını inceleyecegiz.

Asagıdaki örnekte çesitli isimlerden olusan bir diziyi “

kendisine parametre olarak karısık sırada isimlerden olusan bu diziyi alfabetik sırada yeni bir dizi içerisinde

olusturarak geriye de bu yeni diziyi gönderiyor.

import javax.swing.*;

import java.util.Arrays;

import java.lang.System;

class DiziSirala {

public static void main(String[] args) {

String liste[] = {"Evren Akar", "Ahmet Aykaç", "Fatih Demir", "Ender Uçkun"};

String gelenDizi[] = alfabetikSirala(liste);

diziGoruntule(liste, "Orjinal Dizi");

diziGoruntule(gelenDizi, "Sirali Dizi");

System.exit(0);

}

public static String[] alfabetikSirala(String [] dizi) {

String sirali_dizi[] = new String[dizi.length];

System.arraycopy(dizi, 0, sirali_dizi, 0, dizi.length);

Arrays.sort(sirali_dizi);

return sirali_dizi;

}

public static void diziGoruntule(String []dizi, String dizi_adi) {

String mesaj = dizi_adi+" Içerigi\n***************\n\n";

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

mesaj += "dizinin "+i+". elemani: "+dizi[i]+"\n";

JOptionPane.showMessageDialog(null, mesaj);

}

}

Diziler metodlara parametre olarak aktarılırken sadece isimlerinin aktarılması yeterlidir. Örnegimizde 5. satirda

yaratilan “

“

Diziyi parametre olarak alan metod bildiriminde ise, parametre kısmında gelecek olan dizinin türü, [ ] sembolü ve

bir parametre adı yazılması gerekir. Örnegimizde yarattıgımız “

bildiriminde de, gelecek olan dizi parametresi “

“

“alfabetikSirala”

kullanılacaktır.

“

indeksinden itibaren, 3. parametre ile aldıgı dizinin, 4. parametre ile aldıgı indeksine, 5. parametre ile aldıgı sayıda

elemanı kopyalar. Bu metod yardımıyla, 14. satırda oldugu gibi metod içerisinde “

dizimizin tüm elemanları, “

“

örnegimizde bu metodu kullanarak “

Dizilerin Geri Dönüs Degeri Olarak Kullanılması

Bir diziyi geri dönüs degeri olarak gönderirken benzer sekilde “

yazılması yeterlidir. Ancak dikkat edilmesi gereken önemli nokta

degiskeni olması gerektigidir. Örnegimizde 16. saturda yazılan “

metodu çagırdıgımız yere geri dönüs degeri olarak göndermekteyiz. 6. satıra gelen bu yeni dizi “

dizi degikenine aktarılmaktadır.

Örnekte 19. satırda yazmıs oldugumuz “

dizinin 2. parametre ile gönderilen baslıgı kullanarak içerigini görüntülemektedir. Bu metod yardımıyla orjinal ve

sıralanmıs dizilerimizin içeriklerini de görüntülemkteyiz.

Bu örnekler sayesinde metod ve dizi kullanımına iliskin teknikleri daha iyi anlayacagınızı umuyorum. Ders içerisinde

verilen örnekleri mutlaka satır satır yazmanızı öneririm. Böylece hiç farkında olmadan Java'da birçok seyin pratik

hale geldigini göreceksiniz.

Simdi dizilere iliskin son bir örnekle metod ve dizilerin birlikte kullanımını toparlayalım.

import javax.swing.*;

import java.util.Arrays;

import java.lang.System;

class HistogramSinifi {

public static void main(String[] args) {

int uzunluk = Integer.parseInt(JOptionPane.showInputDialog(null, "Dizi uzunlugu

ne olsun?"));

String []liste = diziYarat(uzunluk);

Histogram(liste);

System.exit(0);

}

public static String[] diziYarat(int boyut) {

String isimler[] = new String[boyut];

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

isimler[i] = JOptionPane.showInputDialog(null, i+". ismi giriniz");

Arrays.sort(isimler);

return isimler;

}

public static void Histogram(String dizi[]) {

JTextArea cikisEkrani = new JTextArea(15, 15);

String cikis = "isim \t uzunluk \n -------------------\n";

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

cikis += dizi[i] + "\t";

for(int k = 0; k < dizi[i].length(); k++)

cikis += "*";

cikis += "\n";

}

cikisEkrani.setText(cikis);

JOptionPane.showMessageDialog(null, cikisEkrani);

}

}

Örnegimizde 5. satırda “

kullanıcının girecegi

içerisine parametre olarak verilerek integer bir sayıya dönüstürülür. Dönüstürülen bu sayı da “

degiskene atanır. Daha sonra 7. satırda

dikkat ederseniz bu sefer dizi yaratma islemi bizim yazdıgımız “

13. satırda tanımlanan “

yaratır. Daha sonra 16. satırda yazılan for döngüsü ile bu dizinin elemanlarını kullanıcıdan alarak diziye yerlestirir.

Bu islemi 17. satırda oldugu gibi, for döngüsünün her i adımında, kullanıcıdan istedigi giris degerini dizinin i.

elemanına atayarak yapmaktadır. Daha sonra 19. satırda yaratılan ve içerisine isimler yerlestirilen dizimiz “

isimli sınıfın “

ile metodun çagrıldıgı 7. satıra gönderilir. Bu gönderme neticesinde de yaratılan ve sıralan bu dizi, liste isimli dizi

degiskenine atanmıs olur.

8. saturda, “

her elemanının kendisini ve bu elemanın karakter uzunlugu kadar * simgesini ekrana basar. Metod bu islemi

yapmadan önce ilk olarak

yaratılmaktadır. Java nesneleri ve nesnelerin yaratılması konusunu sonraki dersimizde ayrıntılı olarak görecegiz.

26. satırda “

Ancak bu degisken ilk yaratıldıgında içi bos bir sekilde olusturulmaktadır. 28. satırdaki for döngüsü ile dizinin her

elemanı tek tek ele alınacaktır. 29. satırda, i. adımdaki eleman ve bir tab bosluk karakteri “

yazılır. 30. satırdaki for döngüsü, i. adımda ele alınan dizi elemanının her karakteri için adım adım * isaretini yine

cikis isimli degiskene yazar. En son olarak da 33. satırda “

geçme karakteri eklenerek 28. satırdaki döngünün bir sonraki adımına geçer ve aynı islemler diger dizi elemanları

için de tekrarlanır. Tüm dizi elemanları bu sekilde ele alındıktan sonra, 35. satırda oldugu gibi “

nesnenin içerisinde yer alacak yazı, yine bu nesneye ait öntanımlı “

degiskenin içerisinde saklanan degere set edilir. (Java'da nesnelerin öntanımlı metodlarını sonraki derslerimizde

inceleyecegiz.) En son olarak da metod 36. satırda oldugu sekilde bu nesneyi showMessageDialog isimli metoda

vererek ekranda görünmesini saglar.

Dikkat ederseniz daha önceki örneklerimizde JOptionPane.showMessageDialog isimli metoda hep bir mesaj

yazıyorduk. Ama bu sefer metoda, “ ” içerisinde yazılmıs bir String mesajı yerine, bir nesne gönderdik ve tüm

mesajımızı da bu nesne içerisinde yazdık.

UYGULAMA:

aldıgınız bir ismi aratınız. Eger isim dizinin içerisinde bulunursa bu ismin indeks numarasını ekrana yazdırınız.

Bulunamazsa ismin bulunamadıgına dair bir mesaj yazdırınız.

Java ile Programlama:

Bölüm 5:

Önceki dersimizde hatırlarsanız Java'da metodların nasıl kullanıldıgını ve yaratıldıgınu ayrıntılı olarak inceleyerek,

devamında da dizilerin metodlara parametre olarak gönderilmesine iliskin birtakım örnekler üzerinde çalısmıstık.

Önceki derslerimizi iyice tekrar ettiginizi ve verilmis örnekleri de teker teker yazarak denediginizi umuyorum. Bilinen

örnekleri bile sabırla yazmak inanın çok sey ögretecektir.

Bugünkü dersimizde artık nesne yönelimli programcılıgın en önemli kavramı olan sınıfları inceleyecegiz. Önümüzdeki

derslerin birçogu artık bu sınıfları kullanmak ve gelistirmek üzerine olacak. Bu yüzden burada basitlestirerek

anlatmaya çalıstıgım bu temel kavramları iyice anlamaya ve irdelemeye çalısmanızı öneririm.

Sınıf Kavramı:

Biliyoruz ki genel anlamda program yazabilmek için çesitli degiskenler yaratıp kullanıyoruz. Yaratılan her degiskenin

bir türü oldugunu ve yaratıldıktan sonra bu degiskenlerin de artık birer nesne oldugunu görmekteyiz.

Örnegin

"

"

"

oluyoruz. Yani degiskenleri bilinen nesne türlerinden birtanesi cinsinden yaratıyoruz.

1ste bugün ögrenecegimiz sekilde, sınıfları yazarak önce

yaratmıs oldugumuz bu "

da bir baskasının yaratmıs oldugu bir sınıf türünden yeni bir degisken yaratabiliyor ve yine bu degiskeni

kullanabiliyoruz.

Aslında bundan önceki derslerde, önceden yaratılmıs bazı sınıfları zaten kullanmıstık. Örnegin "

isimli sınıfa ait "s

JOptionPane

Sınıf Nedir?

Simdi biraz daha genel olarak sınıfların ne oldugundan bahsetmekte fayda var. Sınıf denilen sey aslında birden fazla

metod ve degiskeni birarada tutan bir yapıdır. Ancak bu degisken ve metodların da aynı göreve iliskin olması

beklenir. Örnegin icq benzeri bir uygulamada en kaba sekilde görsel kısım ve ag baglantıları olmak üzere iki kısım

oldugunu kabul edelim. Bu uygulamanın pencere sekli, rengi, dügmelerin yeri v.b. isleri üstlenecek birçok metod ve

degiskeni olsa da hepsinin amacı aslında görselligi saglamaktır. Yine benzer sekilde arka planda baglantıları

ayarlayan, kontrol eden bir çok metod ve degisken de ag ayarları için kullanılır.

Bu durumda aynı projeye iliskin ama ayrı görevleri üstlenen tüm metod ve degiskenleri bu iki ana sınıf altında

toplamak hem organizasyonda hem de tasarımda kolaylık saglar. Bu iki kısım birbirinden bagımsız tasarlanarak bir

araya getiriliebilir. Bu da projeye esneklik saglar.

Sınıfların Yaratılması

Bundan önce yazdıgımız örneklerde aslında biz hep bir sınıf ve bu sınıfın içerisinde de birtakım metod ve

degiskenler yaratıyorduk. Simdi yine örnek bir sınıf yaratalım. Bu sınıf kendi içerisinde sadece bir degisken tutsun

ve bu degiskenin degerini elde edebilecek ya da degistirebilecek bazı metodları olsun:

class DegiskenTutan {

int x;

public void setX(int c) {

this.x = c;

}

public int getX() {

return this.x;

}

}

DegiskenTutan.java dosyasındaki örnekte, bahsettigimiz bu sınıfı yine sınıf ile aynı isimde olan

"

bir nesne türü yaratmıs oluyoruz.

DegiskenTutan sınıfının 2. satırında yaratılan "

olmasının nedeni yaratıldıgı yerin herhangi bir metodun içinde degil de en dıs faliyet alanında olmasıdır. Bu nedenle

sınıf içerisinde tanımlı diger tüm metodlar bu degiskene erisebilir ve degiskeni kullanabilirler.

this Anahtar Sözcügü

Sınıf içerisinde yazılmıs olan "

Yalnız dikkat edilirse 9. satırda gerçeklesen bu geri döndürme islemi sırasında sadece degiskenin adı degil, onun

yerine "

sonra gelen degisken isimlerinin sınıfa ait oldugunu ifade etmektedir. Yani 9. satırda yazılan

r

ile kastedilen sey, ilgili sınıfa ait olan "x" isimli degiskeninin geri döndürülecegidir. Yine sınıf içerisinde yazılmıs olan

"

sınıfa ait olan "

Gördüıgümüz gibi yazmıs oldugumuz bu yeni sınıf içerisinde baska degisken ya da metod bulunmamaktadır. Peki ya

madem artık bu sınıf yazıldı ve kullanıma hazır, sınıfı nasıl kullanabiliriz? Simdi bu sorunun cevabını verelim:

Yazılmıs Sınıfların Kullanılması

Bazı özel durumların dısında, en genel biçimiyle bir sınıf nesnesi ya da bildigimiz sekliyle bir sınıf türünden degisken,

su sekilde yaratılır:

SinifAdi degisken = new SinifAdi();

Mesela, az önce yazmıs oldugumuz "DegiskenTutan" isimli sınıf türünden bir degisken de:

DegiskenTutan a = new DegiskenTutan();

seklinde yaratılmaktadır. Bu yaratma islemini baska bir sınıf içerisinden yapabilirsiniz. Burada vurgulanması gereken

en önemli nokta, yaratılan her sınıf degiskeninin (a’nın) aslında gerçek sınıfın bir kopyası oldugudur (instance). Yani

biz yukarıdaki gibi a isimli ve DegiskenTutan türünde bir sınıf nesnesi ve yine aynı sekilde

DegiskenTutan b = new DegiskenTutan();

b isimli baska bir DegiskenTutan isimli sınıf nesnesi yarattıgımızda, bu iki nesne de artık kendilerine ait birer "setX"

ve "getX" metodları ile bir "x" degiskeni barındırmaktadır. A nesnesinin "x" degiskeni ile b nesnesinin "x" degiskeni

artık farklıdır. Ama ikisinin de bir "x" degiskeni vardır. Yine aynı sekilde "a" nesnesi ile "b" nesnesinin "setX" ve

"getX" metodları vardır ama her metod kendi nesnesine ait olan "x" degiskeni üzerinde islem yapabilir.

Simdi "DegiskenTutan.java" dosyası ile aynı klasör içerisinde yer alan "GenelSinif" isimli yeni bir sınıf daha yaratalım

ve bu yeni sınıf içerisinde de "DegiskenTutan" isimli sınıfı kullanalım:

import javax.swing.*;

public class GenelSinif {

public static void main(String arg[]) {

DegiskenTutan a = new DegiskenTutan();

DegiskenTutan b = new DegiskenTutan();

a.setX(10);

b.setX(20);

String message = "a daki x degeri: "+a.getX();

message += "\nb deki x degeri: "+b.getX();

JOptionPane.showMessageDialog(null, message);

System.exit(0);

}

}

Simdi yazmıs oldugumuz bu sınıfları kaydettikten sonra çalıstırabilmek için su islemleri yapmamız gerekmektedir.:

Öncelikle komut satırında bu sınıf dosyalarını yazmıs oldugunuz dizin içerisine cd komutu

yardımıyla giriniz. Örnegin bu dizin linux kullanıcıları için "/home/academytech/kodlar" ya da

windows kullanıcıları için "C:\kodlar" ise, dizin içerisine girmek için:

$cd /home/academytech/kodlar

ya da

C:\> cd kodlar

yazmanız gerekmektedir.

2 Simdi sırasıyla "DegiskenTutan.java" dosyasını ve "GenelSinif.java" dosyasını derleyelim:

javac DegiskenTutan.java

javac GenelSinif.java

3 Son olarak da GenelSinif.java dosyasını çalıstıralım:

java GenelSinif

Not:

çalıstırılmıyor. Bunun nedeni asıl çalısan programın "GenelSinif" olması "DegiskenTutan" sınıfının ise sadece

kullanılıyor olmasıdır. Çünkü "GenelSinif" sınıfı içerisinde "main" metodu vardır. Bununla ilgili ayrıntılı açıklamayı

yazının ilerleyen kısımlarında zaten bulabileceksiniz.

Örnegimizde 7. ve 8. satırlarda DegiskenTutan sınıfı türünden "a" ve "b" isimli 2 degisken ya da iki

"DegiskenTutan" sınıfı nesnesi yaratılmaktadır. Daha sonra 9. satırda a nesnesinin "setX" metodu "a" nesnesinin "x"

degiskeni degerini 10, "b" nesnesinin "setX" metodu da "b" nesnesinin "x" degiskeninin degerini 20 yapmaktadır.

Dikkat ederseniz "a" ve "b" nesneleri de "setX" ve "getX" metodlarına sahiptir ve bu metodları kullanmak için nesne

adından sonra "." isareti ve sonra da metod adını yazmak gerekir. "a" ve "b" nesnelerinin tıpkı "DegiskenTutan"

sınıfı gibi metodlara ve degiskenlere sahip olmalarının nedeni, bu nesnelerin de yaratılırken "DegiskenTutan" sınıfı

türünden yaratılmıs olmalarıdır.

12. ve 13. satırlarda hazırlanan "message" isimli String degiskeni içerisine ekranda görülecek yazı ve "getX"

metodları yardımıyla "a" ve "b" nesnelerinin "x" degiskenlerinin içerisindeki degerler hazırlanmaktadır. En son olarak

da "message" isimli degisken içerisinde hazırlanan bu son görüntü "JoptionPane" isimli sınıfın "showMessageDialog"

isimli metodu yardımıyla ekrana gönderilmektedir.

Bu örnekten çıkaracagımız sonuç sudur; Genel olarak yazılmıs sınıfların kullanılabilmesi için öncelikle bu sınıflar

türünden degiskenler yaratılarak bu sınıfların birer kopyası ya da nesnesi çıkarılmalı ve sınıfa ait degisken ve

metodlar bu nesneler aracılıgıyla kullanılmalıdır. Ayrıca gördügümüz gibi bir sınıfa ait metodlar kullanılırken sınıf

nesnesinden sonra "." isareti ve daha sonra da metodun adı yazılmaktadır.

Bu örnegimizde "a" ve "b" isimli sınıf nesneleri yaratıldıktan sonra, sahip oldukları "x" degiskenlerine "setX" metodu

ile degerler verilmektedir. Peki eger biz daha nesneyi yaratorken hemen o anda "x" degiskenine deger vermek

istersek ne olacak? Bunun için "baslangıç metodu" kavramını bilmemiz gerekir.

Sınıfların Baslangıç Metodları (Constructors):

Sınıfların baslangıç metodları bizim bildigimiz anlamda metodlardan biraz daha farklıdır. Bu metodların en önemli

özelligi, bir sınıf nesnesi yaratılırken otomatik olarak çagrılmalarıdır. Mesela "DegiskenTutan" sınıfı türünden bir

nesne yaratılırken aslında "new" anahtar sözcügünden sonra bir metod çagrıldıgını görmekteyiz:

DegiskenTutan a = new DegiskenTutan();

1ste bu "DegiskenTutan()" isimli metod, "DegiskenTutan" isimli sınıfın baslangıç metodudur. Peki o zaman baslangıç

metodlarının normal metodlardan farkı nedir?

1 Baslangıç metodları kesinlikle ve kesinlikle sınıf ismiyle aynı olmak zorundadır. Eger baslangıç metodunun ismini

verirken sınıf isminden farklı bir isim kullanırsanız bu metod artık baska bir metod olarak kabul edilir. Örnegin:

DegiskenTut -> Yanlıs. Sınıf ismi DegiskenTutan o halde baslangıç metodunun ismi bu olamaz

Degiskentutan -> Yanlıs. Sınıf isminde T harfi de büyük. 1sim, büyük küçük harf bazınbda da aynı olmak

zorundad?r.

2 Baslangıç metodları geri dönüs degerine sahip degildir. Yalnız burada geri dönüs degeri void demek

istemiyorum. Baslangıç metodlarının geri dönüs degeri gibi bir kavramları yoktur. void ile yok baska anlamlara

gelir.

3 Bir sınıfın birden fazla baslangıç metodu olabilir. Bütün baslangıç metodları da sınıf ismiyle aynı olmak

zorundadır ancak her birinin parametreleri birbirlerinden farklı olmak zorundadır.

Biz baslangıç metodlarını genelde bir sınıf türünden bir nesne yaratırken, bu nesnenin degiskenlerine birtakım ilk

degerler vermek amacıyla yazarız. Aslında tasarladıgımız bir sınıfa baslangıç metodu yazmak zorunda degiliz. Ancak

baslangıç metodu yazmamıssak, nesne yaratılırken Java

metodu yazar ve onu çagırır. Eger yazmıssak bizim yazdıgımız baslangıç metodunu çagırmaktadır.

Simdi tüm bu anlattıklarımızı "DegiskenTutan" sınıfımıza baslangıç metodları ekleyerek irdeleyelim. Ama bu sefer

"DegiskenTutan" ve "GenelSinif" isimli sınıfları "DegiskenTutan2" ve "GenelSinif2" olarak degistirelim. Tabi aynı

degisikligi dosya isimlerinde de yapmayı unutmayalım:

/*** DegiskenTutan2.java ***/

class DegiskenTutan2 {

int x;

public DegiskenTutan2() {

this.x = 0;

}

public DegiskenTutan2(int c) {

this.x = c;

}

public void setX(int c) {

this.x = c;

}

public int getX() {

return this.x;

}

}

/*** GenelSinif2.java ***/

import javax.swing.*;

public class GenelSinif2 {

public static void main(String arg[]) {

DegiskenTutan2 a = new DegiskenTutan2();

DegiskenTutan2 b = new DegiskenTutan2(2);

String message = "a daki x degeri: "+a.getX();

message += "\nb deki x degeri: "+b.getX();

JOptionPane.showMessageDialog(null, message);

System.exit(0);

}

}

Bu örnekte görüyoruz ki; "GenelSinif2" dosyasının 7. satırında, "a" isimli "DegiskenTutan2" türünden sınıf degiskeni,

"DegiskenYutan2" sınıfının 5. satır?nda tanımlanan bos olan baslangıç metodu ile yaratılıyor ve bu metodun

içerisinde de "a" nesnesinin "x" degiskenine 0 degeri veriliyor. Ancak "GenelSinif2" çerisinde 8. satırda yaratılan "b"

isimli ve "DegiskenTutan2" türündeki nesne, "DegiskenTutan2" isimli sınıfın 9. satırda tanımlanmıs ve int parametre

alan baslangıç metoduyla yaratıldıgı için bu "b" nesnesine ait olan "x" degiskeni nesne yaratılırken verilen 2 degerini

alıyor. Bu örnekte, bir sınıf türünden nesne yaratılırken yapılmasını istedigimiz birtakım ilk islemleri baslangıç

metodları yardımıyla yaptırabildigimizi görüyoruz.

NOT:

verilmez.

main Metodu

Su ana kadar dikkat ederseniz "main" metodu ile ilgili çok az ayrıntıdan bahsettim. Aslında bu metod da birtakım

özelliklere sahip özel bir metoddur. Simdi yukarıda yapmıs oldugumuz örneklere bir göz atmanızı istiyorum. Bu

örnekler de "GenelSinif" isimli sınıf içerisinde "main" metodu varken "DegiskenTutan" isimli sınıfın içerisinde böyle

bir metod yok. Ama her iki örnek de düzgün bir sekilde çalısabiliyor. Bunun nedenini söyle açıklayalım:

Bu ana kadar gördük ki bir sınıf nesnesi ilk önce yazılmakta ve daha sonra da kullanılmaktadır. Ancak kullanılmadan

önce tüm nesneler öncelikle "javac" komutu ile derlenmelidir. 1ste bir java dosyasının "javac" ile derlenmesi

isleminden sonra bir de "java" komutu ile çalıstırılabilmesi için, o java dosyası (ya da sınıfı) içerisinde "main"

metodu olması gerekir. Yani çalıstırılabilir sınıfların main metodunu sahip olmaları gerekir. Aksi takdirde

java <Sinif_adi>

komutundan sonra ekranda asagıdaki gibi "main" metodunun bulunamadıgına dair bir mesaj ile karsılarsınız:

"java.lang.NoSuchMethodError: main"

Ancak "DegiskenTutan" gibi sadece baska bir sınıf içerisinde kullanılmak üzere tasarlanmıs sınıflar dogrudan

çalıstırılmayacagı için, onların içerisinde main metodu olmasına gerek yoktur. Bu tür sınıfların yukarıdaki örnekte de

görüldügü gibi sadece derlenmesi, kullanılabilmeleri için yeterli olacaktır.

Özetle; yazdıgımız programlarda birbirinden farklı görevleri üstlenmis bir çok sınıfı barındıran java dosyaları ve

hepsini en son olarak tek çatı altında toplayacak ve asıl programın çalısmasını saglayacak genel bir sınıfımız

olacaktır. Ve tüm bu sınıflar içerisinde sadece ana programı çalıstıracak olan bu genel sınıf içerisinde "main" metodu

olmalıdır. Diger sınıfları kullanabilmeniz için, genel sınıf da dahil olmak üzere hepsini java ile derlemelisiniz. Ancak

programı çalıstırmak için sadece genel sınıfı java komutu ile çalıstırmanız yeterlidir.

Sonuç olarak; bir sınıf java ile çalıstırıldıgı zaman, otomatik olarak içerisindeki main metodu çagrılacaktır. Eger sınıf

içerisinde main metodu yoksa, böyle bir sınıf "javac" ile derlenebilir ancak "java" ile çalıstırılamaz!

main Metodu parametreleri:

"main" metodunun su ana kadar hiç deginmedigimiz bir özelligi de aldıgı parametrelerdir. Bu metod yazılırken

görmekteyiz ki

public static void main(String arg[])

seklinde bir String dizisini parametre olarak almaktadır. "1yi de bu parametre ne ise yarıyor?" diye merak ettiginizi

tahmin ediyorum. Artık bunu ögrenme zamanım?z geldi. Öncelikle asagıda verilen "MainParametreleri.java" isimli

sınıfı yazıp kaydediniz:

class MainParametreleri {

public static void main(String arg[]) {

System.out.println("1. parametre:"+arg[0]);

System.out.println("2. parametre: "+arg[1]);

System.exit(0);

}

}

Simdi asagıda gösterildigi gibi bu sınıfı önce javac komutu ile derleyip daha sonra java komutunun bu özel kullanımı

ile çalıstırınız:

javac MainParametreleri.java

java MainParametreleri bir iki

Bu sekilde sınıfı çalıstırdıgınızda ekranda söyle bir çıkıs göreceksiniz.

1. parametre:bir

2. parametre: iki

1ste burada, java komutu ile "MainParametreleri" sınfını çalıstırırken sırasıyla verdiginiz "bir" ve "iki" isimli bu iki

String degeri, main metodunun pototipinde tanımlanmıs olan "arg" isimli String dizisine atulmıstır. "main"

metodunun paramtresi olan bu "String arg[]" dizisi bu örnekte oldugu gibi bir sınıf çalıstırılırken kullanıcının vermek

istedigi parametreleri alır ve daha sonra program içerisinde kullanılabilmesi için saklar. Örnek programımızın 5. ve

6. satırlarında "arg[0]" ve "arg[1]" ile bu girilen parametreleri kullanabildigimzi görmekteyiz. Buradaki kullanma

seklimiz bu parametreleri sadece ekrana yazmak gibi anlamsız bir islem gibi görünse de daha sonra ise yarar

sekillerde kullanabilecegimizi düsünebiliriz.

1. parametre: bir

2. parametre: iki

Sınıfların public ve private Metod ve Degiskenleri

Su ana kadar belirli isleri yapabilmek amacıyla metod ve degiskenleri birarada tutan nesneleri yaratmayı ve

kullanmayı, yani sınıfların genel olarak kullanımını görmüs olduk. Bir sınıf içerisinde çesitli metod ve degiskenler

tutuyor ve daha sonra biz de bu sınıf türünden nesneler yaratarak bu metod degiskenleri kullanabiliyoruz.

Bazen bir sınıf içerisinde yazılan metod ya da degiskenleri sadece sınıfın içerisinde kullanmak isteyebiliriz. Yani

baska bir yerde bu sınıf türünden yaratılan bir degisken ile kullanmayacagımız ancak sınıfın kendi içinde kullanılması

gereken metod ve degiskenler olabilir. Bunu anlamak için "DegiskenTutan" sınıfına tekrar dönelim. Biz

"DegiskenTutan" sınıfı türünden bir "a" nesnesi yarattıgımızda "a" nesnesi kendisine ait olan "x" degiskenini:

a.x = 10;

seklinde degistirebilir. Ancak biz bu sekilde bir müdaheleye izin vermek istemiyor olabiliriz. Eger "a" nesnesinin "x"

degiskeni degistirilecekse, böyle bir islemin "setX" gibi bir metodla yapılmasını, degiskene "a.x" diyerek dogrudan

erisilememesini istiyor olabiliriz. 1ste bu durumlarda sınıf içerisine "x" degiskeninin basına bir "private" anahtar

sözcügü eklememiz gerekir. Yani "DegiskenTutan" sınıfında "x" degiskeninin bildirimi:

class DegiskenTutan {

private int x;

public Degiskentutan() {

...

seklinde olursa, artık "DegiskenTutan" türünden "a" gibi bir nesne yaratılsa bile, "a.x" gibi bir erisim yasaklanmıs

olur. Ancak sınıf içerisindeki bir metod "x" degiskenine yine de ulasabilir.

Eger genel olarak özetlemek gerekirse; sınıflar içerisinde bildirilen "private" türündeki degiskenlere dısarıdan

erisilemez, ancak sınıfın diger metodları ile erisilebilir.

Bu durum sınıfın private metodları için de geçerlidir. Eger sınıf yazılırken bir metodun basına "private" anahtar

sözcügü eklenirse, bu metod da artık dısarıdan erisilemez, sadece sınıf içerisindeki diger metodlar tarafından

kullanılabilir bir hale gelir. Mesela "DegiskenTutan" isimli sınıfa asagıdaki gibi bir "private" metod ekleyelim

class DegiskenTutan {

private int x;

...

private void resetX() {

this.x = 0;

}

...

public setX(int c) {

this.resetX();

this.x = c;

}

}

Bu sekilde "private" olarak bildirilmis "resetX" metodu artık bu sınıf türünden yaratılmıs nesneler ile dısarıdan

kullanılamaz. Yani asagıdaki gibi bir kullanım geçersizdir:

class BaskaSinif {

public static void main(String arg[]) {

DegiskenTutan a = new DegiskenTutan(2);

a.resetX();

/* YANLIS! resetX private bir metoddur

Bu sekilde dısarıdan kullanılamaz.*/

...

}

}

En son örnekte gördügünüz gibi "a.resetX()" gibi bir çagrım geçerli degildir. Çünkü "DegiskenTutan" sınıfının

"resetX" isimli metodu "private" bir metoddur. Bu nedenle, bu sınıf türünden yaratılmıs olan "a" nesnesi aracılıgıyla

bu metoda dısarıdan erisilemez. Ancak önceki örnekteki gibi "resetX" metodunu sınıfın diger bir metodu olan "setX"

metodu kullanabilmektedir. Degisken ya da metodların "private" ya da "public" olması, bu metod ya da

degiskenlerin sadece dısarıdan kullanımı etkileyen bir durumdur. Sınıf içerisindeki diger metodlar bu "private"

degisken ya da metodlara erisebilirler.

Tüm bunların bir sonucu olarak da , sınıflar yazılırken yaratılan "public" metod ve degiskenler, sınıf nesneleri

aracılıgıyla dısarıdan erisilebilirler.

Statik Metod ve Degiskenler

Su ana kadar ögrendiklerimizi ele aldıgımızda neden

kullanmak için JOptionPane sınıfı türünden bir nesne yaratmıyoruz? diye sormamız gerekir.

Bazı metodlar yazıldıkları sınıflar içerisinde statik olarak yazılırlar. Bu türden statik olarak yazılmıs metodları

kullanmak için sınıf nesnesi yaratmak gerekmez. Bu metodları kullanmak için yazıldıkları sınıf isminden sonra "."

isareti koyarak dogrudan metodu çagırabilirsiniz.

Ancak tahmin edersiniz ki bir metod statik olarak yazılmıssa genel amaçlı bir metod olmalıdr. Mesela JOptionPane

isimli sınıfın showMessageDialog ya da showInputDialog isimli metodları genel amaçlı olup her zaman

kullanılabilmektedir. Ekrana bir mesaj penceresi çıkarmak ya da kullanıcıdan bir giris degeri almak için bir nesne

yaratmaya gerek yoktur. Siz de kendi tasarladıgınız sınıflar içerisinde bu sekilde genel amaçlı metodlar yazmak

isterseniz bunları statik olarak yaratabilirsiniz.

Bir metodun statik olarak yaratılabilmesi için, metodun prototipinin basına "static" anahtar sözcügü eklenir.

Asagıdaki iki örnegi yazıp kaydediniz:

import javax.swing.*;

class StatikTest {

String mesaj;

public StatikTest() {

mesaj = "";

}

public StatikTest(String m) {

this.mesaj = m;

}

public static void ozelMesaj(String m) {

JOptionPane.showMessageDialog(null, m);

}

public void kayitliMesaj() {

JOptionPane.showMessageDialog(null, this.mesaj);

}

}

class GenelSinif3 {

public static void main(String arg[]) {

StatikTest.ozelMesaj("Bu mesaji dogrudan gosterdim");

StatikTest a = new StatikTest("Bu mesaj icin nesne yarattim");

a.kayitliMesaj();

}

}

Bu örnegi çalıstırdıgınızda ekrana iki tane mesajın geldigini göreceksiniz. Bu mesajlardan ilki, "GenelSinif3" isimli

sınıfın 5. satırında, "StatikTest" sınıfının statik metodu dogrudan çagrılarak ekrana gelmistir. Gördügümüz gibi,

sınıfın statik metodunu kullanmak için

Çünkü statik metodlar sınıf ismi ve sonra ". " isareti yazıldıktan sonra dogrudan çagrılabilirler. Ancak ikinci mesaj

"StatikTest" sınıfının "kayitliMesaj" isimli ve statik olmayan metodu sayesinde ekrana geldiginden, bu metodu

kullanabilmek için ilk önce "StatikTest" sınıfı türünden bir nesne yaratılması ve metodun da bu nesne aracılıgıyla

çagrılması gerekir.

Uygulama Sorusu:

tasarlayınız. Yapılması gereken islemler:

a. iki tarihin birbiriyle kıyaslanması,

b. tarih üzerine belirli bir gün sayısı eklenebilmesi,

c. tutulan tarihin gösterilmesi,

d. tutulan tarihin degistirilmesi seklinde olmalıdır.

Bu islemlerin her biri için sınıf içerisinde bir metod tasarlamanız gerekmektedir. Böyle bir sınıfın günü, ayı ve yılı

tutan degiskenleri olmalıdır. Sınıfı tasarladıktan sonra, bu sınıfı kullanan ve bu sınıf türünden örnek nesneler

yaratarak bunları kullanan baska bir genel sınıf yazınız ve tasarımınızı bu nesneler üzerinde test ediniz.

Nihayet bu dersimizin de sonuna gelmis bulunuyoruz. Nesne yönelimli programlama tekniginin özünü olusturan

sınıfları ve sınıfların kullanımını ögrendigimiz bu dersimizi iyice sindirmenizi ve örnekleri de tekrar yazarak kendi

basınıza denemenizi ısrarla öneririm.

Uygulama Sorusu2:

bu array i dinamik olarak genisletebilmelidir. Ozetle bu sinifta asagidaki metdolar yer almalidir.

void add(int toAdd);

void add(int []toAddArray);

int findMax();

int findMin();

int remove(int index);

int display();

int reverseDisplay();

public IntArray(int a);

public IntArray(int []a);

public IntArray();

Java ile Programlama

Bölüm 6:

Sort yontemleri (bubble sort ve selection sort) anlatılacak.

ODEV

Uygulama Sorusu (Derste yapilacak):

Sınıfların dizilere parametre olarak gönderilmesine iliskin ornekler

- Person turunden bir sinif yarat (isim, yas)

- Bu sinif turunden elemanlari olan bir array yarat

- Bu arrayi bir metoda gonder ve ekranda goruntule

- Sonra compareTo metodunu Person sinifina ekle ve sort bilgisiyle bu sefer bu listeyi sirala

public class Person {

private String name;

private int age;

public Person() {

this.setName("No person");

this.setAge(0);

}

public Person(String name, int age) {

this.setName(name);

this.setAge(age);

}

public String toString() {

return "Person Name: " + this.getName() + "\nPerson Age: " +

this.getAge();

}

public static void sortPersonArray(Person p_array[]) {

/*for(int i = 0; i < p_array.length; i++)

for(int j = 0; j < p_array.length; j++)

if(p_array[i].compareTo(p_array[j]) > 0)

swap(p_array[i], p_array[j]);*/

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

for(int j = i+1; j < p_array.length; j++)

if(p_array[i].compareTo(p_array[j]) > 0)

swap(p_array[i], p_array[j]);

}

private static void swap(Person p1, Person p2) {

Person temp = new Person();

temp.setAge(p1.getAge());

temp.setName(p1.getName());

p1.setAge(p2.getAge());

p1.setName(p2.getName());

p2.setAge(temp.getAge());

p2.setName(temp.getName());

}

public int compareTo(Person p) {

return this.getName().compareTo(p.getName());

}

/**

* @return Returns the age.

*/

public int getAge() {

return age;

}

/**

* @param age The age to set.

*/

public void setAge(int age) {

while(age < 0)

age = Integer.parseInt(

JOptionPane.showInputDialog(null, "Yas bilgisi 0 ya da

daha kucuk olamaz!\nTekrar giriniz"));

this.age = age;

}

/**

* @return Returns the name.

*/

public String getName() {

return name;

}

/**

* @param name The name to set.

*/

public void setName(String name) {

this.name = name;

}

public static void main(String[] args) {

Person array[] = {new Person("ali", 12), new Person("ahmet", 24), new

Person("zeren", 13)};

Person.sortPersonArray(array);

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

System.out.println(array[i]);

}

}

Bu derse kadarki derslerimizde artık nesne yönelimli programlama tekniginin merkezinin olusturan sınıfların ne

anlama geldiklerini ve nasıl tasarlandıklarını ögrenmistik.

Bugün tasarımını ayrıntılı olarak ögrendigimiz sınıfların kullanımına iliskin bazı örnekler üzerinde duracagız. Ayrıca

Java'da öntanımlı olarak bulunan ve kendi özeli islerimiz için kullanabilecegimiz sınıfların bazılarını da görmüs

olacagız. Size tavsiyem burada

Sınıfların Kendi Kendilerini Kullanmaları:

Bundan önceki örneklerimizde bir sınıfın yazıldıktan sonra, baska bir sınıf içerisinde ya da örneklerde yaptıgımız gibi

main metodu içerisinde kullanılabildigini görmüstük. Bazı sınıflar otomatik olarak çalıstırılabilmek amacıyla da

yazılabilirler. Bir sınıfın otomatik olarak çalısabilmesi için içerisinde main metodu olması gerektigini zaten biliyoruz.

1ste bu sekilde main metodu içerisinde bir sınıf, kendisi türünden nesne yaratıp bunu kullanabilir.

1sin özü aslında sudur: Bir sınıf yazıldıktan sonra, bu sınıf türünden nesneleri istedigimiz her metod ya da her sınıf

içerisinde artık yaratıp kullanabiliriz. Bu genel kuralı bilirsek, zaten sınıf nesnelerinin ne zaman ve nerede

yaratılacagına dair bir problemimiz de kalmaz.

Asagıdaki örnegimizde, matematikte kullanılan karmasık sayılara iliskin deger ve metodları barındıran bir sınıf

yazacagız. Bu sınıf aynı zamanda “main” metodu içerecek ve kendisi türünden nesneler yaratarak bu nesneler

üzerinde islemler yapacak:

Simdi bu örnegimizi biraz inceleyelim. Sınıfımızın iki adet baslangıç metodu oldugunu görmekteyiz. Bu metodlardan

birtanesi, 6. satırda tanımlanmakta ve hiçbir parametre almadan yaratılan KarmasikSayi nesnesinin “gercel” ve

“imajinel” isimli degiskenlerini 0.0 degerine esitlemektedir. Diger baslangıç metodu ise 11. satırda tanımlanmaktadır

ve nesne yaratılırken kendisine verilen parametreleri kullanarak “gercel” ve “imajinel” degiskenlerinin degerlerini

atamaktadır.

NOT:

basına “this.” eklemis olduguma dikkat ediniz. Daha önce de söyledigim gibi this anahtar sözcügü sınıfın kendisini

temsil eder. Örnegin 12. satırda “this.gercel” ifadesi, “o anda içerisinde bulundugumuz sınıfa ait olan gercel isimli

degiskeni” temsil etmektedir.

16. satırda tanımlanan “topla” isimli metod parametre olarak baska bir “KarmasikSayi” nesnesi alarak, bu sayının

“gercel” ve “imajinel” degiskenleri ile sınıfın kendi “gercel” ve “imajinel” degerleri toplamını elde eder ve bu

degerlerle, “sonuc” adında yeni bir “KarmasikSayi” nesnesi yaratarak bu degiskeni 19. satırda geri döndürür. Buna

benzer sekilde 22. satırda yazılmıs olan “cikart” metodu da aynı islemi çıkartma için yapar. Ancak bu metod biraz

daha ilginç bir yöntemle deger döndürmektedir. Bu sefer sonucu tutacak ayrı bir degisken yaratmak yerine, 23.

satırda oldugu gibi “return” anahtar sözcügünün önünde yeni bir “KarmasikSayi” nesnesi yaratılarak hemen o anda

döndürülür. Bu yöntemde arada “sonuc” gibi baska bir degisken içerisinde “KarmasikSayi” nesnesi yaratma ihtiyacı

ortadan kalkmaktadır.

Yazdıgımız Sınıfların toString metodu:

Dikkat ederseniz 35. satırda “toString” adında ilginç bir metod yer almaktadır. Bu metod aslında main metodu

içerisinde hiç çagrılmamıstır. Ancak ilginçtir ki, 47. satırdaki “sayi1” isimli sınıf degiskeni ekrana yazılmak istendigi

zaman sanki bu metod çagrılmaktadır. Çünkü ekranda toString metodunun döndürdügü String ifadesi yazılmaktadır.

Aslında gerçekten de 47. satırda sayi1 degiskeninin ekrana basıldıgı noktada otomatik olarak bu metod çagrılır.

Yazılan tüm sınıflara aslında toString metodu da eklenebilir. Eger

“String toString()”

prototipini bozmadan sınıfınız içerisinde bir toString metodu yazarsanız, bu sınıfa iliskin bir sınıf degiskenini ekrana

basmak istediginizde bu metod otomatik olarak çagrılmaktadır. Ancak metodun içini istediginiz gibi yazabilirsiniz.

Eger yazdıgınız sınıf içerisinde bu metodu eklemez ve bu sınıf türünden bir degiskeni ekrana basmak isterseniz, o

zaman Java otomatik olarak bir toString metodunu kendisi yazacak ve buna iliskin bir String degeri de dödürecektir.

Ancak bu deger oldukça anlasılmaz bilgiler içermektedir. Özetle sınıfınızı nasıl ifade etmek istiyorsanız, buna iliskin

String toString() prototipli bir metod yazabilirsiniz.

Öntanımlı Java Sınıflarının Kullanımı:

Dersimizin bundan sonraki kısmında yeni bir konuya geçmeden önce, Java'da öntanımlı bazı sınıflara iliskin örnekler

yapmakta yarar görüyorum. Görecegimiz bu sınıflar, yazacagımız programlarda birçok yükü üzerimizden almakta

ve bize bazı yararlı hazır metodlar sunmaktadır. Bu nedenle isimizi görecek ve daha önceden yazılmıs bu hazır sınıf

ve metodları kullanarak zaman kaybı ve zahmetten kurtulabiliriz.

Bir konuda sizleri uyarmak isterim: Burada bu öntanımlı java sınıflarının tüm metodlarını detaylı bir sekilde

göstermek yerine, bu sınıflar hakkında bilgi sahibi olmanızı ve sadece birkaç metod kullanımıyla sınıfı sizlere

tanıtmayı hedefledim. Kendi uygulamalarınız için burada genel olarak ögrenmis oldugunuz bu sınıfların size uygun

metodlarını ve burada gösterilmeyen baska öntanımlı sınıfları java dökümantasyonu ve internette yapacagını

aramalar ile bulabilirsiniz. Java dökümantasyonunun online halini:

“http://java.sun.com/j2se/1.4.2/docs/api/index.html” adresinde bulabilirsiniz.

Özetle buradaki örnekleri sizlere sadece neyi nerede arayacagınızı bilmeniz açısından veriyorum. Simdi bu sınıfları

incelemeye baslayalım.

Math Sınıfı:

Bu sınıf çesitli matematiksel islemleri yapabilecegimiz metodları sunmaktadır. Bu metodlar içerisinde sin, cos, tan,

kuvvet alma, kök alma v.b. metodlar bulunmaktadır. Bu sınıfı kullanabilmeniz için uygulamalarınızın basında

herhangi bir kütüphaneyi “import” etmenize gerek yoktur. Asagıda Math sınıfınının bazı metodlarının kullanımına

iliskin bir örnek verilmektedir. Bu örnek, daha önce yapmıs oldugumuz karmasık sayı sınıfının biraz

gelistirilmis hali ve Math sınıfının fonksiyonlarının kullanıldıgı bir örnektir. Ayrıca bu sınıfa “aciHesapla” adında yeni

bir metod daha eklenmis ve sınıfın içerisinde saklanan karmasık sayının açı degerleri bu metod yardımıyla

hesaplanmıstır.

Simdi örnegimizi daha detaylı inceleyelim. Herseyden önce genel bir noktayı vurgulamak istiyorum. Dikkat

ederseniz “KarmasikSayi2” sınıfının 23, 24, 27 satırlarında, “gercel” ve “imajinel” degerlerini “this.gercel” diyerek

dogrudan almak yerine bu degerleri 13 ve 16. satırlarda yazılmıs olan “gerceliVer” ve “imajineliVer” metodları

yardımıyla alıyoruz. Bunun nedeni sınıfın veri elemanlarını korumak ve böylece sınıf hiyerarsisini düzgün bir sekilde

kurmak içindir.

Bu teknik bizlere oldukça önemli ve saglam bir mekanizma sunar. Zaten dikkat ederseniz “gercel” ve “imajinel”

isimli veri elemanları da dısarıdan dogrudan erisimin engellenmesi amacı ile 7. satırda “private” olarak

tanımlanmıstır. Veri elemanlarına erisimin bu sekilde kontrollü olarak yapılması gerekir. Eger bu elemanlara

erisilmek gerekiyorsa, bu isi dogrudan degil de set ve get metodları gibi metodlar yardımıyla yapmak gerekir.

Kullanıcıya sadece bu metodlar sunulmalı, sınıfın veri elemanlarına erisim ise metodlar içerisinde ve gerektigi gibi

yapılmalıdır.

23. satırda kullanılan “Math.pow” isimli metod 1. parametre ile aldıgı sayının, 2. parametre ile aldıgı sayı kadar

kuvvetini hesaplar ve sonucu geri döndürür. Bu metodu “gercel” ve “imajinel” kısımların karelerini hesaplamak için

kullandık. Bu karelerin toplamının da karekökünü, tahmin ettiginiz gibi Math.sqrt metodu ile elde ettik. Yani özetle;

Math.pow degerleri ile elde edilen “gercel” ve “imajinel” kısımların karelerinin toplamını, Math.sqrt metoduna

paramtere olarak dogrudan göndererek sonucu da dogrudan geri döndürdük. Sizler de bol bol program yazdıkça

bu tip hızlı yazım tekniklerinizi gelistireceginizden emin olabilirsiniz. Ancak pratik olması amacıyla kısa kodlar

yazarken bile kodunuzun okunabilir olmasına dikkat ediniz.

Örnegimizin 27. satırında kullandıgımız “Math.atan2” isimli metod kendisine parametre olarak verilen “y” ve “x” gibi

iki sayının polar koordinatlarda sahip oldugu açı degerini hesaplayan bir metoddur. Yani aslında yaptıgı islem y/x

degerinin arktanjant degerini hesaplamaktır. Fakat geri dönen bu deger radyan cinsindendir. Bu nedenle, radyan

olarak elde edilen açı degeri 29. satırda yazılan “aciyiDereceVer” metodu ile derece olarak da elde edilebilir.

Hızlı bir sekilde listelemek gerekirse Math sınıfının bazı diger metodları sunlardır:

int Math.abs(int a) a sayısının mutlak degerini geri döndürür. Aynı metodun

float, double ve long türler için de versiyonları vardır.

double Math.acos(double a) a sayısnın ters kosinüs degerini döndürür. Benzer sekilde

asin ve atan metodları da vardır.

double Math.cos(double a) a sayısnın cosinüz degerini geri döndürür. Benzer sekilde

sin metodu da vardır.

double Math.exp(double a) a sayısnın e sayısını kuvveti olarak hesaplar ve bu degeri

döndürür.

int Math.max(int a, int b) a ve b sayılarından büyük olanın degerini geri döndürür.

Benzer sekilde bu metodun double, int, float ve long

versiyonları da vardır.

double Math.random() 0 ile 1 arasında rastgele pozitif bir sayı üretir ve bu degeri

döndürür.

DecimalFormat Sınıfı:

Java ile yazdıgımız programlarda sayısal degerler çogu zaman anlasılması zor ve gereksiz uzunlukta üretilir. Ancak

Java bizim için sayının ne kadar uzunlukta olması gerektigini otomatik olarak bilemez ve bu nedenle en dogru ve

orjinal sekilleriyle bu degerleri üretmektedir. Eger yukarıdaki örnegi yazıp çalıstırdıysanız, elde edilen sonuçların (açı

degerleri gibi) virgülden sonra oldukça fazla miktarda basmak içerdigini görmüssünüzdür.

DecimalFormat sınıfı, sayıları istedigimiz gibi ifade edebilmemize olanak saglar. Bu sınıfın kullanımına iliskin bir

örnek yazalım:

Örnegimize dikkat edersek, “DecimalFormat” sınıfını kullanmadan önce 4. satırda oldugu gibi

“java.text.DecimalFormat” kütüphanesini programa dahil etmeliyiz. 9. satırda yaratılan bir DecimalFormat nesnesi

yapmak istedigimiz ifade biçimini String bir deger olarak tutmaktadır. Bu nesne yaratıldıktan sonra, nesne

aracılıgıyla istenilen bir sayı “format” metodu kullanılarak 13. satırda oldugu gibi biçimlendirme yapılabilir. “format”

metodunun geri dönüs degeri String bir degerdir.

Sargı Sınıfları:

Java'da yaygın olarak kullanılan sınıflar arasında sargı sınıfları da vardır. Bu sınıflar aslında genel olarak aynı

prensiple kullanılır. Bı sınıfları kullanmaktaki amaç bilinen temel türleri (integer, float, double gibi) String türüne ya

da tersine, String türündeki bir ifadeyi temel türlere dönüstürmektir. Aslında bu tür sınıflara olan ihtiyacı örnek

üzerinde açıklarsak daha anlasılır olacaktır.

Mesela en son yaptıgımız “OndalikKisim” sınıfı örneginde, 10. satırda tanımlanan “a” degiskeni içerisindeki degerin

biçimlendirilmis hali String türünde elde edilmektedir. Ancak biz bu biçimlendirilmis hal ile baska matematiksel

islemler yapmak istedigimizde String türündeki bu sonuç isimize yaramayacaktır. Bu sonucun tekrar double türünde

elde edilmesi gerekir. Bunun için String türünde elde edilen bu deger “Double.parseDouble” metodu ile tekrar

double türüne dönüstürülebilir. Bu metodun örnek kullanımı:

...

double yeniBicim = Double.parseDouble(ikiHane.format(a));

..

seklinde olacaktır. Bu dönüsümleri yapan diger bazı sargı sınıfları ve metodları da sunlardır:

int Integer.parseInt(String str) str ile gelen String biçimindeki sayıyı integer

biçiminde geri döndürür.

String Integer.toString(int a) integer türündeki a sayısının String türünde

degerini geri döndürür.

double Double.parseDouble(String str) str ile gelen String biçimindeki sayıyı double

biçiminde geri döndürür.

String Double.toString(double a) double türündeki a sayısının String türünde

degerini geri döndürür.

float Float.parseFloat(String str) str ile gelen String biçimindeki sayıyı float biçiminde

geri döndürür.

String Float.toString(float a) float türündeki a sayısının String türünde degerini

geri döndürür.

String String.valueOf(int a) integer türündeki a sayısnın String degerini geri

döndürür. Aynı metodun double, float, ve long türünde

parametre alan versiyonları da vardır

ArrayList Sınıfı:

Daha önce ögrenmis oldugumuz diziler konusundan bildigimiz gibi bir dizi yaratıldıktan sonra artık otomatik olarak

boyutu degismiyordu. Siz diziyi belirli bir uzunlukta açtıktan sonra dizinin tüm alanları doluysa, yeni bir eleman

eklemek için birtakım algoritmik yöntemler uygulamanız gerekir. Ya da diziden bir eleman çıkardıgınız zaman, diger

elemanları birer basmak geri kaydırmak gibi birtakım isleri de yapmanız gerekir.

“ArrayList” sınıfı bu tür görevleri otomatik olarak yapan ve bize dinamik olarak kullanabilecegimiz bir dizi

mekanizması sunan bir sınıftır. Eger böyle bir diziye sahip olmak istiyorsanız asagıdaki sekilde bir “ArrayList”

nesnesi tanımlamanız gerekir:

ArrayList dinamikDizi = new ArrayList();

Daha sonra bu nesneyi artık kendi dizinismis gibi düsünerek “ArrayList” sınıfının sundugu metodlar yardımıyla

eleman ekleme, çıkartma ve bulma gibi islemler yapabilirsiniz. Mesela “dinamikDizi” nesnesine eleman eklemek için:

dinamikDizi.add(“merhaba”);

ya da

int a = 3;

dinamikDizi.add(a);

ArrayList sınıfının yukarıda gördügümüz gibi “add” isimli metodunun yanısıra diger metodlarından bazıları da

sunlardır:

void remove(int index) Dizinin verilen indeks numarasındaki elemanını çıkartır ve

diziyi buna göre düzenler. Örnek kullanım:

int a = dinamikDizi.remove(2); //2.eleman siliniyor

int size() Dizinin içerisindeki elelman sayısını verir. Örnek kullanım:

int a = dinamikDizi.size();

Object get(int index) Dizinin index nolu elemanını geri döndürür. Örnek kullanım:

String str = dinamikDizi.get(0);

int indexOf(Object o) o ile temsil edilen nesnenin dizi içerisindeki indeks nuaarasını

geri döndürür. Eger eleman dizide yoksa -1 geri döndürür.

Asagıdaki “KayitListesi.java” uygulamamızda hem böyle bir dinamik dizi kullanımını, hem de bugüne kadar

ögrendiklerimizle gerçege oldukça yakın bir java uygulamasının yazımını görmekteyiz. Bu uygulama çalıstıgında,

ekrana resimdeki gibi bir menü sunulmakta ve kullanıcının yaptıgı seçimlerle kayıt ekleme, silme, kayıtları listeleme

gibi islemler yapıldıktan sonra tekrar aynı menü ekrana gelmektedir. Kullanıcıya istedigi zaman programdan

çıkabilecegi bir seçenek de sunulmaktadır.

KayitListesi.java Uygulamasındaki Nesne Yönelimli Programcılık zleri

Uygulamamız içerisinde , her seçime iliskin bir metod uygun isi üstlenmektedir. Ayrıca tüm alt görevleriyle ve

degiskenleriyle birlikte bu uygulama tek bir sınıf altında ve tek bir amaç için olusturulmustur. Programlarınızda bu

sekilde is bölümü yapma islemi nesne yönelimli programcılıgın baslıca presiplerinden birisidir.

Yazmıs oldugumuz bu uygulama tek bir sınıf nesnesi olarak tasarlanmıs ve 106. satırdaki main metodu içerisinde de

bir degisken aracılıgıyla çalıstırılmıstır. Ayrıca dikkat ederseniz uygulamamızın bazı metodları “private” olarak

tasarlanmıstır. Bunun nedeni; bu metodların iç mekanizma isleyisi için kullanılıyor olmasıdır. Yani 109. satırda

oldugu gibi kullanıcı, bu sınıfın “uygulamaBaslat” metodunu çagırabilmeli ancak diger metodlarını çagıramamalıdır.

Bu metodların hangi sırada ve ne zaman çagrılacagı program içerisinde sınıfın kendisi tarafından ve uygun bir

hiyerarsi ile belirlenmektedir. Bu nedenle, bir degisken üzerinden erisilmemesi istenen metodlar private olarak

tasarlanmıstır. Böylece bu metodlara, sadece sınıfın diger metodlarının erisebilmesine izin verilmektedir. Kullanıcının

hizmetine ise sadece “public” metodlar sunulmaktadır.

StringBuffer Sınıfı:

Daha önceki derslerimizde ögrendigimiz üzere String sınıfı bazı yararlı metodlara sahiptir. Hatta bu metodlardan

“equals” ve “matches” isimli olanlarını da, “KayitListesi.java” uygulamamızda 19.satırda ve “toUpperCase” isimli

olanı da 37. satırda kullanmaktayız.

Bu metodlar sayesinde çesitli kolaylıkları olan String türünde degiskenlerin içerikleri sabit uzunluktadır. Bu nedenle

içerigi de dinamik olarak degistirilebilen bir sınıf türüne ihtiyaç duyulmaktadır. Bu amaçla StringBuffer isimli sınıf

kullanılabilir.

StringBuffer sınıfı kullanılmadan önce bu sınıf türünden bir nesne yaratılmalıdır:

StringBuffer strbuffer = new StringBuffer();

Bu sekilde, içerisinde hiç karakter tutmayan ve 16 karakter kapasiteli bir StringBuffer nesnesi yaratılabilir. Bu sınıfın

baska baslangıç metodları da vardır. Mesela 20 karakter kapasiteli bir nesne yaratmak için

StringBuffer strBuf = new StringBuffer(20);

Ya da hazır bir String degiskenini StringBuffer halinde yaratmak için:

StringBuffer str = new StringBuffer(“Merhaba”);

yazmak gerekir. Bu sınıf içerisinde tutulan String degerinin String olarak kullanılabilmesi için, sınıfa ait olan toString

metodu kullanılabilir. Mesela az önce “Merhaba” String degeri ile yaratmıs oldugumuz “str” isimli StringBuffer

nesnesinin String degeri:

String a = str.toString();

seklinde elde edilebilir.

Bu sınıfın sahip oldugu bazı metodlar sunlardır:

StringBuffer append(String) StringBuffer nesnesi içerisinde tutulan String sonuna

parametre ile verilen String degerini ekler ve bu yeni hali

StringBuffer nesnesi olarak geri döndürür. Bu metodun int,

float, double, char [] parametreli versiyonları da vardır.

int capacity() Nesnenin sahip oldugu karakter kapasitesini verir.

void ensureCapacity(int minCapacity) Nesnenin kapasitesini minCapacity parametresi ile verilen

deger haline getirir.

char charAt(int index) Nesnenin tuttugu String degeri içerisinde verilen indekste yar

alan karakteri geri döndürür.

StringBuffer reverse() Nesnenin içerisinde tutulan String degerininin ters çevrilmis

halini geri döndürür.

Ancak yine de hatırlatmak isterim ki StringBuffer sınıfının daha birçok metodu vardır. Diger metodları her zaman

söyledigim gibi Java dökümantasyonu içerisinde bulabilirsiniz.

NumberFormat ve DecimalFormat Sınıfı: Çıkısın Biçimlendirilmesi

Asagıdaki gibi bir numerik hesap yaptıktan sonra

x = 10000.0/3;

System.out.println(x) metodu yardımıyla bu sonucu ekranda görüntüleyebiliriz.

Ancak ekrana gelecek olan bu görüntü 3333.333333335 seklinde olacaktır. Oysa biz çıkısın daha anlamlı olmasını

isteyebiliriz. Bunun için DecimalFormat sınıfından yararlanıyoruz.

DecimalFormat formatter =

System.

System.

}

}

Ayrıca sistemde tanımlı olan yerel sayı, para birimi (currency) gibi degerleri kullanmak için de NumberFormat

sınıfından yararlanabiliyoruz

NumberFormat formatter = NumberFormat.getCurrencyInstance();

formatter.setMaximumFractionDigits(4);

formatter.setMaximumIntegerDigits(6);

formatter.setMinimumIntegerDigits(6);

String s = formatter.format(y);

System.

}

}

GregorianCalendar Sınıfı

Java’da tarihlerle ilgili islemler yapmak için kullanılabilecek 2 tane sınfı vardır.

Tarihte herhangi bir noktayi ifade etmek için “Date” sınıfı kullanılabilir.

Date d1 =

d1.setYear(1999-1900);

d1.setDate(12);

d1.setMonth(0);

Date d2 =

d2.setTime(System.currentTimeMillis());

System.

System.

}

}

GregorianCalendar sınıfı, Date sınfından daha fazla metoda sahiptir.

GregorianCalendar ile kullanabileceginiz baslangıç metodları:

new GregorianCalendar()

new GregorianCalendar(1999, 11, 31);

new GregorianCalendar(1999, Calendar.DECEMBER, 31, 23, 59, 59)

GregorianCalnedar kullanarak zamanı elde etme ve istedigimiz gibi degistirmeye

iliskin temel metodlar sunlardır:

GregorianCalendar simdi = new GregorianCalendar();

int month = simdi.get(Calendar.MONTH);

simdi.setTime(Calendar.MONTH, 3);

simdi.add(Calendar.MONTH, 3);

GregorianCalendar simdi =

System.

+

System.

}

}

}

}

}

}

ODEV:

Dinamik buyuyen int array dizisini double, String ve int turleri icin genellestirip gerekli tum metodlari da barindiran

bir DinamicArray nesnesi yaratiniz.

Önümüzdeki derste Sınıfların Türetilmesi konusunu detaylı bir sekilde inceleyecegiz.

Java ile Programlama

Bölüm 9 - 10

Stringler

Daha önce de sıkça kullanıdıgımız String türünde degiskenler asılnda ilkel degiskenlerden biraz daha farklıdır.

Burada ilkel kelimesinden kasıt her dilde tanımlı olan ve java’da da yer alan en temel degiskenlerdir. Java’da

String’ler bu temel olma durumunun biraz daha üstünde nesnelerdir. Zaten String nesnelerinin kendilerine ait bazı

metodların olması da bu durumu açıkça göstermektedir. Teknik olarak Stringler karakter dizileridir.

Bir String nesnesi ile kullanılabilecek özel metodları söyle listelyebiliriz:

a)

b) char charAt(int index):

c) String substring(int start, int end):

d) String toUpperCase():

e) String toLowerCase():

f) String trim():

g) int indexOf(String str):

gönderir.

h) boolean equals(String str):

durumunda true, diger durumda false degerinin üretir.

i) boolean equalsIgnoreCase(String str):

dikkat etmez.

j) String valueOf(int a):

Çok Boyutlu Diziler

Çok boyutlu diziler aslında her elemanı baska bir dizi olan dizilere çok boyutlu diziler denilir.

1) Bir çift boyutlu dizinin tüm elemanlarinin toplamini bulan bir metod yaziniz:

a. 1nt findTotal(int arr[][]);

2) Verilen bir çift boyutlu diziyi dortgn haline getiren bir metod yaziniz. Verilen

uzunlukta olmayabilir.

a. 1nt [][] makeSquare(int arr[][]);

Sınıfların Türetilmesi

Sınıfların türetilmesi kavramını söyle bir örnekle açıklamaya çalısalım: Diyelim ki çok büyük bir programlama

projesinin bir kısmında görev aldınız. Öyle ki sizin yapmanız gereken kısım bir ekran üzerine yerlestirilecek olan

seçenek dügmelerinin tasarımı olsun. Ancak bu islemi yapabilmeniz için elinizde herseyden önce bir ekran

görüntüsünün olması lazım. O halde öncelikle bir ekran görüntüsü olusturan program parçası, ya da artık yeni

ögrendigimiz kavramlara dayanarak, temel ekran islemlerini barındıran sınıf olması gerekmektedir. Ancak sizin asıl

isiniz olmadıgından, ekran islemlerine iliskin bir sınıf yazmanız ve daha sonra da kendi dügmelerinizi de bu sınıf

içerisine eklemeniz gereksiz bir is olacaktır. Ayrıca bu ekran islemleri gibi temel nitelige sahip ve sizin dısınızda diger

kisilerin de baska islemler için ihtiyaç duyabilecegi bir sınıf kendi basına ayrı bir sekilde tasarlanmalıdır. Eger bu

sınıfın temel özelliklerini koruyarak, üzerine herkesin ihtiyaç duyacagı yeni özelliklerle birlikte yeni bir sınıf haline

getirilecegi bir mekanizma olursa, önceden harcanan emek de yeni islemler için temel teskil edecek nitelikte olup,

gereksiz is gücü kaybı engellenmis olacaktır.

1ste Java'da bu mekanizmaya sınıfların türetilmesi denilir. Sekilde türetme iiliskisine iliskin bir örnek yer almaktadır.

Buna göre sekildeki “TemelSinif”tan türetilen “Sinif 1” ve “Sinif 2” isimli sınıfların islevleri “Temel Sınıf”ın islevlerini

de içermektedir. Buna göre “Sinif 1”; kendi içerisinde yer alan “x”, “y” ve “z” degiskenleri ile “X” metodunun yanı

sıra, “TemeSinif” dan türedigi için “a”,”b” degiskenleri ile “A”, “B” metodlarına da sahip olmaktadır. Benzer sekilde

“Sinif 2”, kendisinde yer alan “k” degiskeni ile “K”, “L” ve metodları ve türetme iliskisi yüzünden “a”, “b”

degiskenleri ile “A” ve “B” metodlarına da sahip olmaktadır.

Sekilde bu türetme iliskisinin “Sinif 1” ve “Sinif 2” den “TemelSinif”a dogru giden oklarla gösterilmesi bir yanlıslık

degil, kasten yapılmaktadır. Nesne yönelimli programlamada türetme iliskisi genellikle bu sekilde, yani, türetilmis

sınıftan türetilen sınıfa dogru gösterilmektedir.

Örnek Uygulama 1

O halde kavramsal olarak inceledigimiz türetme islemini bir de uygulamalı olarak görelim. Kisi.java, Ogrenci.java ve

KisiDeneme.java dosyalarından olusan klasik örnekte bir kisi kaydını temsil eden bir sınıftan, bir ögrenci kaydını

temsil eden farklı bir sınıf türetilmektedir.

class Kisi {

String isim;

String adres;

char cinsiyet;

public Kisi(String gelenIsim, char gelenCinsiyet, String gelenAdres) {

this.isimSetEt(gelenIsim);

this.adresSetEt(gelenAdres);

this.cinsiyetSetEt(gelenCinsiyet);

}

public void isimSetEt(String yeniIsim) {

this.isim = yeniIsim.toUpperCase();

}

public void adresSetEt(String yeniAdres) {

this.adres = yeniAdres.toUpperCase();

}

public void cinsiyetSetEt(char gCinsiyet) {

if(gCinsiyet != 'e' && gCinsiyet != 'k') {

System.out.println("Cinsiyet bilgisi \"e\" ya da \"k\"

olmali.");

System.out.println("Yanlis bir deger girdiniz...");

System.out.println("Program sonlaniyor");

System.exit(0);

}

else

this.cinsiyet = gCinsiyet;

}

public String ismiGetir() {

return this.isim;

}

public String adresiGetir() {

return this.adres;

}

public char cinsiyetiGetir() {

return this.cinsiyet;

}

public String toString() {

String str="";

str += "Kisi Bilgileri\n";

str += "Isim: "+this.ismiGetir()+"\n";

str += "Cinsiyet :"+this.cinsiyetiGetir()+"\n";

str += "Adres: "+this.adresiGetir()+"\n";

return str;

}

}

Örnekte, türetme islemine maruz kalan sınıfın “Ogrenci” isimli sınıf oldugunu görmekteyiz. Bu nedenle “Ogrenci”

isimli sınıf yaratılırken sınıf bildiriminin devamına “extends” anahtar sözcügü ve daha sonra da bu sınıfın türetildigi

temel sınıf olan “Kisi” sınıfının adı yazılmaktadır

class Ogrenci extends Kisi {

String bolum;

int donem

public Ogrenci(String ad, char cns, String adr, String blm, int dnm) {

super(ad, cns, adr);

this.bolumSetEt(blm);

this.donemiSetEt(dnm);

}

public String bolumuGetir() {

return this.bolum;

}

public void bolumSetEt(String yBolum) {

this.bolum = yBolum.toUpperCase();

}

public int donemiGetir() {

return this.donem;

}

public void donemiSetEt(int yDonem) {

this.donem = yDonem;

}

public String toString() {

String str = super.toString();

str += "Bolum: "+this.bolumuGetir()+"\n";

str += "Donem: "+this.donemiGetir()+"\n";

return str;

}

}

Böylece Ogrenci sınıfı artık aynı zamanda bir “Kisi” sınıfı haline gelmis ve kendi degisken ve metodlarının yanı sıra,

“Kisi” sınıfının degisken ve metodlarına da sahip olmustur. Bu nedenle “Ogrenci” sınıfını yazarken bir daha isim,

cinsiyet ve adres degiskenleri ve bu degiskenler ile ilgilenen gerekli metodları yazmaya gerek yoktur.

class KisiDeneme {

public static void main(String arg[]) {

Ogrenci o1 = new Ogrenci("Dogac Berkun", 'e', "Kurtulus Cd. No 24",

"Bilgisayar Bilimleri", 2);

System.out.println(o1);

o1.donemiSetEt(3);

System.out.println(o1);

}

}

KisiDeneme.java dosyasındaki “main” metodu içerisinde en son olusturdugumuz “Ogrenci” sınıfını kullanarak bir

nesne yaratmaktayız. Daha sonra da önceden ögrendigimiz “toString” metodu islevinden yararlanarak (bkz. Bölüm

6) olusturdugumuz bu “Ogrenci” türünden nesneyi ekrana basmaktayız.

Sınıflarda super Metodu:

En son yazdıgımız “Ogrenci” sınıfının baslangıç metodu içerisinde “super” isimli

Oysa “Ogrenci” isimli sınıfın böyle bir metodu yoktur. O halde hiç yazılmamıs olan bu metod nedir?

Baska bir sınıftan türetilmis olan sınıflarda, “super” ile temsil edilen metod, türetmenin yapıldıgı sınıfın baslangıç

metodunu temsil etmektedir. O halde bizim örnegimizde “Ogrenci.java” dosyasının 7. satırındaki

super(ad, cns, adr);

kullanımı ile “Ogrenci” sınıfının türedigi “Kisi” sınıfının uygun parametreli baslangıç metodunun çagrıldıgını

söyleyebiliriz. Böylece “KisiDeneme.java” dosyasında kullanıcı “Ogrenci” nesnesini yaratırken, aslında arka planda,

bu “Ogrenci” nesnesinin içerisinde yer alan “Kisi” nesnesine ait kısımlar, “Kisi” nesnesinin baslangıç metodu ile

olusturulmakta ve daha sonra da “Ogrenci” nesnesinin kendisine ait olan kısımlar olusturulmaktadır. Fakat bu

islemlerin hepsi neticede “Ogrenci” nesnesinin baslangıç metodu içerisinde yapılmaktadır. “Ogrenci” nesnesi “Kisi”

nesnesinden türedigi için, bünyesinde “Kisi” nesnesine ait kısımları da barındırmakta ve dolayısı ile “super” metodu

yardımıyla gerektiginde “Kisi” nesnesinin baslangıç metodlarına ya da “Ogrenci.java” dosyasının 29. satırında

oldugu gibi “Kisi” nesnesini baska metod ve degiskenlerine erisme hakkına sahip olmaktadır.

Örnek Uygulama 2

Simdi örnegimizi biraz daha genellestirelim ve bu sefer içerisinde “Ögrenci2” sınıfı türünden nesneleri tutan ve bu

nesneler ile ilgili çesitli islemler yapan bir “Kayitlar” isimli bir sınıf tasarlayalım.

class Kisi2 {

String isim;

char cinsiyet;

public Kisi2(String gelenIsim, char gelenCinsiyet) {

this.isimSetEt(gelenIsim);

this.cinsiyetSetEt(gelenCinsiyet);

}

public void isimSetEt(String yeniIsim) {

this.isim = yeniIsim.toUpperCase();

}

public void cinsiyetSetEt(char gCinsiyet) {

if(gCinsiyet != 'e' && gCinsiyet != 'k') {

System.out.println("Cinsiyet bilgisi \"e\" ya da \"k\" olmali.");

System.out.println("Yanlis bir deger girdiniz...");

System.out.println("Program sonlaniyor");

System.exit(0);

}

else

this.cinsiyet = gCinsiyet;

}

public String ismiGetir() {

return this.isim;

}

public char cinsiyetiGetir() {

return this.cinsiyet;

}

public String toString() {

String str="";

str += "Kisi Bilgileri\n";

str += "Isim: "+this.ismiGetir()+"\n";

str += "Cinsiyet :"+this.cinsiyetiGetir()+"\n";

return str;

}

}

class Ogrenci2 extends Kisi2 {

String bolum;

int donem;

int ogrenci_no;

String ortalama;

public Ogrenci2(String ad, char cns, String blm, int dnm, int ogrNo, double ort)

{

super(ad, cns);

this.bolumSetEt(blm);

this.donemiSetEt(dnm);

this.numaraSetEt(ogrNo);

this.ortalamaSetEt(ort);

}

public String bolumuGetir() {

return this.bolum;

}

public void bolumSetEt(String yBolum) {

this.bolum = yBolum.toUpperCase();

}

public int donemiGetir() {

return this.donem;

}

public void donemiSetEt(int yDonem) {

this.donem = yDonem;

}

public int numarayiGetir() {

return this.ogrenci_no;

}

public void numaraSetEt(int ogrNo) {

this.ogrenci_no = ogrNo;

}

public String ortalamayiGetir() {

return this.ortalama;

}

public void ortalamaSetEt(double yeniOrt) {

if(yeniOrt < 1.0)

this.ortalama = "F";

else if(yeniOrt >= 1.0 && yeniOrt < 1.5)

this.ortalama = "D";

else if(yeniOrt >= 1.5 && yeniOrt<2.0)

this.ortalama = "C";

else if(yeniOrt >= 2.0 && yeniOrt<3.6)

this.ortalama = "B";

else if(yeniOrt >= 3.6 && yeniOrt <= 4.0)

this.ortalama = "A";

}

public String toString() {

String str = super.toString();

str += "Bolum: "+this.bolumuGetir()+"\n";

str += "Donem: "+this.donemiGetir()+"\n";

str += "Ogrenci No: "+this.numarayiGetir()+"\n";

str += "Ortalamasi: "+this.ortalamayiGetir()+"\n";

return str;

}

}

class Kayitlar {

Ogrenci2 dizi[];

public Kayitlar() {

}

public Kayitlar(Ogrenci2 yeniEleman) {

this.dizi = new Ogrenci2[1];

this.dizi[0] = yeniEleman;

}

public void ekle(Ogrenci2 eklenecekOgr) {

if(this.dizi == null) {

dizi = new Ogrenci2[1];

this.dizi[0] = eklenecekOgr;

}

else {

Ogrenci2 tmp[] = new Ogrenci2[dizi.length+1];

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

tmp[i] = dizi[i];

tmp[tmp.length-1] = eklenecekOgr;

this.dizi = tmp;

}

}

public void cikart(int id) {

Ogrenci2 tmp[] = new Ogrenci2[dizi.length-1];

int indeks=-1;

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

if(dizi[i].numarayiGetir() == id)

indeks = i;

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

tmp[i] = dizi[i];

for(int i = indeks; i < dizi.length-1; i++)

tmp[i] = dizi[i+1];

dizi = tmp;

}

public void listele() {

System.out.println("Kayitlar listeleniyor:");

System.out.println("--------------------");

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

System.out.println(""+dizi[i]);

}

public Ogrenci2 enBuyukOrtalamaliOgrenci() {

Ogrenci2 max=dizi[0];

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

if(dizi[i].ortalamayiGetir().compareTo(max.ortalamayiGetir()) == -1)

max = dizi[i];

}

return max;

}

}

class KayitlarDeneme {

public static void main(String arg[]) {

Kayitlar x = new Kayitlar();

x.ekle(new Ogrenci2("Evren Banger", 'e',"Bilgisayar", 2, 100, 2.54));

x.ekle(new Ogrenci2("Aykut Toygar", 'e',"Bilgisayar", 2, 101, 2.4));

x.ekle(new Ogrenci2("Hande Kumek", 'k', "Bilgisayar", 3, 102, 3.5));

x.ekle(new Ogrenci2("Ilker Kara", 'e', "Bilgisayar", 2, 103, 1.55));

x.ekle(new Ogrenci2("Cemile Caglar", 'k',"Isletme", 4, 201, 3.7));

x.ekle(new Ogrenci2("Erdem Aykac", 'e', "Isletme", 4, 202, 3.58));

x.listele();

Ogrenci2 sonuc = x.enBuyukOrtalamaliOgrenci();

System.out.println("En buyuk ortalamali ogrenci: \n"+sonuc);

}

}

Bu sınıf daha önceki derslerimizde yazmıs oldugumuz “KayitListesi” sınıfını andırmakla beraber, bu sefer sınıfın veri

elemanı bu kayıtları tutacak “Ogrenci2” türünden bir dizi olacaktır. Bu arada , “Ogrenci2” sınıfı da bir önceki örnekte

kullandıgımız “Ogrenci” sınıfına çok benzer olup sadece bazı metodları degistirilerek yeniden yazılmıstır. Özetle bu

örnek “Kisi2.java”, “Ogrenci2.java” ve “Kayitlar.java” dosyalarından olusmakta ve en son olarak

“KayitlarDeneme.java” dosyasında çalıstırılmaktadır.

Simdi de gelelim bu uygulamanın detaylı bir incelemesine: “KayitlarDeneme.java” dosyasındaki main metodu

içerisinde “Kayitlar” sınıfı türünden bir nesne yaratılmıs ve bu nesneninin “ekle” isimli metodu yardımıyla birtakım

“Ogrenci2” sınıfı türünden nesneler hemen o anda parametre olarak yaratılarak listeye eklenmistir. Bu “Ogrenci2”

türünden nesneleri önce degisken olarak yaratıp daha sonra “ekle” metdouna parametre olarak gönderebilirdik.

Örnegin:

...

Ogrenci2 o2 = new Ogrenci2("Evren Banger", 'e',"Bilgisayar", 2, 100, 2.54)

x.ekle(o2);

...

Ancak bizim kullanıdıgımız yöntem hem daha pratik hem de gereksiz degiskenlerden arınmıs bir program yazmamızı

saglamaktadır.

“Kayitlar.java” sınıfının içerisindeki

public Kayitlar(Ogrenci2 yeniEleman)

prototipli baslangıç metodu daha önce hiç kayıt eklenmemis durum için tek elemanlı yeni bir “Ogrenci2” dizisi

yaratır ve “yeniEleman” isimli “Ogrenci2” türünden parametreyi de bu diziye ekler. Yine “Kayitlar” sınıfının

metodlarından birisi olan ekle isimli metod da durumu iki türlü ele alır. Eger daha önce hiç kayıt eklenmemisse önce

tek elemanlı bir “Ogrenci2” dizisi açılarak bu kayıt diziye eklenir (satır 16-18). Ama zaten daha önceden eklenmis

kayıtlar varsa o zaman ilk olarak eski diziden 1 eleman fazla uzunlukta “tmp” adında yeni bir geçici dizi yaratılır

(satır 22), daha sonra eski dizinin tüm elemanları bu diziye de kopylanır (satır 24-25) ve en son olarak da bu tmp

dizisinin fazla olan sondaki bos eleman yerinde de metoda parametre olarak gönderilen “eklenecekOgr” isimli

“Ogrenci2” nesnesi yerlestirilir (satır 27). Tüm bu islemlerin sonunda da artık kayıtların son halini tutan “tmp” dizisi,

sınıfın kendi dizisi olan “dizi” isimli “Ogrenci2” dizisine atanır (satır 28).

Buna benzer olarak; sınıfın cıkart isimli metodu da çıkarılacak olan elemanının dizideki indeks numarasını

saptadıktan sonra (satır 37-39) bu elemana kadar olan ve bu elemandan sonraki tüm elemanları “tmp” dizisine

kopyalar (satır 41-42 ve 44-45) ve “tmp” dizisini yine sınıfın asıl dizisi haline getirir (satır 47).

“Kayitlar” sınıfının “public Ogrenci2 enBuyukOrtalamaliOgrenci()” isimli metodu ise “Ogrenci2” nesnelerinin

ortalamarına bakarak en yüksek ortlamalı “Ogrenci2” nesnesini geri dönüs degeri olarak gönderir. Geriye dönen bu

deger “KayitlarDeneme.java” dosyasında bir “Ogrenci2” degiskeninde tutularak (satır 16) ekrana basılır (satır 17).

Burada tekrar hatırlatmak isterim ki; “sonuc” adındaki “Ogrenci2” sınıf degiskeni 17. satırda oldugu gibi ekrana

basılmak istendiginde, aslında sonuc degiskeni aracılıgıyla ve “Ogrenci2” sınıfına ait olan “toString” isimli metod

otomatik olarak çagrılmaktadır ve bu metodun hazırlayıp gönderdigi String türünden ifade ekrana basılmaktadır.

Tabi ki bu ifadeyi hazırlayan da sınıfı yazan kisidir.

Umuyorum ki detaylı olarak hazılayıp anlatmaya çalıstıgım bu örnek ile birlikte, sınıfların tasarlanması, baska sınıf ve

metodlar içerisinde kullanılması ve türetilmesine iliskin kavramları daha rahat kavramıs olursunuz.

Uygulama Sorusu

Yukarıda verilen “Kayitlar” sınıfı örnegini biraz daha gelistirerek bu sınıfa ögrencileri not ortalamalarına göre, isim

sırlarına göre listeleyen ve sadece belirli bölümlerdeki ya da belirli dönemlerdeki ögrencileri görüntüleyen metodlar

ekleyiniz ve bu yeni sınıfın adını da “Kayitlar2” olarak degistiriniz. 1pucu olarak; yazmanız gereken bu metodların

prototiplerini asagıdaki sekilde verebiliriz:

public void notOrtalamasinaGoreListele()

public void isimSirasinaGoreListele()

public void bolumdekiOgrenciler(String bolumAdi)

public void donemdekiOgrenciler(int donem)

Sunu da belitmeliyim ki, “Kayitlar” sınıfına ekleyeceginiz bu metodların yanı sıra, eger gerekecegini düsünüyorsanız

mevcut metodların isleyislerini ya da bu sınıfın içerisinde kullanılan “Ogrenci2” sınıfının da yine bazı metodlarının

isleyisini degistirebilirsiniz.

Polymorphism ve Final Metodlar genel açıklama

Ornek:

class TemelSinif {

public void method() {

System.out.println("Temel sinifin metodu");

}

public final void method2() {

System.out.println("Temel sinifin final metodu");

}

}

class TuremisSinif1 extends TemelSinif {

/*Temel sinifin metodunu override etmis*/

public void method() {

System.out.println("TuremisSsinif_1 sinifin metodu");

}

/*Temel sinifin metodunu override etmis*/

public void method2() {

System.out.println("TuremisSsinif_1 sinifin final metodu");

}

}

class TuremisSinif2 extends TemelSinif {

}

class Main {

public static void main(String arg[]) {

TuremisSinif1 t1 = new TuremisSinif1();

TuremisSinif2 t2 = new TuremisSinif2();

TemelSinif tt = new TemelSinif();

t1.method();

t2.method();

tt = t1;

tt.method();

tt = (TemelSinif)t1;

tt.method();

}

}

Instanceof Ornek

}

}

Sınıfların protected veri elemanları:

Daha önceden biliyoruz ki sınıflarda private olan bir degisken ya da metod sadece kendi sınıfının diger metodları

tarafından erisilebilir haldedir. Bununla beraber public sınıf elemanları, hem bu sınıfın diger metodları, hem de bu

sınıf türünden yaratılmıs olan nesneler tarafından, yani dısarıdan erisilebilir haldedir.

Eger bir sınıfın veri elemanı sadece bu sınıfın kendi metodları ya da bu sınıftan türetilmis sınıfların metodları ile

erisilebilir ancak dısarıdan erisilemez olsun isteniyorsa, böyle veri elemanlarının protected veri elemanı olarak

bildirilmesi gerekir. Bu durumda protected veri elemanlarının erisim bakımından public ve private veri elemanları

arasında bir seviyede oldugunu söyleyebiliriz.

Protected Metodlar

Bir sınfıfın bazı metodları protected olarak tasarlanabilir. Böyle metodlar da sadece sınıfı türeten alt sınıflar

içerisinde kullanılabilir ancak dısarıdan kullanılamazlar. Böylece sadece türetme yapan sınıflara güveniliyorsa ve

dısarıya kapatılmak isteniyora bir metod protected olarak tasarlanabillir. Bunun bir örnegini ileriki konularda

görecegimiz Object sınıfının protected metdu olan “clone” metodunu incelreken görecegiz.

Object Sınıfı

Su ana kadar sınıfların türetilmesine iliskin birçok sey ögrendik. O halde artık Java da temel bir sınıf olan Object

sınıfını da inceleyebiliriz. Java’da her sey bir nesnedir. Aslında bu tanım hem kavramsal hem de teknik anlamda

dogrudur.

Kavramsal olarak Java’da herseyin bir nesne oldugunu zaten bu noktaya kadar tartıstık. Teknik olarak da Java’da

herseyin bir nesne olması, Java’daki tüm tanımlı sınıfların aslında “Object” adı verilen özel bir sınıftan türemesi

anlamına gelmektedir.

Öyle ki sizin yazdıgınız bir sınıf da aslında öntanımlı olarak Object isimli sınıftan türemistir.

Object Sınıfının Metodlarının Yeniden Yazılması

Ayrıca daha önce ögrenmis oldugumuz “function overriding” kendi yarattıgımız sınıflarda Object sınıfının bazı

metodlarını kendi istegimize göre sınıfımız içerisinde degistirerek yazabiliriz. Aslında toString isimli metodun böyle

bir metod oldugunu bu noktada belirtmek gerekir

Object sınıfının toString Metodu

toString metodu Object sınıfında yazılmıs olan bir metoddur. Ancak daha önce de söyledigimiz gibi Java’da yazılan

her sınıf, hatta bizim kendi yazdıgımız sınıflar da dahil, birer Object sınıfı kabul edildiginden (yani otomatik olarak

bu sınıftan türediginden), Object sınıfına ait olan bu metodları kendi basımıza yazabiliriz.

Object sınıfının finalize Metodu

finalize() isimli metod da Object sınıfına ait bir metoddur. Bu metodu da kendi sınıfımıza göre yazabiliriz. Ancak

daha önce bu metodun ne iser yaradıgını bilmekte fayda var.

Önceden ögrendigimiz gibi bir sınıf yaratıldıgı zaman otomatik olarak uygun olan baslangıç metodu (constructor)

çagrılmaktadır. Ayrıca sistemde kullanılmayan nesnlerin de garbage collector yapısı ile otomatik olarak ortadan

aldırıldıgını da söylemistik.

1ste sınıflarda benzer sekilde bir sınıf ortadan kaldırılırken, yani islevi sonlandırılırken de otomatik olarak çalgrılan bir

metod vardır. Bu metod finalize() isimli bir metoddur. O halde nasıl baslangıç metodu içerisine sınıfımızın birtakım

ilk islemlerini yazıyorsak, finalize metodu içerisine de bir sınıf sonlanırken yapılması gereken son islemleri

tanımlayabiliriz. Bu son islemlere örnek olarak:

a) Daha önce açılmıs bir dosyanın kapatılması

b) Daha önce yapılmıs bir veri tabanının sonlandırılması

c) Daha önce açılmıs bir session’ın sonlandırılması

d)

verilebilir.

Ancak sunu da belirtmek gerekir ki Java’da finzlize metodu Garbage Collector devreye girdigi zaman çagrıldıgı için

bu metodu tam olarak ne zaman çagrılacagı bilinemez. Bu nedenle bazen öngörülemeyen sonuçlar ortaya çıkabilir.

O halde sonuç olarak kullanıcı aslında kendi istedigi zaman çagırabilecegi birtakım son islemleri yapacak bir metodu

yine kendisi baska bir isimle yazabilir. Böylece son islemler dogru sırada ve kullanıcının istegine baglı olarak

yapılacaktır. Bu da finalize metoduna olan gerekliligi ortadan kaldırmaktadır.

Bunun dısında Object sınıfında baska metodlar da vardır. Ancak bu metodlar ilerde ögrenecegimiz bazı kavramları

gerektirdiginden simdilik Object sınıfına bu kadar deginecegiz.

Object Sınıfına Her Nesne Atanabilir

Java’da herseyin bir Object oldugunu tekrar hatırlayalım. Aslında Object isimli sınıf türünden bir degiskenin bu

nedenle her türden nesneyi tutabilecegini de söyleyebiliriz

Object dizi[] =

dizi[0] =

dizi[1] =

dizi[2] =

}

}

}

Yukarıdaki örnekte Object türünden bir dizi yarattık. Bir dizi içerisinde tüm elemanların aynı türden olması gerektigi

halde birbirinden farklı türleri nasıl oluyor da bir dizide saklayabiliyoruz? 1ste bunun nedeni az önce söyledgim gibi

aslında her türün aynı zaman bir Object olmasından kaynaklanmaktadır.

class ObjectDeneme {

public static void main(String arg[]) {

Object ar[] = {new Deneme(), "String ekledik", new Integer(12), new BaskaBirSinif()};

BaskaBirSinif temp = (BaskaBirSinif)ar[3];

System.out.println(temp.methodX());

/*Olmaz!*/

//ar[3].methodX();

}

}

class Deneme {

public static void methodY() {

System.out.println("Deneme sinifi");

}

}

class BaskaBirSinif {

public static String methodX() {

return "12";

}

}

Soyut sınıflar

Soyut sınıf kavramı aslında tamamen türetme ile iliskilidir. Bu nedenle soyut sınıfların anlamlı kullanılması aslında bir

türetme isleminin yapılmasını gerektirir. Türetme islemini hatırlayacagımız gibi bir sınıf baska bir sınıfının degisken

ve metodlarını alabilmektedir. Böylece önceden yazılmıs birtakım metod ve degiskenlerin yeraldıgı bir sınıf varsa ve

biz de bu metod ve degiskenlere ihtiyaç duyuyor ve aynı zamanda yeni metod ya da degiskenler de eklemek

istiyorsak, mevcut sınıftan bir türetme yaparak sadece yeni eklemek istedigimiz metod ve degiskenleri yazmamız

yeterli olacaktır.

Bir sınıf içerisinde daha önce görmüs oldugumuz metod tanımlamalarından farklı

metod sekli daha vardır. Bir metod soyut olarak yazılacaksa metod prototipinde public, private ya da protected

anahtar sözcügünden sonra “abstract” anahtar sözcügü yazılmadır. Ayrıca sınıf içerisinde bu sekilde prototipi

yazılan soyut metodun içerisine de hiçbirsey yazılmaz. Örnegin:

public abstract String ismiVer();

Yukarıdaki örnekte bir soyut metod bildirimi yapılmıs ve içerisi yazılmadan noktalı virgül ile bildirim tamalanmıstır.

1kinci kural olarak da içerisinde soyut metod barındıran bir sınıftan türetilen yeni bir sınıf, bu soyut metodun

içerisini kendi içinde yazmak zorundadır. Aksi takdirde türetme islemi hatalı sayılır. Sonuç olarak:

Soyut bir metodun temel sınıf içerisinde sadece prototipi yazılır.

Bu temel sınıftan türeyen bir sınıf sadece prototipi yazımıs olan bu soyut metodu kendi içerisinde tamamen

yazmak zorundadır.

1çerisinde soyut metod barındıran sınıflara soyut sınıf denilir ve böyle bir sınıfın bildiriminin basına Class

anahtar sözcügünden önce “abstract” yazılmak zorundadır.

Peki ama soyut metodların bu kullanımı ne ise yarar?

Sınıf bildirimi içerisinde yazılmıs olan soyut metodların nasıl çalısacagı, ancak bu sınıftan türetilen sınıflar içerisinde

yazılmaktadır. Temel sınıf içerisinde bu metodların nasıl isleyeceklerinden ziyade geri dönüs degerlerinin ve

parametrelerinin ne oldukları yazılır. O halde içerisinde soyut metodlar barındıran bir sınıftan türetme yapıldıgında,

ondan türeyen her sınıf içerisinde bu metodun yeniden yazılması gerekecek ve dolayısıyla bu sınıftan türeyen tüm

sınıfların böyle bir metod barındıracagı garanti edilmis olacaktır.

Böylece birçok kisinin görev aldıgı büyük bir projede yazılması kesinlikle gerekli olan ancak sadece isleyisi

degisebilen metodları temel bir sınıf içerisinde soyut olarak tanımlarsak ve yazılacak tüm yeni sınıfların da bu temel

sınıftan türetilerek yazılmasını sart kosarsak, herhangi bir kontrole gerek kalmaksızın yazılması zorunlu olan bu

metodların birbirinden bagımsız kisilerin tasarlayacagı tüm sınıflarda kesinlikle yer alacagından emin olabiliriz. Bu

durum asagıdaki sekilde de özetlenmistir

Böylece kavramsal olarak soyut metod ve soyut sınıfın ne oldugunu yeterince

yukarıda okuduklarımız pekistiren bir örnek yapalım. Bu örnekte soyut metod kullanımını içeridigi gibi aslında

türetme isleminin de güzel bir kullanımını göstermektedir.

Örnegimizde en temel olarak “Sekil” adında bir sınıf yeralmaktadır. Bu sınıf tüm geometrik sekillerin temelini teskil

ettiginden içerisinde yer alacak olan alanHesapla, cevreHesapla, kenarSayisiVer gibi metodların yazılması

anlamsızdır. Ancak bir geometrik sekil bu metodlara sahip olmalıdır. O halde biz “Sekil” sınıfınının bu metodlarını

soyut olarak tasarlayıp gerekli olan geometrik sekile iliskin bir sınıfı da bu sınftan türetirsek, soyut olan bu metodları

ilgili seklin özelliklerine göre yeniden yazabiliriz. Bu düsünceyle de örnegimizde “Sekil” sınıfından türeyen “Kare”,

“Ucgen” ve “Daire” sınıflarını da yazmaktayız:

Java ile Programlama

Arayüzler

Arayüzler aslında teknik olarak bir sınfın ne yapması gerektigini anlatmaktadır. Yani aynen soyut sınıflarda oldugu

gibi, temel bir sınıfın operasyonlarını tanımlamak amacıyla tüm metodlarının soyut olması soncunda arayüzler

meydana gelir.

Bu bakıs açısıyla ir arayüzün aslında tam anlamıyla bir sınıf olmaktan ziyade “yapılması gerkenler listesi” olarak

tanımlanması da mümkündür.

Nesneler arasındaki büyüklük küçüklük kriterinin önemi

Bunu su temel örnekler açıklayabiliriz. Daha önceki derslerimizde de ögrendigimiz gibi belirli nesneler üzerinde bir

sıraya dizme islemi yapılabilmesi için bu nesnlerim birbirleri arasında bir büyüklük-küçüklük iliskisinin tanımlı olması

gerekir. 1lkel veri tipleri için bu iliski zaten “>” ya da “<” operatörü ile kolaylıkla anlasılabilmektedir. Ancak bizim

yarattıgımız nesneler üzerinde (mesela Student ya da Dortgen sınıfları gibi) dogal bir büyüklük küçüklük kriteri

yoktur. Çünkü java açısından bu nesnelerin mantıksal olarak ne ise yaradıkları bilinemez. O halde biz büyklük

kriterini de içercek compareTo ismli bazı metodlar yazarız. Bu metodlar yardımıyla da bu kriteri kullanıur ve böylece

nesneleri sıralayabiliriz.

Comparable Arayüzü

1ste bu islem için java programlama dili içerisinde “Comparable” adında bir arayüz tanımlanmıstır.

public interface Comparable {

int compareTo(Object other);

}

Bu arayüz bize kendisinde türetilen bir sınıfın içerisinde bu compareTo metodunun zorunlu olarak yazılması

gerektigini anlatır. Ayrıca bir nesne eger bu arayüzden türetilirse, yine java içerisinde zaten öntanımlı olarak

kullanılan “Arrays” isimli sınıfın sort metodu yardımıyla bu sınıf türünden nesneler de otomatik olarak

sıralanabilecektir.

NOT:

bir sınıftır.

Comparable’dan türetme neden gerekli?

Peki ama biz zaten kendimiz istedigimiz bir sınıf içerisine compareTo metodu ekleyebileceksek o halde neden

sınfımızı Comparable nesnesinden türetelim ki??

Bunun nedeni “Arrays.sort” metodu içerisinde bir yerlerde a[i].compareTo(a[j]) gibi bir kod yazmaktadır. O halde

bu metoda gonderilen bir nesne dizisinin içerindeki her nesnenin comparTo metodu oldugu garanti edilmelidir.

Bunun da tek yolu sizin gonderdiginiz ve sıralanmasını istediginiz bu nesnelerin Comparable arayüzünden türetilmis

olmalarıdır.

Arayüzlerin Özellikleri

1) Arayüzler ile instance yaratılamaz

Teknik olarak aryüzleri içerisinde hiçbir metod yazılmadıgından bir aryüz nesnesini dogrudan yaratmak hataya

neden olur. Yani asagıdaki gibi bir kod geçersizdir:

Comparable x = new Comparable();

2) Arayüzler içerisndeki degiskenler sabit olmalıdır

Arayüzlerde yaratılan metodların içerinde yerlestirilen degiskenler her zman public static final kabul edilirler.

3) Birden fazla arayüzden türetme

Nir ınıf normalde en fazla bir sınıf türetebilir. Ancak birde fazla sınıftan türetme yapmamın tek yolu kullanılan teme

sınıflardan sadece birtanesinin sınıf, digerlerinin ise arayüz olması gerekir. Örnegin Comparable gibi bir de Movable

isimli bir arayüzün varlıgını kabul edersek, Student isimli bir sınıf Person isimli bir sınıftan türetme ve Comparable ile

Movable isimli arayzlerden de implement tyaparak aslında birden fazla sınıftan türetme yapabilir:

class Student extends Person implements Comparable, Moveable

public int compareTo(Object obj2) {

}

public void move(double x, double y) {

}

}

}

class Person {

}

}

Hata Yakalama (Exception Handling)

Java’da error adı verilen hatalar meydana geldiginde program akısı dogrudan sonlandırılmaktadır. Ancak bazen,

aslında derleme sırasında hata oldugu belli olmayan ancak çalısma zamanı sırasında yapılan hatalı islemler

neticesinde ortaya çıkan hatalar olabilir.

Çalısma zamanı sırasında meydana gelen hatalar

Mesela program içerisinde “x/a” gibi bir ifade oldugunu varsayalım. Bu durumda program derlenirken bu ifade

hatalı olarak algılanmaz. Ancak program çalısırken a degiskenine 0 degeri atanırsa bu ifade matematiksel olarak

sonsuz anlamına gelir ve bu da baska bir hata üretilmesine neden olur.

1ste bu tur hatalara error degil “exception” adı verilir.

Exception ele alınabilir ama error alınamaz

Exception ile error kavramları saece tanım olarak degil, nitelik olarak da farklıdır. Çünkü java da excepton’lar

runtime sırasında yakalanabilir. Ancak error oldugu zaman bu durum kesinlikle programın çalısmasını sonlandırır.

Exception ların ele alınması

Exception, programda bazı özel bloklar içerisinde ele alınır. Programın çalısması sırasında bir exception olursa

hemen o anda bir “Exception” nesnesi yaratılır. Bu nesne, aslında Exception nesnesinden türemis bir baska

exception da olabilir. Ama neticede en temel anlamda bir “Exception” nesnesi yaratılır.

Çalısma zamanı sırasında üretilen exception’lar ele alınabilir

Daha sonra eger programcı tercih etmisse bu exception nesnesi özel bir blok tarafından yakalanır ve yine aynı

bloklar içerisinde programcının istedigi kodları çalıstırır.

try {

openFile();

readFile();

closeFile();

}

catch(Exception e) {

doSomething();

}

Yukarıda da görüldügü gibi aslında exception ların yakalanma prensibi, exception olma ihtimali olan satırların bir try

blogu içerisinde yazılması ve meydana gelen exception’ı yakalayacak bir catch blgunun da hemen bu try bloklarının

sonuna yerlestirilmesi seklindedir.

Exception’lar Es Geçilemez

Exceptionlar uretildigi anda programcı tarafından ele alınmazsa program exception ile birlikte sonlanır. Bu nedenle

bir exception ele alınmadan program akısına devam edilemez.

Kontrol edilen ve Kontrol Edilmeyen Exception lar

Aslında Exception lar kontrol edilen ve kontrol edilmeyen olmak uzere 2’ye ayrılır.

Çalısma zamanı sırasında meydana gelen bazı exceptionların kontrol edilmesi pogramcının istegine baglıdır. Bu tip

exception lar “RunTimeException” nesnesinden türemislerdir. Programcı bu exceptionları ele almazsa program bir

hata mesajı ile sonlanır. Ya da programcının ele aldıgı sekilde akısına devam ederi. (dizi indeksinin geçilmesi, sıfıra

bölme hatası )

Kontrol edilen exceptionların ele alınması prgoramcının istegine baglı degildir. Bu exceptionların ele alınması

zorunludur. Mesela bir sodyanın açılması okunması ya da kapanması islemleri kontrol edien exceptionlardır. Bu tür

exceptionlar programcının hatasından kaynaklanmayan exception lardır (Bozuk bir dosya ya da URL)

NOT:

Exception ların Yakalanması

Asagıdaki örnekte kulanıcıdan bir sayı girmesi istenecektir

import javax.swing.*;

public class HataYakalama {

public static void main(String[] args) {

String str = JOptionPane.showInputDialog(null, "Bir sayı

giriniz");

try {

int n = Integer.parseInt(str);

System.out.println("Girilen sayi: " + n);

}

catch(NumberFormatException e) {

e.printStackTrace();

System.exit(0);

}

}

}

Eger kullanıcı bir sayı yerine yanlısklıkla bir metin girerse, o zaman bu metinin Integer.parseInt metodu yardımıyla

sayıya donusturulmesi bir runtime exception uretilmesine neden olur. Ve program akısı hemen RunTimeExeption

ureterek catch bloguna atlar. Boylece hata yakalanmıs olur. Eger hata yaklalanmaz ise JVM u hatayı kendisi yakalar

ve ekrana asagıdaki gibi bir exception mesajı gondererk program akısını sonlandırır:

java.lang.NumberFormatException: For input string: "gdg"

at java.lang.NumberFormatException.forInputString(Unknown Source)

at java.lang.Integer.parseInt(Unknown Source)

at java.lang.Integer.parseInt(Unknown Source)

at HataYakalama.main(HataYakalama.java:9)

import javax.swing.*;

public class HataYakalama {

public static void main(String[] args) {

int n;

String str = JOptionPane.showInputDialog(null, "Bir sayı giriniz");

try {

n = Integer.parseInt(str);

}

catch(NumberFormatException e) {

JOptionPane.showMessageDialog(null, "Exception yakalandı");

n = Integer.parseInt(JOptionPane.showInputDialog(null, "Giris

yanlis tekrar deneyiniz:"));

}

System.out.println("Girilen sayi: " + n);

}

}

KISACA REKURSIF METODLAR

Cevap:

import javax.swing.*;

public class HataYakalama {

public static int sayiAl(String onEk) {

JOptionPane.showMessageDialog(null, "DEBUG: metoddayiz");

int n = -1;

String str = JOptionPane.showInputDialog(null, onEk + " Bir sayı

giriniz");

try {

JOptionPane.showMessageDialog(null, "DEBUG: try blogundayiz");

n = Integer.parseInt(str);

}

catch(NumberFormatException e) {

JOptionPane.showMessageDialog(null, "Exception yakalandı");

onEk = "Giris yanlis tekrar tekar deneyiniz.\n";

return sayiAl(onEk);

}

return n;

}

public static void main(String[] args) {

System.out.println("Girilen sayi: " + sayiAl(""));

System.exit(0);

}

}

Exception Ureten Metdolar

Su ana kadar ogrendiklerimizden görüyoruz ki Java’da bazı satırlar exception olusmasına neden olabilir. O halde

bazı metodlar da exception uretilmesine neden olabilirler.

Bir metod eger exception uretiyorsa bu metodu kullandıgımız satırında try blogu içerisinde yazılması gerekir. O

halde Java’da bazı hazır metodları incelerken bunların exception uretip uretmediklerine de bakılmalıdır.

Eger biz de yazdıgımız metodların exception uetmelerini istiyorsak metod prototipinin sonuna throws anahtar

sözcügü ve devamında da üretilecek exception’ın tipini yazarız.

public String getValue(int index) throws IndexOutOfBoundsException {

f(index == null || index >= values.length) {

throw new IndexOutOfBoundsException();

}

}

Checked ya da Unchecked Exception Nasıl Yaratılır

Eger exception gonderen method “Exception” ya da ondan tureyen bir exception’ı throw ediyorsa bu exceptionlar

checked sayilir. O halde bu metodu kullanan kisi metodu try bloklari icerisinde yazman zorudadir.

Ancak gonderilen exception “RunTimeException” ya da ondan turemis bir exception ise metodumuz unchecked

exception uretiyor demektir. O halde bu metodu try bloklari icerisinde yazmak zorunda degiliz.

finally Blok Yapısı

finally blok yapısı catch bloklarının sonuna eklenir Bir exception yakalansa da yakalanmasa da program akısı finally

blokları içerisine yönlenecektir. Asagıdaki örnegi incelyiniz:

try {

code a;

}

catch(IOException e) {

code b;

}

finally {

code c;

}

1. Burada code a; hiçbir exception üretmeyebilir. Bu durumda “code a” çalıstıktan sonra “code c” çalısacaktır.

Program akısı daha sonra finally blogu altındaki kodları çalıstırmaya devam eder.

2. Bu durumda “code a” IOException üretir ve bu nedenle “code b” çlaısır. Daha sonra yine “code c”

çalısacaktır. Eger catch blogu herhangi bir exception üretmez ise program akısı yine try bloklarının bittigi

yerden devam edecektir.

3. try blokları içerisinde catch içerisinde yakalanmayan bir exception üretilirse o zaman “code a” ve “code c”

çalıstıktan sonra exception kullanıcıya gönderilir.

Asagıdaki örnegi degisik senaryolar için deneyiniz:

package derstekiornekler;

public class ExceptionTest {

public static void main(String[] args) {

try {

System.out.println("Satir 1");

throw new Exception();

}

catch(Exception e) {

System.out.println("Catch blogu icindeyiz");

}

finally {

System.out.println("Finally blogu icindeyiz.");

}

System.out.println("Catch blogu disindayiz");

}

}

NOT:

Java ile Programlama

Bölüm 8:

Java'da Dosya slemlerine Giris

Programcılıgın vazgeçilmez islerinden birisi de disk üzerindeki dosyalarla çalısmaktır. Buraya kadar konuları

ögrenmek amacıyla kullanmıs oldugumuz örneklerde aslında veriler sadece o anda çalısan program içerisinde ele

alınabiliyordu.

Profosyonel anlamda yazılan programların çogu kullanıcının ihtiyaç duyacagı verileri dosyalar üzerinde saklamakta

ve gerektiginde bu dosyalardan verileri okuyarak ya da yeni verileri dosyalara yazarak isleyislerini sürdürmektedir.

Bu nedenle programcılıkta amaç ne olursa olsun dosyalar üzerinde islem yapma ihtiyacı mutlaka karsınıza

çıkacaktır.

File Sınıfı

Java'da dosya islemlerine iliskin ilk olarak “File” isimli sınıfın kullanımını inceleyerek baslayalım. Bu sınıf disk

üzerinde yer alan bir dosyayı program içerisinde de bir nesne haline getirerek programcının dosya üzerinde islem

yapabilmesini saglamaktadır. Sınıfın baslangıç fonksiyonu temel olarak bir dosyanın yol (path) bilgisini alarak File

nesnesini yaratır. Örnegin:

...

File dosya1 = new File(“Dosya.txt”);

File dosya2 = new File(“c:\ornekler\dosya.txt”);

File dosya3 = new File(“/home/Academytech/Dosyam.txt”)

...

Tabi yukarıda verilen bu örneklerde, “File” sınıfının baslangıç fonksiyonuna parametre olarak verilen bu yolların

diskte de düzgün bir sekilde mevcut olması gerekmektedir. Yani bulundugumuz dizinde Dosya.txt ya da

“c:\ornekler\” dizini altında bir “dosya.txt” ya da “/home/Academytech/” dizini içerisinde bir “Dosyam.tx”t dosyası

bulunmalıdır. Aksi takdirde “dosya1”, “dosya2” ya da “dosya3” ismi ile temsil edilen “File” nesneleri düzgün bir

sekilde yaratılamayacaktır.

Not:

sözcügü ile programa dahil edilmesi gerekmektedir.

Asagıdaki örnekte temel olarak “File” sınıfı ile dosya islemlerinin ele alınmasına iliskin bir program yazılmaktadır.

Örnegimizde temel bir File nesnesi yaratarak aslında diskte yer alan bir dosya bilgilerinin nasıl ele alındıgını

görmekteyiz. Bu örnekte benim girmis oldugum “/tmp/dosya.txt” yolu aslında kendi sistemimdeki bir dosyanın

yerini temsil ettiginden siz kendi örneginizi yazarken kendi diskinizdeki yolu yazmaya dikkat ediniz. Program

çalıstırıldıgında “InputDialog” nesnesi ile asagıdaki resimde gösterildigi gibi sizden bir dosya yolu istenecektir:

Girdiginiz bu yol bilgisi programımızın 8. satırında yazıldıgı sekilde “dosyaYolu” degiskenine aktarılmakta ve daha

sonra da 11. satırda oldugu gibi bu degisken yardımı ile nesne yaratılmaktadır. Bu nesne yardımıyla kullanılabilecek

birkaç metodu 14, 15 ve 16. satırlarda görmekteyiz.

System.out.println metodu

Bu metodu daha önceki derslerimizden gayet iyi biliyoruz. Aslında bu metodun System paketi içerisindeki out

sınıfının println metodu olarak düslünebilirsiniz. Ancak gerçekte durum bu degildir. Buradaki durumun anlasılması,

java’da dosyalar konusunu kavramak için önemli bir baslangıç olacaktır. O halde ilk önce bu durumu inceleyelim.

out System sınıfı içerisinde statik bir nesnedir (instance)

Aslında “out”, System sınıfı içerisinde yer alan static bir instance’dır. Bu yüzden programcı bu instance’a dogrudan

erisebilir. Ayrıca bu nesne bir “PrintStream” nesnesidir.

Stream Kavramı:

Programcılık açısından dosya islemlerini anlamanın en iyi yolu Stream kavramını bilmekle baslar. Stream denilen

nesne aslında bir seyin okunması ya da yazılması için bir soyutlamadır (abstraction). Bu soyutlama gereklidir, çünkü

okunacak ya da yazılacak bilginin tipi her zaman degisebilir. Yani okunan ya da yazılan bilgi bir uygulamada

manyetik karttan yapılabilecegi gibi baska bir uygulamada da diskten yapılabilir.

Burada Stream aslında kelime anlamı olarak akıs anlamına gelir ve programcılık anlamında “bilgi akısını” ifade eder.

Bu yaklasıma göre okuacak bilgi stream den okunur ve yazılacak bilgi de stream e yazılır. Böylece bilginin tipi ne

olursa olsun okunma ve yazılma asamasında stream üzerinde ortak bir bilgi akısı saglanacaktır. Bu ifadeyi

kullandıgımız örneklerle daha iyi pekistirecegimizi düsünüyorum.

Stream kullanımı ile bilgi ne olursa olsun okuma ya da yazma sekli hep aynıdır:

stream aç

daha fazla bilgi oldukça (ya da yazdıkça)

bilgi oku (ya da yaz)

stream kapat

O

sınıf olan PrintStream sınıfı türündendir. Aslında bizim ekrana bilgi gönderme seklimiz her isletim sisteminde

farklıdır. Ancak JVM içerisinde platforma göre implement edilmis olan bu PrintStream nesnesi bize bu soyutlamayı

saglar ve böylece içerisinde yer alan println metodunu platform bagımsız olarak kullanabiliriz.

flush Kavramı

Aslında yazılması ya da okunması istenen bilgiler yukarıda nalatılan stream’ler içerisine ve oradan da yazılması ya

da okunması istenen yere gönderilir. Ancak bir stream’in kendi içini ne zaman bosaltacagı (yani istenen bilgiyi

gerekli yere ne zaman ulastıracagı) belli degildir. Bu isleme “flush” denilir. Programcı isterse bunu kendisi de

yapabilir.

InputStream Nesnesi

Yine System sınıfı içerisinde yer alan ve out nesnesine benzeyen bir nesne daha vardır. Bu nesnenin adı “in” ve türü

de InputStream sınıfı türündendir. Bu nesne de konsoldan bir bayte lık bilgi okuma yetenegine sahiptir. Ancak

okuma yetenegi bu kadarla sınırlıdır. Bu nesneyi “debug” islemleri için kullanabiliriz

System.

System.

}

}

}

}

}

Standart Giris ve Çıkıs

Java'da yukarıda bahsettigimiz bu stream kavramı ile standart giris ve standart çıkısa yazma ve okuma yapmak

mümkün olacaktır. Aslında standart giris-çıkısı komut satırı ortamı olarak düsünebilirsiniz.

Fazla detaya inmeden söylemek gerekirse standart çıkısa yazma yapma islemi aslında daha önceden bildigimiz

Sytem.out.print(“yazi”) metodu ile yapılmaktadır. Arka planda aslında “System” isimli sınıfın içerisinde tanımlı

“PrintStream” türünden yaratılmıs ve adı “out” olan static bir degiskeni kullanmaktayız.

BufferedReader <-- InputStreamReader <-- InputStream

Aynı sekilde standart giristen program içerisine okuma yapmak da mümkündür. Bu islem için yetenekleri sınırlı olan

System.in nesnesine InputStream nesnesi ve BufferedReader nesnesi yardımıyla yetenek kazandıracak ve en son

BufferedReader nesnesinin readLine metodu ile okuma yapacagız:

Örnegimizde 7. satırda BufferedReader nesnesi yaratılmıstır. Bu nesnenin baslangıç fonksiyonuna parametre olarak

bir “InputStream” nesnesi hemen orada yaratılmakta ve gönderilmektedir. “InputStream” nesnesi okuma yapmak

amacıyla kullanılır. Bu nesnenin de baslangıç fonksiyonuna, okumanın yapılacagı yer olan standart giris parametre

olarak verildiginden bu stream standart girise yönlendirilmis, yani standart giristen okuma yapacak sekilde

hazırlanmıstır.

Program çalıstırılırken asagıdaki resimde görüldügü gibi komut satırı ortamında bizden birseyler girmemizi isteyecek

ve bu bilgileri daha sonra ekrana yazacaktır. Bilginin standart giristen alınmasını saglayan komut da 14. satırda

görülmektedir. Aslında bu komut soyutlanmıs “BufferedReader” nesnesinin “readLine” metodur ve bu nesne

yukarıda da anlatmıs oldugum gibi standart girise yönlendirlmistir

Text Dosyalarının Okunması ve Yazılması:

(FileReader ve FileWriter sınıfları)

Yukarıda bahsettigimiz stream kavramı sayesinde standart giristen yapılan okuma aynı sekilde bir text dosyasına

yönlendirilirse, o zaman dosyadan okuma yapmak da mümkün olacaktır. Aynı sekilde standart çıkısa gönderilen bir

bilgi text dosyasına yönlendirilmis bir stream e gönderilirse o zaman da text dosyasına yazma islemi yapmıs oluruz.

1ste burada da stream soyutlamasının kolaylıgını görmekteyiz. Asagıdaki örnekte, bahsettigimiz bu dosyadan okuma

islemini

String str;

String fileName =

BufferedWriter out =

out.write(

out.write(

out.write(

out.close();

BufferedReader in =

ne

System.

}

in.close();

}

}

}

NOT:

yardımıyla dosyaya text yazmak ya da dosyadan text okumak mümkündür. Yani bu soyutlama zaten yapılmıstır.

Ancak Buffered sınıfları yardımıyla bu okuma ve yazma islemi daha büyük verier için daha verimli bir sekilde

yapılmaktadır.

Veri Dosyalarını Okunması ve Yazılması:

(DataOutputStream, DataInputStream)

Veri dosyaları önceki örnekte kullanmıs oldugumuz text dosyalarından biraz daha farklıdır. Bildigimiz gibi program

yazarken degiskenlerin yaratılması sırasında onların türlerini de belirtmek zorundayız. Daha sonra da bu

degiskenlere verilen degerleri de aynı türden vermek zorundayız.

1ste veri dosyalarında saklanan bilgiler de bu sekilde tür bilgisi ile birlikte sanki hafızada(ram’de) saklanıyormus gibi

saklanmaktadır. Yani text dosyalarında oldugu gibi verilerin tamamı string seklinde saklanmaz. Bu nedenle de veri

dosyalarını bir text editörü ile açıp okumaya kalktıgınızda bilgilerin anlasılır olmadıgını görürüz. Asagıdaki örnekte bir

veri dosyasına birtakım bilgiler yazılmakta ve daha sonra da aynı dosyadan bu bilgiler okunmaktadır.

Aslında buradaki mantık yine yukarıdaki anlattıklarımıza benzer. Yukarıda bir dosyaya text yazmadan önce bir

FileWriter stream açarak dosyaya giden bir yol açmıs olduk. Ancak bu yola verileri dha verimli yüklemek için yolun

ucuna bir BuffereWriter tüneli ekleyerek onun üzerinden dosyaya gönderdik. Ancak bu sekilde ancak text verileri

dosyaya yazabiliyoruz.

Dosyaya verileri tür bilgisi ile gönderebilmek için önce dosyaya ulasan bir FileOutputStream tüneli açıyoruz. Daha

sonra bu tünelin ucuna BufferedOutputStream ve onun da ucuna DataOutputStream ekleyerek verileri tür

bilgileriyle birlikte dosyaya gönderebiliyoruz.

Yukarıdaki örnegimizde bu sefer veri yazma islemi yapmaktayız. Bu nedenle stream nesnemizi 9. satırda oldugu gibi

veri yazabilecek ve 16. satırda oldugu gibi veri okuyabilecek sekilde hazırlamaktayız. 12. ve 13. satırlarda sırayla

yazılan double ve int veriler okunurken de yazıldıkları sıra ile okunurlar. Veri yazma islemini program içerisindeki bir

degiskenin hafızada degil de dosyada saklanması gibi düsüebiliriz. Çünkü bazen verileri bu sekilde tür bilgileriyle

saklamak ve daha sonra da ele almak gerekmektedir. Bu islemi bir text dosyasıyla yapmaya kalkarsak verilerin

sadece görüntülerini saklamıs oluruz. Bu durumda verilerin daha sonra tekrar okunması sırasında tür bilgileri

kaybolacagından örnegimizdeki 19. 20. satırdakilere benzer atamalar mümkün olmayacaktır

throws Kullanımının getirdigi kolaylık

Ayrıca dikkat edersek bu örnegimizde “try” ve “catch” bloklarını kullanmak yerine üretilecek “Exception” bilgisini

daha farklı ele aldık. Eger bir metodun içerisinde “Exception” üretilme ihtimali varsa örnegimizde oldugu gibi

metodun prototipine “throws” anahtar sözcügünden sonra üretilecek Exception yazılırsa, metod içerisinde bu

Exception'ı üretebilecek satırları “try” bloklarında ele almaya gerek kalmaz. Buna iliskin detaylı bilgileri bir önceki

dersimizde bulabilirsiniz.

Özetleyecek Olursak

Text Veri ---> BufferedWriter ---> FileWriter ---> DOSYA

Program <--- BufferedReader <--- FileReader <--- (TextVeri) DOSYA

Hep Sırayla Okuduk, Sırayla Yazdık Ama..

Dersimizin buraya kadar olan kısmında stream yaratarak dosyalara yazma ve okuma islemlerini gördük. Ancak bu

yazma-okuma islemlerini hep sırayla yaptık. Yani bir veriyi okumadan, ondan daha sonra gelen veriyi okumak

mümkün degildi. Yine aynı sekilde ilk veriyi yazmadan ikinci veriyi yazmak yukarıda gösterdigimiz stream ler ile

olanaksızdı. Böyle bir islem yapmak için daha farklı bir stream kullanmamız gerekmektedir. Dosyalara bu sekilde

erisim istegine teknik olarak “rastgele erisim” denilir. Simdi bunu inceleyelim.

Dosyalara Rastgele Erisim slemi

Bir dosyaya rastgele erisim yapılabilmesi için öncelikle “RandomAccessFile” sınıfı türünden bir degisken yaratmak

gerekir. Bu degisken yaratılırken 1. parametre olarak erisimin yapılacagı dosya ve ikinci parametre olarak da erisim

hangi modda yapılacagı bilgisi verilmelidir.

Örnegin “CikisDosyasi.dat” dosyamıza okunabilir ve yazılabilir modda erismek istiyorsak nesneyi su sekilde

yaratmamız gerekir:

RandomAccessFile myFile = new RandomAccessFile(“CikisDosyasi.dat”, "rw");

Dosyaya rasgele erisim için kullanılabilecek en genel modlar su sekilde özetlenebilir:

r:

yapılırsa IOException üretilir.

rw:

Asagıdaki örnekte bir dosya içerisine veriler yazıldıktan sonra rastgele erisilerek okunmaktadır. Burada okuma islemi

sırayla yapılmamaktadır.

Örnegimizde 8. satırda okuma-yazma modunda açılan dosyamıza bazı double degerler ekliyoruz. Bu ekleme islemini

bir döngü ile yapıyoruz. Kullanıcı 13. satırdaki sorgu geregi “-1” girmedigi sürece girilen bilgiler önce double türüne

dönüstürülüyor ve daha sonra da dosyaya yazılıyor. Bu dönüstürmenin nedeninin, girilen bilgini hep string

olmasından dolayı oldugunu önceden hatırlayınız.

Daha sonra 21. satırda kullanılan “seek()” metodu sayesinde dosya içerisinde rastgele bir pozisyona gidiyoruz. Bu

pozisyon, seek metoduna asıl pozisyon * 8 olarak gönderiliyor. 1lk pozisyon “0” oldugu için kullanıcının istedigi

pozisyondan 1 çıkartarak seek() metoduna gönderiyoruz. Böylece kullanıcı gerçekten istedigi sayıyı elde edebiliyor.

NOT:

degisir. Mesela int veriler icin bu deger 4, byte veriler icin ise 1 dir. Bu bilgiler dokumantasyonda yer alan write

metodlarinda mevcuttur.

Object Serialization Hakkında

String

ObjectReaderWriter orw =

}

ObjectReaderWriter() {

FileDialog fd =

FileDialog.

fd.show();

ObjectOutputStream outStream =

MySerialObject serialObject1 =

MySerialObject serialObject2 =