Bu hafta Java programlama dilinde kullanılan çok
ilginç bir konuyu inceledim. Sınıflar içerisinde sınıfların tanımlanmasından
tutunda, bir metod içinde sınıf tanımlanması gibi ilginç kavramları bünyesinde
barındıran bir konuydu bu. Inner Class (Dahili Sınıflar) kavramı. Bu kahve
molası açıkçası çok eğlenceli geçeceğe benziyor. Programatik olarak yani. Yoksa
dışarıdan birisi bana bakıpta, yazdığım örnek kodlardan sonra hafifçe güldüğümü
görse, sanıyorum ki bu adam keçileri kaçırmış der. Aslında hepimiz öyle
değilmiyiz? Programcılar doğaları gereği hafif uçuk adamlar olmak zorundadırlar.
Eğer kodlara bakıp kendi kendinize gülmek gibi bir hobiniz yoksa, hemen bir tane
edinmenizi tavsiye ederim. Bir programcının karizmasını gerçekten önemli ölçüde
arttıyor. Tabi gülmek derken sinsi sinsi gülüp hafifçede Platinyum Kadir Bey
havası katacaksınız işin içine.
Neyse muhabbeti bırakıp iş yapmak sanırım daha
hayırlı olucaktır. Nedir bu dahili sınıflar? Ne iş yaparlar? Neden
kullanılırlar? Bu sorular içerisinde en zor olanı belkide dahili sınıflara neden
ihtiyaç duyduğumuzdur. Doğruyu söylemek gerekirse, bu ihtiyacı anlayabilmek
için, kaynaklarda kullanılan örnekleri bir hayli kurcalamam gerekti. İlk başta
dahili sınıfların, sınıfları normal kullanım alanları haricinde farklı
bölgelerde kullanmak için var olduklarını söyleyebilirim. Her zaman için
uygulamalarımda şu ana kadar, sınıfları hep ayrı birer veri yapısı olarak
tanımladım. Ancak aşağıdaki şekilde görülen dahili sınıf tipleri ile, bir sınıfı
başka bir sınıf bloğu içinde tanımlamak, bir metod bloğu içinde tanımlamak
mümkün.
Özetle dahili sınıfların, sınıf tanımlamaları
içerisinde tanımlanan sınıflar olarak düşünebiliriz. İlk önce üye sınıfları
incelemeye karar verdim. Çünkü kaynaklar özellikle bu konuya oldukça fazla yer
ayırmıştı. Üye sınıfları anlayabilmenin en iyi yolu basit bir örneğe
uygulamaktan geçiyordu. Yapabileceğim en basit örnek, bir sınıf tanımlaması
içine bir kaç sınıf tanımlaması eklemekti. Bu amaçla aşağıdaki gibi bir sınıf
tanımlaması oluşturdum.
public class DahiliSiniflar
{
class UyeSinif_1
{
}
class UyeSinif_2
{
}
class UyeSinif_3
{
}
public static void main(String[] args)
{
}
} |
Yukarıdaki uygulamayı derlediğimde herhangibir
hata mesajı ile karşılaşmadım. Yani DahiliSiniflar sınıfım içindeki diğer
sınıflar için derleyici bana ses çıkartmamıştı. İşte burada yaptığım iş, aslında
bir sınıf içerisine, bu sınıfın kapsüllediği Üye Sınıf (Member Class) 'ları
eklemekti. Bir başka deyişle aslında aşağıda şekilsel olarak ifade edebildiğimi
düşündüğüm işlemi gerçekleştirmiştim.
Her şey iyiydi güzeldi de, acaba bu üye sınıfları
nasıl kullanabilirdim. Öncelikle, üye sınıflara iş yapacak metodlar
eklemeliydim. Bu amaçla kodları aşağıdaki gibi düzenledim. İşin kritik noktası,
üye sınıf nesnelerinin, bu üye sınıfları içeren sınıfa ait main metodu
içerisinde nasıl örneklendirildikleriydi.
public class DahiliSiniflar
{
class UyeSinif_1
{
void Yaz()
{
System.out.println("UyeSinif_1 Yaz Metodu...");
}
}
class UyeSinif_2
{
void
Alan(double en, double boy)
{
double alan=en*boy;
System.out.println("Alan "+alan);
}
}
class UyeSinif_3
{
int Topla(int
baslangic, int bitis)
{
int toplamDeger=0;
for(int i=baslangic;i<=bitis;i++)
{
toplamDeger+=i;
}
return toplamDeger;
}
}
public static void main(String[] args)
{
DahiliSiniflar.UyeSinif_1 uye1=new
DahiliSiniflar().new UyeSinif_1();
uye1.Yaz();
DahiliSiniflar.UyeSinif_2 uye2=new
DahiliSiniflar().new UyeSinif_2();
uye2.Alan(5,10);
DahiliSiniflar.UyeSinif_3 uye3=new
DahiliSiniflar().new UyeSinif_3();
int sonuc=uye3.Topla(5,10);
System.out.println("Aralik degerleri
toplami "+sonuc);
}
} |
Burada önemli olan nokta, üye sınıflara ait bir
nesne örneği yaratabilmek için, önce üye sınıfı kapsayan sınıfa ait bir nesnenin
oluşturulmak zorunda olduğu. Yani,
| DahiliSiniflar.UyeSinif_1 uye1=new
DahiliSiniflar().new UyeSinif_1(); |
satırları ile, önce DahiliSiniflar sınıfından bir
nesne oluşturuluyor ve ardından bu sınıfın üye sınıfı olan dahili UyeSinif_1
sınıfına ait bir nesne örneği oluşturuluyor. Evet söz dizimi oldukça garip, bunu
bende kabul ediyorum. Ancak, olayı mantık boyutları çerçevesinde son derece
güzel açıklıyor. Tabi burada kafama takılan en önemli sorun şu. Her üye sınıf
nesnesi örneği için, üye sınıfı içeren sınıf örneğini oluşturmak zorundamıyım.
Bu durumda n kadar üye sınıf içeren bir sınıf uygulamasında, her bir üye sınıf
için bellekte gereksiz yer işgali olmıyacakmı? Yazık değilmi güzelim sistem
kaynaklarını harcamaya?
Neyseki bu durumun çözümünü kısa sürede
kaynaklardan tedarik ettim. Çözüm ilk başta, üye sınıfları içeren sınıfa ait bir
nesne örneğini oluşturmak ve daha sonra üye sınıflara ait nesne örnekleri için,
oluşturulan bu sınıf örneğinin referansını kullanmaktı. Yani şu şekilde,
public static void main(String[] args)
{
DahiliSiniflar ds=new DahiliSiniflar();
DahiliSiniflar.UyeSinif_1 uye1=ds.new UyeSinif_1();
uye1.Yaz();
DahiliSiniflar.UyeSinif_2 uye2=ds.new UyeSinif_2();
uye2.Alan(5,10);
DahiliSiniflar.UyeSinif_3 uye3=ds.new UyeSinif_3();
int sonuc=uye3.Topla(5,10);
System.out.println("Aralik degerleri toplami "+sonuc);
} |
Şimdi kafamı kurcalayan nokta, üye sınıf
yapıcıları ile, üye sınıfları içeren sınıf yapıcısı arasındaki ilişkinin
içeriğiydi. Sonuçta ya kapsül sınıfın tek bir nesne örneğine başvurarak, üye
sınıf nesneleri oluşturuyor yada her üye sınıf nesnesi için birer kapsül sınıf
nesnesi oluşturuluyordu. Her ne şekilde olursa olsun, kapsül sınıfın
yapıcısınında, üye sınıfın yapıcısınında çalıştırılacağı kesindi. Peki sıralama
nasıl olucaktı? Elbette burada kalıtımda yapıcıların nasıl çalıştığı göz önüne
alınabilirdi. Kalıtıma göre, en üst ata sınıfın yapıcısı ilk olarak çağırılacak,
daha sonra hiyerarşide aşağıya doğru inilerek diğer yapıcılar sırasıyla
işleyecekti. Bu işlevi izleyebilmek amacıyla aşağıdaki örneği geliştirdim.( Her
zamanki gibi iş yapmayan ama amacı kavramaya yönelik bir örnek...)
public class Uygulama
{
class Uye_1
{
Uye_1()
{
System.out.println("Uye_1 Sinifi
Yapicisi...");
}
class
Uye_1_AltUye
{
Uye_1_AltUye()
{
System.out.println("Uye_1 Sinifinin Uye Sinifinin Yapicisi...");
}
}
}
Uygulama()
{
System.out.println("Kapsul Sinifi
Yapicisi...");
}
public static void main(String[] args)
{
Uygulama.Uye_1.Uye_1_AltUye nesne=new
Uygulama().new Uye_1().new Uye_1_AltUye();
}
} |
Her ne kadar, en alttaki üye sınıfa ait nesneye
oluşturmak uzun ve zahmetli bir yol olarak gözüksede sonuç itibariyle amacıma
ulaşmıştım. Yapıcılar tahmin ettiğim gibi kapsülleyen sınıftan çalıştırılmaya
başlamıştı. Zaten bu, Uye_1_AltUye üye sınıfına ait nesnesnin oluşturulmasından
önce diğer üst sınıf nesnelerinin oluşturulma zorunluluğunun bir sonucuydu.
Üye sınıflar ile ilgili bir diğer ilginç nokta,
üye sınıflarında public ve friendly dışında, protected ve private gibi erişim
belirleyicilerinin kullanılabilmesiydi. Normal şartlar altında, bir sınıfı
private yada protected erişim belirleyicileri ile tanımlamaya çalışmak
olanaksızdı. Oysaki üye sınıflarda durum farklıydı. Örneğin bir üye sınıfı
private yaparak, kapsül sınıfı dışındaki diğer sınıflarca kullanılması
engellenebilirdi. Nasıl mı? İşte örneği.
class DahiliSiniflar
{
public class UyeSinif_1
{
void Yaz()
{
System.out.println("UyeSinif_1 Yaz Metodu...");
}
}
protected class UyeSinif_2
{
void Alan(double en, double boy)
{
double
alan=en*boy;
System.out.println("Alan "+alan);
}
}
private class UyeSinif_3
{
int Topla(int baslangic, int bitis)
{
int
toplamDeger=0;
for(int
i=baslangic;i<=bitis;i++)
{
toplamDeger+=i;
}
return
toplamDeger;
}
}
class UyeSinif_4
{
UyeSinif_4()
{
System.out.println("UyeSinif_4 yapicisi");
}
}
}
public class Uygulama2
{
public static void main(String[] args)
{
DahiliSiniflar ds=new
DahiliSiniflar();
DahiliSiniflar.UyeSinif_1 uye1=ds.new
UyeSinif_1();
uye1.Yaz();
DahiliSiniflar.UyeSinif_2 uye2=ds.new
UyeSinif_2();
uye2.Alan(5,10);
DahiliSiniflar.UyeSinif_3 uye3=ds.new
UyeSinif_3();
int sonuc=uye3.Topla(5,10);
System.out.println("Aralik degerleri
toplami "+sonuc);
DahiliSiniflar.UyeSinif_4 uye4=ds.new
UyeSinif_4();
}
} |
Bu örneğin bukadar uzun olduğuna bakmamak lazım.
Odaklanılması gereken nokta, private üye sınıfın, tanımlandığı kapsül sınıfı
dışındaki bir sınıf içerisinde örneklendirilmeye çalışılmasıdır. Uygulamayı
derlediğimde aşağıdaki hata mesajlarını anladım.
Sonuç gayet açık ve netti. Private tanımlanmış bir
üye sınıfa, tanımlandığı kapsül sınıf dışından erişememiştim. Ancak bu kısıtlama
üye sınıfa, tanımlandığı kapsül sınıf içindeki başka üye sınıflar tarafından
erişilemiyeceği anlamına gelmemekteydi. Dolayısıyla, private üye sınıfa ait
nesne örneğini, başka bir üye sınıf içinde aşağıda olduğu gibi kullanabilirdim.
Tek şart üyelerin, aynı kapsül sınıf içinde tanımlanmış olmalarıydı.
class DahiliSiniflar
{
...
private class UyeSinif_3
{
int Topla(int baslangic, int bitis)
{
int
toplamDeger=0;
for(int
i=baslangic;i<=bitis;i++)
{
toplamDeger+=i;
}
return
toplamDeger;
}
}
class UyeSinif_4
{
UyeSinif_4()
{
DahiliSiniflar.UyeSinif_3 uye3=new DahiliSiniflar().new UyeSinif_3();
int
sonuc=uye3.Topla(5,10);
System.out.println("Aralik degerleri toplami "+sonuc);
}
}
}
public class Uygulama2
{
public static void main(String[] args)
{
...
DahiliSiniflar.UyeSinif_4 uye4=ds.new
UyeSinif_4();
}
} |
Artık Bonus Plus'a geçmenin vakti gelmişti. Vitesi
arttırıp konuda ilerlemeye devam etmeliydim. Üye sınıflara burada nokta koyup
diğer dahili sınıfları incelemem gerektiği düşüncesindeydim. Ancak yapamadım.
İncelemem gereken bir konu daha olduğunu farkettim. Static üye sınıflar. Nasıl
ki static metodları çalıştırmak için nesne örneklerine gerek yoksa, static üye
sınıfları oluşturmak içinde, kapsül sınıfın nesne örneğini oluşturmaya gerek
yoktur diye düşündüm ilk olarak. Acaba durum böyle miydi? İlk önce static bir
üye sınıf tanımlamakla işe başladım. Sonraki amacım bu static sınıfa ait bir
nesne örneğini oluşturmaktı. Bu nesne örneğini ilk başta klasik üye sınıfı
örneklendirme tekniğiyle oluşturmaya çalıştım.
public class Uygulama
{
static class Static_Uye
{
Static_Uye()
{
System.out.println("Statik_Uye Sinifi Yapicisi...");
}
}
public static void main(String[] args)
{
Uygulama.Static_Uye uye=new
Uygulama().new Static_Uye();
}
} |
Kod başarılı bir şekilde derlenmişti. Şimdi main
yordamı içindeki nesne örneklendirme satırını aşağıdaki gibi değiştirdim.
| Static_Uye uye=new Static_Uye(); |
Kod yine başarılı bir şekilde derlendi ve çalıştı.
İki teknik arasında oldukça önemli bir fark vardı. İkinci kullanımda bu üye
sınıfı static olarak tanımladığım için, kapsül sınıftan bir nesne oluşturma
zahmetine girmemiştim. Dolayısıyla kapsül sınıf içinde bu üye sınıfı normal bir
sınıf türetirmişçesine örnekleyebilmiştim. Peki durum kapsül sınıf dışındaki
sınıflar için nasıl ceyran edecekti. Bunun için yapmam gereken basit bir örnek
ile durumu aydınlatmaya çalışmaktı.
class Deneme
{
static class Static_Uye
{
Static_Uye()
{
System.out.println("Statik_Uye Sinifi Yapicisi...");
}
}
}
public class Uygulama
{
public static void main(String[] args)
{
Static_Uye uye=new Static_Uye();
}
} |
Uygulamayı derlediğimde aşağıdaki hata mesajları
ile karşılaştım.
Çözüm gayet basitti. Statik sınıfa ait nesne
örneğini oluştururken, statik sınıfın tanımlı olduğu kapsül sınıfıda
kullanmalıydım. Nasıl ki, işte şöyle ki.
| Deneme.Static_Uye uye=new
Deneme.Static_Uye(); |
Bu haliyle uygulama başarılı bir şekilde derlendi.
Ancak yine dikkat edilmesi gereken nokta, kapsül sınıfa ait bir nesne örneğinin
oluşturulmamış olmasıydı. Bununla birlikte static üyelerin, kapsül sınıftaki
alanlara ve diğer üyelere erişiminde bir sorun olduğu kaynaklarımda geçiyordu.
Bunu en güzel bir örnekle irdeleyebileceğimi biliyordum.
class Deneme
{
String alan="BURAK";
void Kimlik()
{
System.out.println("MERHABA...
"+alan);
}
static class Static_Uye
{
Static_Uye()
{
System.out.println("Statik_Uye Sinifi Yapicisi...");
Kimlik();
}
}
}
public class Uygulama
{
public static void main(String[] args)
{
Deneme.Static_Uye uye=new
Deneme.Static_Uye();
}
} |
Bu uygulamayı derlediğimde aşağıdaki hata mesajını
aldım.
Bunun sebebini kaynaklar şu şekilde açıklıyor.
Static bir üye sınıfın, kaspül sınıf ile arasında this ilişkisi yoktur. Buradan
çıkartabileceğim sonuç, static üye sınıfın kendi içinden, kapsül sınıftaki
üyelere (alanlar ve metodlar) erişemiyeceğiydi. Nitekim, buradaki sınıfımız
statik olmasaydı, kapsül sınıftaki üyelere erişebilirdi. Ancak durum kapsül
sınıftaki üyelerde statik olursa değişmekteydi. Yani örneği aşağıdaki şekilde
geliştirdiğimde, uygulama başarılı bir şekilde derleniyordu. Çünkü üye sınıf,
kapsül sınıfın nesne örneğine ihtiyaç duyulmadan kullanılabilecek static üyelere
erişmekteydi.
class Deneme
{
static String alan="BURAK";
static void Kimlik()
{
System.out.println("MERHABA...
"+alan);
}
static class Static_Uye
{
Static_Uye()
{
System.out.println("Statik_Uye Sinifi Yapicisi...");
Kimlik();
}
}
} |
Artık sıra yerel sınıfları öğrenmeye geldi
sanıyorum. Ama bu dahili sınıf tipine geçmeden önce özellikle, üye sınıfların
genel kullanım amacı üzerinde durmakta fayda olacağını düşünüyorum. Üye
sınıflar, çoklu kalıtımın gerçekleştirilmesine imkan sağlamaktadırlar. Nitekim,
bir sınıfı bir kaç sınıftan birden türetmek mümkün değildir. Ancak bir sınıfa
bir kaç arayüz uygulanarak çoklu kalıtım kısmide olsa sınırlı bir şekilde
uygulanabilir. Bununla birlikte üye sınıflar ile çoklu kalıtım daha güvenli ve
güçlü bir şekilde gerçekleştirilebilir. Bu amaçla geliştirdiğim aşağıdaki basit
örneği incelemekte fayda var sanırım.
class TemelSinif
{
void Yaz(double deger)
{
System.out.println("Sonuc "+deger);
}
}
class AltTemel
{
double Alan(double en, double boy)
{
return (en*boy)/2;
}
}
public class Program extends TemelSinif
{
class Alt1 extends AltTemel
{
Alt1()
{
Yaz(Alan(20,2.5));
}
}
public static void main(String[] args)
{
Program.Alt1 nesne=new Program().new
Alt1();
}
} |
Peki burada olan olay nedir? Çoklu kalıtım nerede
gizlidir? Bunu cevaplandırabilmenin en kolay yolu, uygulamadaki sınıflar
arasındaki ilişkiyi şematik olarak ifade edebilmektir. Bu amaçla, uml vari bir
diagam geliştirmeye çalıştım.
Şekilde herşey daha net. (.net değil berrak
anlamında...) Program sınıfı içerisinde yer alan Alt1 üye sınıfı, AltTemel
isimli sınıftan türetiliyor. Lakin, üye sınıfımızın bulunduğu kapsül sınıf olan
Program sınıfıda, TemelSinif'tan türetilmiştir. Dolayısıyla burada, Alt1 sınıfı
hem AltTemel, hemde TemelSinif sınıflarının üyelerine erişim hakkına kalıtım
gereği sahiptir. Zaten örnektede bunu irdelemeye çalıştım. Üye sınıf yapcısı
içinden, üye sınıfın içinde bulunduğu kapsül sınıfın türediği temel sınıftaki
metodu, üye sınıfın türediği sınıfa ait metodu parametre alacak şekilde
çağırdım. İşte çok biçimlilik denen olayın üye sınıflar ile güvenli bir biçimde
uygulanabilmesi.
Sanıyorumki artık diğer dahili sınıflara
geçebilirim. Bu umutla kaynaklarıma son kez bakıp titreyen eller ile, umarım üye
sınıfların başka sürprizleri yoktur diyerek sayfalarda ilerlemeye devam ettim.
Ancak biliyorumki üye sınıflar ile ilgili ileride karşıma yeni şeyler çıkacak.
Bu java dilinin doğasında olan bir şey. Sürekli sürprizler yapıyor bu çılgın
programlama dili. Giderek sevmeye mi başladım ne.
Nihayet!!! Sonunda yerel sınıflara gelebildim.
Yerel sınıflar, üye sınıflardan daha ilginç bir kavram. Öyleki, bir metodun
içersinde kullanılmak üzere sınıf bildirimleri gerçekleştirilebiliyor. Sadece
metod olsa iyi. Yapıcılar içindede yerel sınıf tanımlamları yapılabilmekte.
Ancak burada önemli olan yerel sınıfın sadece tanımlandığı metod bloğu
içerisinde çalışıyor olması. Dolayısıyla bu metod dışından bu sınıflara erişmek
mümkün değil. Neden böyle bir gereksinimim olabilir sorusuna gelince, bu
önümüzdeki aylar boyunca kendi kendime soracağım bir soru olarak kalıcak
sanıyorum. Ama bu tarz sorulara verilen güzel bir cevabıda görmezden gelemem.
"Dilin kabiliyetlerini bilmemizi sağlar..." Bir bakalım yerel sınıflar neyin
nesiymiş.
public class Aritmetik
{
static double Hesaplamalar(double a,double b)
{
class Alan
{
double en;
double
yukseklik;
Alan(double
deger1,double deger2)
{
en=deger1;
yukseklik=deger2;
}
public double
Hesapla()
{
return (en*yukseklik)/2;
}
}
Alan nesne=new Alan(a,b);
return nesne.Hesapla();
}
public static void main(String[] args)
{
double sonuc=Hesaplamalar(8,4);
System.out.println(sonuc);
}
} |
Olay son derece açıktı aslında. Metod içinde bir
yerel sınıf tanımlanmış ve kullanılmıştı. İşte yerel sınıfların özü buydu. Yerel
sınıflar, kullanıldıkları metod dışında işlevsel değildi. Bununla birlikte, bir
yerel sınıfı başka sınıflardan veya arayüzlerden türetebilirdik. Yerel sınıflar
ile ilgili önemli bir kısıtlamada, sadece friendly erişim belirleyicisine sahip
olabilmesiydi. Yani üye sınıflarda olduğu gibi tüm erişim belirleyicilerini
kullanılamıyorlar. Zaten, sadece metod içinde geçerli olmasınıda bu durum bir
nebze olsun açıklıyor.
Kahvem azaldıkça gecenin bu geç saatlerinde
enerjimde azalmaya başladı. Ancak işlemem gereken bir dahili sınıf çeşidi daha
var. Bu dahili sınıf türü, isimsiz sınıflar. Açıkçası bu sınıfların kullanımını
düşündükçe biraz güldüm kendimce. Nasıl mı? Haydi kahvemizden bir yudum daha
alalım ve isimsiz sınıfları inceleyelim.
interface Alan
{
public double Hesapla();
}
public class Aritmetik2
{
public static Alan Hesaplamalar(final double a,final double
b)
{
return new Alan()
{
public double
Hesapla()
{
return (a*b)/2;
}
};
}
public static void main(String[] args)
{
Alan a=Hesaplamalar(8,4);
double sonuc=a.Hesapla();
System.out.println(sonuc);
}
} |
Neden güldüğümü şimdi daha iyi anlamışsınızdır
herhalde. Kodu kaynaklarımdaki örnekleri inceleyerek oluşturdum. Sonrada,
örneğimin içinde, isimsiz sınıfı aramaya başladım. İşte o anda bir gülme krizi
aldı beni gitti. İsimsiz sınıfı bulamıyordum. Kod her zamankinden farklıydı,
hemde çok farklıydı ancak ben isimsiz sınıfı bir türlü bulamıyordum. Sonradan
dikkatimi, Hesaplamalar isimli metodunun geri dönüş değerinin türü çekti. Bu
metod dönüş tipi olarak bir arayüzü nesnesi işaret etmekteydi. Bir arayüz
nesnesi geri döndürecekse eğer, return anahtar kelimesinden sonra bu arayüzü
uygulayan bir sınıf örneğinin dönmesi gerektiğini anlamıştım.
İşte isimsiz sınıfım oradaydı. Hakikattende
isimsiz bir sınıftı. Adı yoktu ama şanı almış başını yürüyordu. Gözükmeyen
kahraman gibiydi desem yeridir. return anahtar kelimesinden sonra, metodun dönüş
tipi olan arayüzü'e ait bir sınıf oluşturulmuş ve içinde bir takım hesaplamalar
yaptırılmıştı. Yani isimsiz sınıfım şurasıydı.
return new Alan()
{
public double Hesapla()
{
return (a*b)/2;
}
}; |
Açıkçası anlaşılması ve kullanımı oldukça karmaşık
bir yapıda. Tam olarak kavrayabildiğimi söyleyemem. Ancak kaynaklarım özellikle
ileride göreceğim, olay dinleyicileri (event listener) ile ilgili yerlerde
sıklıkla kullanıldığını belirtiyor. En azından şimdilik, nasıl kullanıldığını
gördüm. Zaman ilerledikçe bu kavramında yerine oturacağı kanısındayım. Ancak
şimdi dinlenme zamanı geldi diye düşünüyorum. Kahvemde bitti zaten.
Burak Selim ŞENYURT
selim@bsenyurt.com