Java'da kalıtım kurmak için bir alt sınıf tanımı extends anahtar kelimesiyle bir üst sınıfa bağlanır; böylece alt sınıf, üst sınıfın alan ve metotlarını otomatik olarak devralır. Üst sınıfın constructor'ı miras alınmadığı için alt sınıfın kurucusunda super() çağrısıyla açıkça tetiklenmesi gerekir. Bu iki mekanizma bir araya geldiğinde, ortak davranışı tek bir yerde tanımlayıp farklı sınıflarda yeniden kullanmayı sağlayan, Java OOP'un temel taşlarından biri olan kalıtım ilişkisi ortaya çıkar.
Bu yazıda extends ile üst sınıf-alt sınıf ilişkisinin nasıl kurulduğunu, super() ve super.metod() kullanımını, field shadowing gibi sık karışan konuları ve kalıtımın kompozisyonla nasıl kıyaslandığını adım adım, örnekler üzerinden ele alacağız.
Kalıtım (Inheritance) Nedir ve Neden Kullanılır?
Kalıtım, bir sınıfın başka bir sınıfın sahip olduğu alanları ve metotları devralarak kendi üzerine yeni özellikler eklemesini sağlayan bir OOP mekanizmasıdır. Devralan sınıfa alt sınıf (subclass), devredilen sınıfa ise üst sınıf (superclass) denir. Bu ilişki genellikle "is-a" (bir çeşittir) mantığıyla kurulur: örneğin bir Kopek sınıfı, bir Hayvan sınıfının özel bir türü olduğu için "Kopek is-a Hayvan" cümlesi mantıklı bir şekilde kurulabilir. Buna karşılık "Kopek is-a Kuyruk" gibi bir ifade anlamsız kaçar, çünkü kuyruk köpeğin bir parçasıdır, bir türü değildir; bu ayrım kalıtımın ne zaman doğru araç olduğunu anlamak için kritik bir turnusoldür.
Kalıtımın asıl amacı kod tekrarını azaltmak ve ortak davranışı tek bir merkezde toplamaktır. Diyelim ki bir uygulamada Kedi, Kopek ve Kus sınıfları var; hepsinin isim, yaş gibi ortak alanları ve yeme, uyuma gibi ortak davranışları olabilir. Bu ortak kısımları her sınıfta ayrı ayrı yazmak yerine, bir Hayvan üst sınıfında bir kez tanımlayıp diğer sınıfların bu üst sınıftan türemesini sağlamak, hem kodu kısaltır hem de bir değişiklik gerektiğinde tek bir yerin güncellenmesini yeterli kılar. Bu sayede yeni bir hayvan türü eklemek istendiğinde sıfırdan başlamak yerine, mevcut üst sınıfın üzerine sadece o türe özgü farkları eklemek yeterli olur.
Bu mantığı ilk kez oturtmaya çalışan biri için en zorlayıcı kısım, kalıtımın soyut bir kural değil, gerçek kod tasarımı problemi olduğunu görmektir. Sınıf kavramını öğrenmiş ama nesneler arasındaki hiyerarşik ilişkileri henüz kurgulayamamış öğrenciler için bu geçiş, uygulamalı örneklerle çok daha hızlı oturur. canlı işlenen yazılım eğitimi programları tam da bu noktada, kalıtım gibi kavramları soyut tanımlarda bırakmadan, gerçek proje senaryoları üzerinden adım adım işleyerek öğrencinin zihninde somutlaştırmayı hedefler. Böylece üst sınıf ve alt sınıf terimleri yalnızca ezberlenen kavramlar olmaktan çıkar, gerçek kod yazma alışkanlığının bir parçası hâline gelir.
extends Anahtar Kelimesi ile Üst Sınıf-Alt Sınıf İlişkisi Kurmak
Java'da bir sınıfın başka bir sınıftan türediğini belirtmek için extends anahtar kelimesi kullanılır. Söz dizimi oldukça basittir: class Alt extends Ust { } yazıldığında, Alt sınıfı Ust sınıfının tüm public ve protected alan ile metotlarına otomatik olarak sahip olur, üzerine kendi özel alan ve metotlarını ekleyebilir. Bu ilişki kurulduktan sonra Alt sınıfından oluşturulan her nesne, hem kendi tanımladığı davranışları hem de Ust sınıfından miras aldığı davranışları taşır.
Bir üst sınıf-alt sınıf ilişkisini sıfırdan kurarken izlenecek adımlar genellikle şu sırayı takip eder:
- Ortak alan ve metotları taşıyacak üst sınıfı tanımla.
- extends anahtar kelimesiyle alt sınıfı üst sınıftan türet.
- Alt sınıfa özgü, üst sınıfta bulunmayan yeni alan ve metotları ekle.
- Alt sınıfın constructor'ı içinde ilk satırda super() çağrısıyla üst sınıfın kurucusunu tetikle.
- Gerekirse üst sınıftan gelen bir metodu override et ve içinde super.metod() ile üst sınıfın orijinal davranışına da erişebil.
Kavramsal olarak düşünmek gerekirse, bir Tasit üst sınıfı hiz ve yakitTuru gibi ortak alanlar ile hizlan() gibi ortak bir metot taşıyabilir; bunun üzerine türeyen bir Otomobil alt sınıfı ise sadece kendine özgü olan kapiSayisi alanını ve bagajAc() metodunu ekler, hiz ve hizlan() gibi ortak yapıyı yeniden yazmaz. Bu yaklaşımın ne kadar oturduğunu görmek isteyenler Java bilgi seviyesini ölçen ücretsiz test ile extends ve kalıtımla ilgili temel kavramlara ne kadar hâkim olduklarını hızlıca kontrol edebilir. Bir sonraki bölümde bu adımlardan dördüncüsü olan super() çağrısının neden zorunlu olduğuna ve constructor'ların miras mekanizmasından neden farklı çalıştığına ayrıntılı şekilde bakacağız.
super() ile Üst Sınıfın Constructor'ını Çağırmak
Alanlar ve metotlar alt sınıfa otomatik olarak geçse de, constructor'lar miras alınmaz. Bunun nedeni, her constructor'ın kendi sınıfının nesnesini kurmaya özgü bir işlem olmasıdır; üst sınıfın kurucusu kendi alanlarını nasıl başlatacağını bilir, ama alt sınıfın hangi ek parametrelerle çağrılacağını bilemez. Bu yüzden Java, alt sınıfın kendi constructor'ını yazmasını ve üst sınıfın kurucusunu super() ifadesiyle açıkça çağırmasını bekler.
Burada uyulması gereken katı bir kural vardır: super() çağrısı, alt sınıfın constructor'ı içinde yazılacaksa mutlaka ilk satırda yer almalıdır. Bunun mantığı basittir; bir nesne önce üst sınıfın parçası olarak kurulur, sonra alt sınıfa özgü kısımlar bu temelin üzerine eklenir. super() ilk satırda olmadığında ya da yanlış parametrelerle çağrıldığında derleyici hata verir, çünkü nesnenin temeli düzgün atılmadan üzerine bir şey inşa edilmesine izin verilmez.
Eğer alt sınıfın constructor'ında super() hiç yazılmazsa, Java derleyicisi arka planda otomatik olarak üst sınıfın parametresiz constructor'ını çağırmaya çalışır. Üst sınıfta parametresiz bir constructor tanımlıysa bu sessizce çalışır ve fark edilmez; ama üst sınıf yalnızca parametreli bir constructor'a sahipse ve parametresiz bir tane tanımlanmamışsa, derleyici uyuşan bir constructor bulamaz ve "constructor Ust() bulunamadı" türünden bir derleme hatası oluşur. Bu, yeni başlayanların sık düştüğü bir tuzaktır: üst sınıfa parametreli bir constructor eklendiğinde, önceden sorunsuz çalışan alt sınıflar birden derlenmez hâle gelebilir, çünkü artık üst sınıfın hangi constructor'ının hangi değerlerle çağrılacağını alt sınıfın açıkça belirtmesi gerekir.
Kapsamlı Kod Örneği: Hayvan ve Köpek Sınıflarıyla extends ve super
Şimdiye kadar anlatılanları tek bir örnekte birleştirelim. Aşağıdaki kod, bir Hayvan üst sınıfı ile ondan türeyen bir Kopek alt sınıfını gösteriyor. Örnek; extends ile kalıtım kurmayı, constructor içinde super() çağırmayı ve override edilen bir metodun içinde super.metod() kullanmayı tek bir akışta gözler önüne seriyor.
class Hayvan {
protected String isim;
protected int yas;
public Hayvan(String isim, int yas) {
this.isim = isim;
this.yas = yas;
}
public void sesCikar() {
System.out.println(isim + " bir ses çıkarıyor.");
}
}
class Kopek extends Hayvan {
private String irk;
public Kopek(String isim, int yas, String irk) {
super(isim, yas);
this.irk = irk;
}
@Override
public void sesCikar() {
super.sesCikar();
System.out.println(isim + " (" + irk + ") havlıyor: Hav hav!");
}
}
public class Main {
public static void main(String[] args) {
Kopek kopek = new Kopek("Karabaş", 3, "Kangal");
kopek.sesCikar();
}
}
Bu kodu çalıştırdığınızda ekranda önce "Karabaş bir ses çıkarıyor." ardından "Karabaş (Kangal) havlıyor: Hav hav!" satırlarını görürsünüz. Şimdi satır satır neler olduğuna bakalım:
- Hayvan sınıfı isim ve yas alanlarını tanımlar; bu alanlar protected olduğu için alt sınıf tarafından doğrudan görülebilir.
- Hayvan'ın constructor'ı bu iki alanı parametre olarak alıp kendi nesnesine atar.
- Kopek sınıfı extends Hayvan ifadesiyle Hayvan'dan türetilir; artık Hayvan'ın tüm public ve protected üyelerine erişebilir.
- Kopek'in constructor'ı, ilk satırında super(isim, yas) çağrısıyla Hayvan'ın constructor'ını çalıştırır; isim ve yas bu sayede düzgün şekilde ilklendirilir.
- sesCikar() metodu @Override ile yeniden tanımlanır; fakat içinde önce super.sesCikar() çağrılarak Hayvan'ın orijinal davranışı da çalıştırılır, sonra köpeğe özgü havlama satırı eklenir.
Bu yapı, gerçek projelerde sıkça karşılaşacağınız bir desendir: bir çalışan sınıfı, bir sipariş sınıfı ya da bir kullanıcı rolü hiyerarşisi kurarken aynı extends-super kombinasyonunu kullanırsınız. Bu mantığı küçük örneklerle değil, gerçek sınıf hiyerarşileri üzerinde uygulamalı olarak pekiştirmek isteyenler için birebir Java özel ders programı adım adım pratik yapma imkânı sunar.
super.metod() ile Override Edilen Metoda Erişim
Yukarıdaki örnekte dikkat çeken bir nokta var: sesCikar() metodu override edilmesine rağmen, üst sınıfın orijinal davranışı tamamen kaybolmadı. Override etmek, bir metodun alt sınıftaki davranışını değiştirmek anlamına gelir; ancak super.metod() kullanmak, o eski davranışa hâlâ erişebilmenizi sağlar. Bu ikisi birbirinin alternatifi değil, birbirini tamamlayan iki farklı araçtır.
Pratikte karşınıza şu karar çıkar: Üst sınıfın davranışını tamamen mi değiştirmeniz gerekiyor, yoksa üzerine bir şeyler mi eklemeniz gerekiyor? Eğer alt sınıfın davranışı üst sınıfla hiçbir ortak noktası olmayacak şekilde farklıysa, override içinde super.metod() çağırmadan tamamen yeni bir mantık yazmak daha doğrudur. Ama çoğu zaman üst sınıfın yaptığı işin geçerliliğini korumak, sadece ona bir adım eklemek istersiniz — loglama, doğrulama, ek bir hesaplama gibi. İşte tam bu noktada super.metod() devreye girer: eski davranışı çalıştırır, siz de üstüne yeni satırlar eklersiniz.
Örneğin bir Calisan sınıfında maasHesapla() metodu temel maaşı hesaplıyorsa, Yonetici alt sınıfında bu metodu override edip önce super.maasHesapla() ile temel maaşı almak, sonra buna yönetici primi eklemek hem daha az kod yazmanızı sağlar hem de üst sınıftaki hesaplama mantığı değiştiğinde alt sınıfın otomatik olarak güncel kalmasını garanti eder. Bu tür küçük ama kritik kararları verirken kendi OOP bilginizi ölçmek isterseniz ücretsiz yazılım bilgisi testi ile hangi konularda daha çok pratiğe ihtiyacınız olduğunu görebilirsiniz.
Kısacası soru "override mı yoksa super.metod() mü" değil, "üst sınıfın işini tamamen bir kenara mı bırakıyorum, yoksa üzerine mi inşa ediyorum" sorusudur. Bu sorunun cevabı sizi doğru tasarıma götürür.
Alan Gölgelemesi (Field Shadowing) ve super ile Çözümü
Metot override etmek gayet açık ve Java'nın desteklediği bir mekanizmadır; ancak alan gölgelemesi (field shadowing) adı verilen durum çok daha sinsi bir kafa karışıklığı kaynağıdır. Field shadowing, alt sınıfta üst sınıftakiyle tamamen aynı isimde bir alan (değişken) tekrar tanımlandığında ortaya çıkar. Metotların aksine alanlar Java'da polimorfik davranmaz; hangi alanın kullanılacağı, referansın tipine göre derleme zamanında belirlenir.
class Hayvan {
protected String tur = "Hayvan";
}
class Kopek extends Hayvan {
protected String tur = "Köpek";
public void turleriYazdir() {
System.out.println("Alt sınıf alanı: " + tur);
System.out.println("Üst sınıf alanı: " + super.tur);
}
}
Bu örnekte Kopek sınıfı, Hayvan'dan miras aldığı tur alanını override etmiyor; sadece kendi tur adında yepyeni bir alan tanımlıyor ve üst sınıftakini gölgeliyor. turleriYazdir() metodu çalıştırıldığında "Alt sınıf alanı: Köpek" ve "Üst sınıf alanı: Hayvan" çıktısını görürsünüz; çünkü super.tur ifadesi açıkça üst sınıfın alanına işaret eder.
Field shadowing'in kafa karıştırıcı olmasının sebebi, metot override ile görsel olarak çok benzemesi ama tamamen farklı kurallara tabi olmasıdır. Bir Hayvan referansı üzerinden erişildiğinde, gerçek nesne Kopek olsa bile Hayvan'ın tur alanı okunur — bu, override edilmiş bir metotta asla yaşanmayacak bir davranıştır. Bu yüzden deneyimli Java geliştiricilerinin çoğu genel bir prensip benimser: alt sınıfta üst sınıftakiyle aynı isimde yeni bir alan tanımlamaktan mümkün olduğunca kaçının. Gerçekten yeni bir veriye ihtiyacınız varsa farklı bir isim seçmek, super ile karmaşık erişim satırları yazmaktan çok daha okunabilir ve hataya daha az açık bir çözümdür.
extends Kullanırken Dikkat Edilmesi Gereken Yaygın Hatalar
Kalıtım mekanizması ilk bakışta basit görünse de, yeni başlayanların sıklıkla aynı noktalarda takıldığı birkaç kritik ayrıntı vardır. Bu hataların çoğu derleyici tarafından anında yakalanır, ancak bazıları çalışma zamanında beklenmedik davranışlara yol açar ve hata ayıklamayı zorlaştırır. Aşağıdaki listeyi bir kontrol listesi gibi kullanmak, kalıtım tabanlı sınıf hiyerarşileri kurarken zaman kazandırır.
- super() çağrısını constructor'ın ilk satırı yapmamak: Alt sınıfın constructor'ı içinde super() çağrısı yapılacaksa, bu çağrı mutlaka ilk satırda yer almalıdır. Araya başka bir kod satırı (örneğin bir alan ataması veya print ifadesi) koymak derleme hatasına neden olur, çünkü Java önce üst sınıfın kurulmasını, sonra alt sınıfın kendi mantığının çalışmasını garanti eder.
- private alanlara alt sınıftan doğrudan erişmeye çalışmak: Üst sınıfta private olarak tanımlanmış bir alan, alt sınıf tarafından miras alınmaz gibi davranılır; alt sınıf ona doğrudan erişemez. Bu durumda çözüm, üst sınıfa protected erişim belirleyicili bir alan tanımlamak ya da getter/setter metotları sunmaktır.
- Java'da sınıflar için çoklu kalıtımın olmaması: Bir sınıf aynı anda yalnızca tek bir sınıftan extends ile türeyebilir; iki farklı sınıftan miras almaya çalışmak derleme hatası verir. Birden fazla davranışı bir araya getirmek gerektiğinde Java, interface'lerin implements ile uygulanmasını tercih eder; bu, çoklu kalıtımın belirsizliklerinden kaçınmak için bilinçli bir tasarım kararıdır.
- Override sonrası gerekirse super.metod() çağırmayı unutmak: Bir metot override edildiğinde, üst sınıfın orijinal davranışı tamamen kaybolur. Eğer amaç üst sınıfın işini genişletmek (tamamen değiştirmek değil), super.metod() çağrısının unutulmaması gerekir; aksi halde üst sınıfta yazılmış önemli bir mantık sessizce devre dışı kalır.
Bu tür hataların çoğu, kod yazarken değil, kodu test ederken veya başka bir geliştirici tarafından incelenirken fark edilir. Bire bir ilerleyen bir çalışma ortamında bu hataları erkenden görmek çok daha kolaydır; bu yüzden kalıtım hiyerarşilerini pratik yaparak pekiştirmek isteyenler için birebir Java dersleri kapsamında kod üzerinden anlık geri bildirim almak, bu tür tuzaklardan kaçınmayı hızlandıran bir yöntemdir.
Kalıtım mı Kompozisyon mu? Has-a ve Is-a Yaklaşımlarının Karşılaştırılması
Kalıtım, "bir şeyin başka bir şeyin türü olması" (is-a) ilişkisini modellerken, kompozisyon "bir şeyin başka bir şeye sahip olması" (has-a) ilişkisini modeller. Örneğin bir Köpek bir Hayvan'dır (is-a), bu yüzden extends mantıklıdır; ancak bir Araba bir Motor'a sahiptir (has-a), bu yüzden Araba sınıfı Motor sınıfından extends etmek yerine, içinde bir Motor nesnesi barındırmalıdır. Bu ayrımı doğru yapmak, uzun vadede esnek ve bakımı kolay bir kod tabanı kurmanın temelidir.
| Kriter | Kalıtım (is-a) | Kompozisyon (has-a) |
|---|---|---|
| İlişki türü | Alt sınıf, üst sınıfın bir türüdür | Bir sınıf, başka bir sınıfın nesnesini alan olarak barındırır |
| Esneklik | Sınıf hiyerarşisi sabittir, çalışma zamanında değiştirilemez | İçerilen nesne çalışma zamanında değiştirilebilir, daha esnektir |
| Bağımlılık derecesi | Alt sınıf, üst sınıfın iç yapısına ve davranışına sıkı bağlıdır | Sınıflar birbirinden daha gevşek bağlıdır, arayüz üzerinden iletişim kurar |
| Ne zaman tercih edilir | Gerçekten bir tür-alt tür ilişkisi varsa ve davranış paylaşımı doğalsa | Sadece belirli bir yeteneği veya bileşeni kullanmak, ama tam davranışı miras almak istenmiyorsa |
Pratikte deneyimli geliştiriciler genellikle şu kuralı benimser: ilişki gerçekten bir is-a ilişkisi değilse, kalıtım yerine kompozisyonu tercih etmek daha güvenlidir. Kalıtım güçlü bir araçtır ama fazla kullanıldığında sınıflar arasında kırılgan ve birbirine aşırı bağımlı hiyerarşiler oluşturabilir; kompozisyon ise nesneleri daha bağımsız parçalar halinde tasarlamayı sağlar.
Python'da Kalıtım: Java ile Kısa Bir Karşılaştırma
Kalıtım kavramı Java'ya özgü değildir; nesne yönelimli programlama yapan hemen her dilde benzer bir mantıkla karşımıza çıkar. Python'da bir sınıfın başka bir sınıftan türemesi için class Alt(Ust): söz dizimi kullanılır; parantez içine yazılan sınıf adı, Java'daki extends kelimesinin karşılığı gibi düşünülebilir. Üst sınıfın constructor'ını çağırmak için ise Python'da super().__init__() kullanılır, bu da Java'daki super() çağrısının işlevsel karşılığıdır.
class Hayvan:
def __init__(self, isim):
self.isim = isim
def ses_cikar(self):
print(f"{self.isim} bir ses çıkarıyor.")
class Kopek(Hayvan):
def __init__(self, isim, cins):
super().__init__(isim)
self.cins = cins
def ses_cikar(self):
super().ses_cikar()
print(f"{self.isim} havlıyor.")
Temel fark söz diziminde ortaya çıkar: Java'da extends anahtar kelimesi ve super() çağrısı açık ve zorunlu bir yapı sunar, derleyici bu kuralları sıkı biçimde denetler. Python'da ise aynı mantık daha esnek bir sözdizimiyle ifade edilir; süslü parantezler ve erişim belirleyiciler yoktur, ancak üst sınıfın kurucusunu çağırma zorunluluğu benzer bir disiplinle uygulanır. Bu farkları elle deneyerek görmek isteyenler için birebir Python dersleri kapsamında iki dilin kalıtım yapısını yan yana çalışmak, kavramın dilden bağımsız olduğunu somut biçimde gösterir.
Sonuç olarak hangi dilde çalışılırsa çalışılsın, kalıtımın arkasındaki OOP mantığı aynı kalır: bir sınıf, başka bir sınıfın davranışını ve verisini devralır, üzerine kendi özelleşmiş mantığını ekler. Java ve Python arasındaki fark yalnızca bu mantığın söz dizimiyle ifade ediliş biçimindedir; kavramsal temel, yani is-a ilişkisi ve davranış genişletme fikri, her iki dilde de birebir aynıdır.
Sık Sorulan Sorular
extends anahtar kelimesi Java'da tam olarak ne işe yarar?
extends anahtar kelimesi, bir sınıfın başka bir sınıftan türediğini ve onun alanlarını, metotlarını devraldığını belirtir. Bu sayede alt sınıf, üst sınıfın davranışını tekrar yazmadan kullanabilir ve üzerine kendi özel mantığını ekleyebilir.
super() çağrısı her zaman zorunlu mudur, hangi durumlarda derleyici otomatik ekler?
Alt sınıfın constructor'ında super() açıkça yazılmazsa, Java derleyicisi üst sınıfın parametresiz constructor'ını otomatik olarak ilk satıra ekler. Ancak üst sınıfta yalnızca parametreli bir constructor varsa, super() çağrısının parametrelerle birlikte açıkça yazılması zorunludur.
super.metod() ile method overriding arasındaki fark nedir?
Method overriding, alt sınıfın üst sınıftaki bir metodu kendi versiyonuyla değiştirmesidir. super.metod() ise override edilmiş bu metot içinden üst sınıfın orijinal davranışına erişmek için kullanılır; yani biri değiştirme, diğeri değiştirilenin eski haline ulaşma işlemidir.
Java'da bir sınıf birden fazla sınıftan extends ile türetilebilir mi?
Hayır, Java'da bir sınıf yalnızca tek bir sınıftan extends ile türeyebilir. Birden fazla davranış kaynağı gerektiğinde bunun yerine interface'ler implements anahtar kelimesiyle uygulanır.
Alan gölgelemesi (field shadowing) neden sorun yaratır?
Alan gölgelemesi, alt sınıfta üst sınıftakiyle aynı isimde bir alan tanımlandığında ortaya çıkar ve hangi alanın kullanıldığı, referansın tipine göre değişir. Bu durum kodun okunmasını zorlaştırır ve beklenmedik değerlerin okunmasına yol açabileceği için genellikle kaçınılması gereken bir tasarımdır.
Kalıtım mı kompozisyon mu tercih edilmeli?
İlişki gerçekten bir tür-alt tür (is-a) ilişkisiyse kalıtım uygundur; ancak bir sınıfın sadece başka bir sınıfın yeteneğini kullanması (has-a) yeterliyse kompozisyon daha esnek ve daha az kırılgan bir çözümdür.
Python'da kalıtım Java'dan farklı mı çalışır?
Temel OOP mantığı aynıdır; fark yalnızca söz dizimindedir. Python'da class Alt(Ust): ve super().__init__() kullanılırken, Java'da bu işlem extends ve super() ile daha açık ve sıkı kurallarla ifade edilir.
Kalıtım, sınıflar arasında kod tekrarını azaltan ve gerçek dünyadaki tür ilişkilerini doğal biçimde modelleyen güçlü bir OOP aracıdır; ancak gücünü doğru kullanmak, extends ve super() mekanizmasını sadece ezberlemek değil, hangi durumda kalıtımın hangi durumda kompozisyonun daha uygun olduğunu ayırt edebilmekten geçer. Bu kavramları kod üzerinde adım adım pekiştirmek isteyenler Java yazılım kursu sayfasından programın içeriğini inceleyebilir.
