�ݺ�ߣ

NESNE TABANLI
PROGRAMLAMA
(JAVA)
Bilgisayar Sistemleri Öğretmeni
Bahadır GÜNAYDIN
Email: gunaydinbahadir@hotmail.com

Ulaşım Sınıfı
• Öncelikle örnek olması açısından bir class
oluşturalım. Sınıfımızın adı ulasim.java olsun. Sınıfımızın
amacı gönderilen parametrelere göre ulasim
maliyetini hesaplamaktır. Burada yuz_km_litre
özelliği aracın yüz kilometrede kaç litre yaktığı
bilgisini, gidilecek_km özelliği mesafeyi, mazot_ücret
ise o günkü mazot litre fiyatını temsil etmektedir.

ulasim.java
•
•
•
•
•
•
•
•
•
•

package com.atml;
class ulasim {
float yuz_km_litre;
float gidilecek_km;
float mazot_ucret;
public float maliyet_hesapla(){
yuz_km_litre*(gidilecek_km/100)*mazot_ucret;
return
}
}

INSTANCE
• Class tanımına uygun olarak yaratılan nesnelere
instance (örnek) denir. Sınıfımızın özellikler(property)
ve yöntemlerden (method) oluştuğunu biliyoruz.
Şimdi başka bir örnek içinde bir instance
oluşturacağız. Yeni oluşturacağımız nesnenin adı u
olsun

ntptest.java
• package com.atml;

• public class ntptest {
•
•
•
•
•
•
•
•
•
•

public static void main(String[] args)
{
ulasim u=new ulasim();
u.yuz_km_litre=5.2f;
u.mazot_ucret=4.5f;
u.gidilecek_km=750.5f;
float ucret=u.maliyet_hesapla();
System.out.println("Toplam Maliyet...:"+ucret);
}
}

Property Initialization
Özelliklerin değerleri belirtilmeden maliyet_hesapla metodunun çalışması
olasılığında derleyici hata üretecektir. Çünkü özelliklerin değerleri null dur.
Bu gibi sıkıntılara engel olmak için özellikler aşağıdaki şekilde
initialise(başlatma) edilmedir.

•
•
•
•
•
•
•
•
•

package com.atml;
class ulasim {
float yuz_km_litre=8.0f;
float gidilecek_km=100f;
float mazot_ucret=4.6f;
return yuz_km_litre*(gidilecek_km/100)*mazot_ucret;
}
}

Constructor
• Bir nesnenin yaratılma aşamasında bazı işlemlerin
yapılması, bazı değerlerin atanması
• gerekebilir. Bir nesne yaratılırken çağrılan method
benzeri yapıya ’constructor' denir.
• Constructor aslında bir method değildir. Ama
class’la aynı ismi taşıyan, dönüş değeri
• olmayan bir method olarak da düşünülebilir.
Prizmanın boyutlarının daha instance
• yaratılırken verilmesi bu şekilde sağlanabilir. Bir
sonraki örnekte initialise işlemini constructor
yardımıyla yapalım.

•
•
•
•
•

package com.atml;
class ulasim_constructor {
float yuz_km_litre;
float gidilecek_km;
float mazot_ucret;

•
•
•
•
•
•
•
•
•

public ulasim_constructor(float ykl,float gk,float mu){
yuz_km_litre=ykl;
gidilecek_km=gk;
mazot_ucret=mu;
}
}
}

Ulasim.java
• package com.atml;
•
•
•
•

float yuz_km_litre;
float gidilecek_km;
float mazot_ucret;

•
•
•
•
•
•
•
•
•

yuz_km_litre=ykl;
gidilecek_km=gk;
mazot_ucret=mu;
}
}
}

Örnek
• Şimdi bir örnek ile instance oluşturalım.

Ornek.java
•
•
•
•
•
•

•
•

package com.atml;
public class ulasım_c_test {
public static void main(String[] args){
ulasim_constructor uc=new
ulasim_constructor(6.7f,896f,4.5f);
float masraf = uc.maliyet_hesapla();
System.out.println("Toplam masrafınız...:"+masraf+"
TL");
}
}

Method Signature

• Bir method'un ismiyle birlikte sırasıyla aldığı
parametre tipleri, o method’un
• 'signature'unu oluşturur. Siz bir method
çağırdığınızda, öncelikle o nesnede o isimde bir
• method olup olmadığına bakılır. Eğer varsa,
çağırdığınız parametreler’in tipleriyle birlikte
• eşleştirme yapılır ve uygun bir method varsa
derleme işlemi başarılı olur. Aksi takdirde kod
• derlenemez.
• Bir nesnenin bir methodunu çağırdığınızda compiler
kızıyorsa ve siz method ismini
• doğru yazdığınıza eminseniz, bilinki verdiğiniz
paramtereler ya eksiktir, ya fazladır, ya sırası
• yanlıştır ya da parametre tipleri yanlýştır.

Overloading (Çeşitleme)
• Overloading (Çeşitleme)
• Bir metotla aynı isimde başka bir method yazılabilir. Buna
overloading (çeşitleme)
• denir. Bu işlem, benzer işlemleri farklı parameteler’le
yapan iki method için yapılır. Bu
• şekilde, bir çok method ismini öğrenmekten kurtulmuş
oluruz. Ancak, overloading işleminde
• yeni method'un signature'u mutlaka farklı olmalıdır ki bir
method çağırdığınıza hangisini
• çağırdığınız anlaşılabilsin. Zaten aynı isimde aynı
parametreleri aynı sırada alan bir ikinci
• method yazmanın hiç bir anlamı yoktur. Aynı işi
yapıyorlarsa, bir tanesine hiç gerek yok.
• Farklı işler yapıyorlarsa farklı bir isimde olmalıdır.

Birden Fazla Constructor
• Bir class'ın farklı parametreler alan birden fazla
constructor'u olabilir.
• Yani constrcutor'lar da method'lar gibi 'overload'
edilebilirler. Bir örnek verelim.

•
•
•
•
•
•
•
•
•
•
•

•
•
•
•
•
•
•
•
•

package com.atml;
float yuz_km_litre;
float gidilecek_km;
float mazot_ucret;
yuz_km_litre=ykl;
gidilecek_km=gk;
mazot_ucret=mu;
}
// Görüldüğü gibi overload ederek oluşturduğumuz ikinci
constructor iki parametreye sahip ve mazot ücretini kendisi
belirliyor
public ulasim_constructor(float ykl,float gk){
yuz_km_litre=ykl;
gidilecek_km=gk;
mazot_ucret=(float) 5.0;
}
}
}

Örnek
•
•
•
•
•
•
•
•
•
•

package com.atml;
public class ulasım_c_test {
public static void main(String[] args){
ulasim_constructor uc=new
ulasim_constructor(6.7f,896f,4.5f);
float masraf = uc.maliyet_hesapla();
System.out.println("Toplam masrafınız...:"+masraf+" TL");
ulasim_constructor ucon2=new
ulasim_constructor(6.7f,896f);
float masraf1 = ucon2.maliyet_hesapla();
System.out.println("Toplam masrafınız...:"+masraf1+" TL");
} }
Görüldüğü gibi iki ayrı nesne (uc,ucon2) iki ayrı constructor kullanıyor.

Package
• Birbiriyle işlev veya kullanım açısından ilişkili class’lar
’package' adı verilen bir birim
• altında birleştirilir. Bir class’ın ait olduğu package’i
belirtmek için ’package' keyword'ü
• kullanılır.
• package mypackage;
• public class MyClass
• // ..
• }

• Bir class'ın diğer bir class’la aynı package’te olması,
ona bazı avantajlar sağlar.
• Aslında bütün class’lar bir package’e ait olmak
zorundadır. Hiç bir isim verilmediğinde o
• class isimsiz default package'de kabul edilir.
Package'i belirtilmemiş bütün classlar aynı
• package'in class'ları sayılır. Bazı durumlarda sadece
örnek olsun diye yapılıp hatalı
• (derlenemez durumda) bırakılan class, yine
package’siz olan başka bir class’ın derlenmesini
• engelleyebilir.

• Import
• Bir class'ın kendisiyle aynı package’de olmayan class’ı
kullanabilmesi için, class tanımından önce import etmesi
gerekir. Bu sadece kullanılacan class’ların tam olarak
hangi pakette olduğunu söylemek anlamına gelir. Bunun
için ’import' keyword'ü kullanılır.
• package myanotherpackage;
• import mypackage.MyClass;
• public class MyAnotherClass
• // ..
• }
• Burada sadece kullanılacağı belirtilmektedir. Yoksa,
import edilen class’ın import eden
• class'ın üzerine ’include' edilmesi (eklenmesi) sözkonusu
değildir.
• 'java.lang' package'indeki class'ları kullanmak için import
ifadesine gerek yoktur. Bu package olmadan hiç bir
Java programı yapılamayacağı için, default olarak
import edilmiş
• sayılır.

• ’*’ Operatörüyle Import
• Bir package'deki bütün class’ları import etmek için ’*'
operatörü kullanılabilir.
• package myanotherpackage;
• import mypackage.*;
• public class MyAnotherClass
• // ..
• }
• Bu işlem, altalta çok sayıda import ifadesi yazmaktan
daha kolaydır.
• '*' operatörü kullanıldığında bir çok class’ın gereksiz yere
import edildiği gibi bir izlenim doğmakla birlikte, import
işlemi aslında bir belirtmeden öteye gerçek bir ’içine
alma’ işlemi
• anlamına gelmediği için önemli bir performans kaybına
yol açmaz. Sadece bazı programcılar okunurluğu
arttırmak için böyle bir yola gitmektedirler.

• Fully-Qualified Name (Tam Nitelendirilmiş ısim)
• Aslında her class package ismiyle birlikte adlandırılır.
Örneğin, ’mypackage’ isimli bir package'de
'MyClass' isimli bir class'ın tam nitelendirilmiş ismi
mypackge.MyClass’ dır.
• Import ifadesi, sadece programcıyı her class ismini
böyle uzun yazmaktan kurtarmaktadır.
• 'java.awt' package'inde olan Button adlı class’ın bir
instance’ını ’import java.awt.*’ diyerek kullanırsak
• Button b=new Button();
• şeklinde yaratabiliriz. Hiç ’import’ kullanmayarak
aynı ifadeyi
• java.awt.Button b=new java.awt.Button();
• şeklinde de yazabiliriz. Bu şekilde paket ismiyle
birlikte verilen class isimlerine fullyqualified name
denir.

• Bir class'ta üst package’i import etmek, otomatikman alt
package’lerin de import edileceği anlamına gelmez. Örneğin,
’java.awt.*’ ifadesi ’java.awt.event.*’ ifadesini içermez. Bu alt
• package'den herhangi bir class kullanılacaksa ayrıca import
edilmesi gerekir.
• Standart Package’ler
• Java'nın kendi API’ı (Application Programming Interface Uygulama Programlama Arayüzü’ü) bir çok class’dan oluştuğu
için bir çok package altında gruplandırılmıştır.
• Bunların çoğu ’java.’ ve ’javax.’ la başlar. ’javax’ öneki daha
çok, sonradan extension (ekleme) package'ler için kullanılır.
Önceden ’extension’ olan package’ler daha sonra
• standart API'a dahil olabilmektedir.
• Java'nın standart package’leri benzer ve ilişkili class'lardan
oluşur. Her package’de bulunan class'ların ezberlenmesine
gerek yoktur. Sadece her package’de ne tür class’ların
• bulunduğu öğrenilmesi yeterlidir. Örneğin, arayüzle ilgili
class’lar ’java.awt’dedir. Görsel bir bileşen olarak Button bu
package’tedir. Yine görsel bir bileşen olan text alanı’nın
• (TextArea'nın) da bu package’de olması gayet doğaldır.

• Naming Convention (ısimlendirme Geleneği)
• Package isimlerinin rastgele verilmesi, bir sistemde farklı
kurumlara ait package’leri bulunması durumunda ’name
collision' (isim çarpışması) adı verilen bir sorun
yaratabilmektedir. Aynı package ismini başka bir kurum da
kullandıysa ne olacak?
• Örneğin siz package’in adını ’myapplets’ koydunuz. Sistemde
aynı isimde başka bir kuruma ait bir package daha var
tesadüfen. Java önce hanginizinkini bulursa onu yükler. Sizinki
• önce bulunuyorsa onların package’i doğru çalışmaz, onlarınki
önceyse sizinki.
• Bu sorunlarla karşılaşmamak için package isimlerinde standart
bir yöntem uygulanır. Bir kurum, sahip olduğu ınternet domain
ismini tersten yazarak package isimlerinin önüne
• ekler. Örneğin ’godoro.com’a sahip olan kurum veya kişiler,
chat appletlerini 'com.godoro.chat' diye bir package'e
koyabilirler. ChatApplet isimli biri class için fullyqualified
• class name 'com.godoro.chat.ChatApplet' şeklinde olur.
Java’yı ortaya çıkaran
• 'Sun' firması da kendi package’lerini ’com.sun.’ şeklinde
başlatmaktadır. Özel kuruluşlar com., ticari olmaytan kurumlar
da org. ile başlarlar.

• Aynı Package’teki Class’lar
• Aynı package’deki class’lar birbirlerinin private
olmayan property ve methodlarına, onlar public
olmasala bile ulaşırlar. Ayrıca, aynı package’deki
class’ların birbirlerini ’import’ etmeleri gerekmez.
• Class'lar '.java' uzantılı dosyalarda bulunabilirler. Bu
dosya aslında bir compilation unit
• (derleme birimi)dir (). Bir dosyada birden fazla class
alt alta tanımlanabilir. Ancak en fazla bir tanesi
'public' olabilir. Ve dosyanın (derleme biriminin) adı
bu public class’ın adıyla aynı olmalıdır. Bu class
derleme biriminin asıl class’ıdır ve adı eğiştirildiğinde
dosyanında adı değiştirilmelidir. Tek dosyada
bulunan class’lar derlendiğinde her biri için ayrı
.class üretilir. Yani derlendikten sonra class’lar
birbirinden ayrılırlar. Bir derleme
• biriminde sadece bir tane class bulundurmak,
zorunlu olmasa da bir gelenek halini almıştır.

•
•
•

•

•
•

•

Encapsulation
Encapsulation Kavramı
Her class çeşitli üyelerden (property ve method’lardan) oluşur. Hemen hemen
bütün
class'lar başka bir class tarafından kullanılmak amacıyla üretildiğinden, bazı
üyeler sadece dışarıdan kullanılmak üzere hazırlanmıştır. Buna karşı bazı property
ve method’lar, diğerlerine yardımcı olmak, sadece onlar tarafından class’ın iç
işlerinde kullanılmak için yazılırlar. Belli bir class’ı kullanan class’ın bunları görmesi
veya bilmesi gerekmez. Hatta bazı durumlarda property ve method’ların sadece
ufak bir kısmı dışarısı tarafından kullanılır. Bir insanın belli bir class’a baktığında
üyelerden hangisi kendisinin işine yarar, hangisi sadece başka methodlarda
kullanılmak için yapılmıştır ve class’a özel’dir anlaması çok zor olabilir. Bazı
durumlarda da güvenlik ve sağlamlık sağlamak amacıyla bir class’ı kullanan
class'ın bazı property’leri değiştirmesi ve bazı methodlara erişmesi engellenmek
istenebilir. Bazı property ve methodların ait olduğu class’ın dışında erişimini
sınırlama özelliğine 'encapsulation' (kapsülleme) denir. Encapsulation sağlamak
için private, public ve proteced sözcükleri kullanılır. Bunlara access modifier
(erişim değiştirici) denir. Hiç birini kullanmak da bu bağlamda belli bir tercih
anlamına gelir.
Default Access
Hiç bir access modifier kullanılazsa, yani bir property ve methodun başında
private, protected ve public keyword'lerinden hiç biri kullanılmazsa bu üye
’package private' olur.
Yani ona sadece aynı package’deki diğer class’lar erişebilir, diğer
package’lerdekiler erişemez.

Read Only Property
•
•
•
•
•
•

public class sinifim{
private int value=3;
public int getValue(){
return value;
}
}

Applicationda instance
oluşturalım
•
•
•
•
•
•
•
•
•
•

public class app{
public static void main(){
sinifim d=new sinifim();
int v=d.getValue();
System.out.println("Value : "+v);
}
}
Buradaki value private olduğu için
int v=d.value;
Derleyicinin hata vermesine yol açacaktır.

Read/Write Only Property
•
•
•
•
•
•
•
•
•
•
•
•

public class sinifim{
private int value=3;
public int getValue(){
return value;
}
public void setValue(int v){
if(v>0){
value=v;
}else{
value=-v;
} } }
İstenirse sinifim classında getValue() metodu çıkarılarak
sadece Write only property yapılmış olur.

Applicationda instance
oluşturalım
•
•
•
•
•
•
•
•
•

public class app{
public static void main(){
sinifim d=new sinifim();
d.setValue(-7);
int v=d.getValue();
System.out.println("Value : "+v);
}
}
İstenirse sinifim classında getvalue() metodu
çıkarılarak sadece Write only property yapılmış olur.

•
•

•
•

•
•
•
•
•
•
•
•

Protected Access
Bazı durumlarda bir property veya method’un dışarıya kapalı
olmasını ancak o class’ı extend edenlere açık olması istenebilir. Bu
durumda 'protected' erişim değiştiricisi kullanılır.
Bir class diğerini extend ederse, onun bütün public property’lerin
erişebilir hale gelir. Zatenbunlara her class'ın erişebilmektedir. Hiç
bir private property extend eden class’a geçmez.
Bunlar diğer bütün class’lara da kapalıdır. Ancak protected
property ve methodlar dışarıya kapalı oldukları halde, extend
edilen class bunlara erişim hakkına sahiptir. Bu keyword, belli bir
property veya method'un sadece onu extend eden class'ları
ilgilendirmesi durumunda
kullanılır.
Erişim değiştirici olarak protected verilmiş property veya
method’lara o class’la aynı package içerisindeki bütün class'lar
tarafından da erişilebilir.
Erişim Düzeyleri Sıralaması
Encapsulation düzeyleri için
public > protected > ’default’ > private
şeklinde bir sıralama yapılır. Büyük olan düzey küçük olanların
haklarını da kapsar. Bir
property'nin public olup private özelliği içermemesi, yani
tanımlandığı class’tan erişilemez
ama onun dışındaki bütün class’lardan erişilmesi gibi bir durum söz
konusu olamaz.

• Inheritance (Kalıtım)
• Inheritance Kavramı
• Bir class'ın başka bir class’daki property ve method’lara
sahip olmasına inheritance
• denir.. Belli bir class, daha genel bir kavramı ifade eden
class’ın üyelerine sahip olarak, onları
• tekrar tanımlamak zorunda kalmaz. Bir class’ın
diğerindeki özellikleri miras olarak alması
• için kullanılan keyword ’extends' dir. Anlam olarak "Bu
class şu class’ı ’genişletir’ yani
• ondaki property ve methodları alır ve yenilerini ekler"
demektir.
• Inheritance, bazı durumlarda başka birinin yazdığı
class’a bazı eklemeler yaparak belli bir
• işlem için kullanılır hale getirmek için kullanılabilir.
Böylelikle sadece o class’ta olmayan
• property ve methodları eklemek suretiyle çok kısa sürede
gelişmiş bir class sahibi olabilir.
• Bazen de ortak bir çok özellik içeren iki nesnede de
aynen bulunan property ve methodları
• tanımlamaktan kurtulmak için kullanılabilir.

Extends Kullanımı
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•

Kullanıma örnek verebilmek adına daha önceden kullandığımız
ulasim_constructor.java sınıfının propertilerini aşağıdaki şekilde protected olarak
düzenledik.
package com.atml;
Protected float yuz_km_litre;
Protected float gidilecek_km;
Protected float mazot_ucret;
public ulasim_constructor()
{
yuz_km_litre=8.8f;
gidilecek_km=900f;
mazot_ucret=5.0f;
}
yuz_km_litre=ykl;
gidilecek_km=gk;
mazot_ucret=mu;
}
public ulasim_constructor(float ykl,float gk){
yuz_km_litre=ykl;
gidilecek_km=gk;
}
}}

Ulasim_ver2.java
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•

•

package com.atml;
public class ulasim_ver2 extends ulasim_constructor
{
//yeni property ile yol zorluğunu da maliyete ekleyeceğiz
public float yol_zorluk_oran=1.0f;
public ulasim_ver2(float a,float b,float c,float d)
{
//super sınfın constructorunu çağırarak değerleri super sınıftaki
//değişkenlere aktardık
super(a,b,c);
yol_zorluk_oran=d;
}
//yol_durum hesaba katılarak yapılan yeni maliyet_hesaplav2
//metodu
public float maliyet_hesaplav2()
{
return
yuz_km_litre*(gidilecek_km/100)*mazot_ucret*yol_zorluk_oran;
}}

App_ulasim_ver2.java
application ile örnek
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•

package com.atml;
public class app_ulasim_ver2 {
public static void main(String[] args)
{
//uv2 adında nesne oluşturduk ve değerleri aşağıdaki //gibi verdik
ulasim_ver2 uv2=new ulasim_ver2(5f,1000f,5.0f,1.5f);
float ucret= uv2.maliyet_hesaplav2();
System.out.println("Yol Durumuna Bağlı Toplam Maliyet...:"+ucret);
//Alt satırda miras aldığımız metodunu kullanmış olduk.
float ucret2= uv2.maliyet_hesapla();
System.out.println("Yol Durumuna Bakılmaksızın Toplam
Maliyet...:"+ucret2);
}}
Çıktı:
Yol Durumuna Bağlı Toplam Maliyet...:375.0
Yol Durumuna Bakılmaksızın Toplam Maliyet...:250.0

Extends
• Görüldüğü gibi yeni bir sınıf oluşturarak yol_durum
adında bir diğer property ve maliyet_hesaplav2
metoduyla yeni bir sınıf yaratmış ve eski sınıfın hem
constructorını çağırmış, hem de property ve metodlarını
kullanmış olduk.
• Bir constructor'ın diğerini çağırması durumunda super
ifadesi kesinlikle ilk satırda belirtilmelidir. Herhangi bir kod
parçası yazıldıktan sonra super class'ın bir constructor’u
• çağrılamaz.
• Super class'ın constructor’u açık olarak çağrılmadıkça,
parametresiz olan super()
• constructor'un çağrıldığı varsayılır. Super constructor’un
böyle bir constructor’u yoksa
• mutlaka parametreli bir constructor çağrılmalıdır. Aksi
takdirde derleyici hata verir.

Overriding (Ezme)
• Bir subclass super class'ının bir methodunun
davranışını yeniden yazabilir, yani
• super'dekini ezebilir. Buna overriding denir. Bunun
için aynı üst class’ın method’unun
• signature'uyla aynı olmalıdır. Bu işlem bazen
methodun tamamen değiştirme, bazen de
• sadece bir ekleme yapma şeklinde yapılır.
• @Override
• public float maliyet_hesapla()
• {
• return
yuz_km_litre*(gidilecek_km/100)*mazot_ucret*yol_z
orluk_oran;
• }
• Maliyet_hesaplav2 metodu yerine Override ettik.

Overriding (Ezme)
• Override eden method, override edilen methodu
çağırabilir. Ancak ikisinin de adı da
• parametreleri de aynı olduğu için super anahtar
sözcüðü kullanılır.
•
•
•
•
•
•

@Override
public float maliyet_hesapla()
{
float sonuc=super.maliyet_hesapla();
return sonuc*yol_zorluk_oran;
}

Overload
• Super class'da olan bir method'un ismiyle aynı farklı
parametreler alan bir method
• yazlıabilir. Ama bu durumda overriding değil
overloading yapılmış olur. Yani var olan bir
• method'u değiştirmek yerine yeni bir method
eklenmiş olur. ılk method çağrıldığında yine
• eskisi gibi çalışır.
• -----Ulasim_ver2.java--• public float maliyet_hesapla(float a)
• {
• float sonuc=super.maliyet_hesapla();
• return sonuc*a;
• }

Multiple Inheritance
• Multiple Inheritance (Çoklu Kalıtım)
• Java'da 'multiple inheritance', yani bir class'ın iki
veya daha çok class’ı extend etmesi,
• onların property ve method’larını miras alması
mümkün değildir. C++ gibi diğer nesneye
• yönelik dillerde bu mümkündür ama Java’da kafa
karışıklığına, çalışma zorluğuna, birbirine
• girmiş yapılar yaratmaya neden olduğu için izin
verilmemiştir. Java’daki single inheritance
• (tekli inheritance)da hangi class'ın hangisini extend
ettiği bir ağaç yapısı şeklinde net bir
• şeklide görülmektedir. Aslında bu yazılım tasarımı
açısından da gereklidir. Örneğin bir

Multiple Inheritance
• hayvan hem memeli hem de kuş olmaz. Hem balık hem
memeli olmaz. Hatta yarasa uçsa
• bile, balina yüzse bile onlar birer memelidir. Yarasanın
kuşlar gibi uçtuğunu görüp onu hem
• memeli hem kuş saymak ne kadar yanlışsa, bir class’ı iki
ayrı class’ın özelliklerine birden
• sahip olması gerektiğini düşünmek o derece yanlıştır.
Eğer tasarımınız bunu zorunlu kılıyorsa
• ya yanlış tasarım yapmışsınızdır ya yanlış çözümleme
yapmışsınızdır. Çoklu kalıtımın
• gerekli gibi göründüðü durumlarda başka çözüm yolları
devreye girer. Bunları programcı ve
• sistem tasarımcıları Java’da bilgi ve deneyimlerini
arttırdıkça öğrenebilirler. Örneğin iki
• class'ı extend etmek yerine birini extend etmek, diğerini
bir property olarak tanımlamak ve
• kullanmak mantıklı bir çözüm olabilir..

Arayüz
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•

Java dilinde interface adını taşıyan, tasarım şablonlarında ve
modellemede kullanılan sınıflar
tanımlamak mümkündür. Bir interface normal bir Java sınıfından farksız bir
şekilde
tanımlanır. Sınıf tanımlanırken class yerine interface terimi kullanılır.
Nesneye yönelik programlama dillerinde (örneğin C++) tamamen soyut
(abstract) sınıflar
tanımlanarak oluşturulabilecek interface benzeri sınıflar için Java dilinde
interface ve
implements gibi özel kelimeler (keywords) mevcuttur. Bu Java diline esnek
yazılımlar
yapılabilmesi adına büyük zenginlik katmaktadır. Bunun nasıl yapıldığını
görmeden önce, bir
interface sınıfın ne olduğunu görelim.
package org.javatasarim.interfaces.oernek1;
public interface Tasit
{
public String getMarka();
}
Java’da tanımlanmış bir interface sınıftan, normal bir sınıfta olduğu gibi
new() operatörü ile
bir nesne oluşturulamaz!

Bu arayüzü kullanacak bir
sınıf oluşturalım.
•
•
•
•
•
•
•
•

public class Audi implements Tasit
{
public String getMarka()
{
return "Audi A4";
}
}

Oluşturduğumuz sınıfa
ait bir uygulama..
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•

/**
* TasitTest2 sinifi
*
* @author Oezcan Acar
*
*/
public class TasitTest2
{
/**
* Bu örnekte, new operatörü kullanilarak, bir Audi marka
* tasit ürettik. Tasit interface'ini kullanan main metodu
* Tasit veritipinde bir nesne tanimliyor. Bu nesne
* Tasit interface'ini implemente eden herhanigi bir sinif
* olabilir.
*
* @param args
*/
public static void main(String args[])
{
Tasit tasit = new Audi();
System.out.println(tasit.getMarka());
}
}

Abstract (Soyut) Sınıf
• Ortak özellikleri olan nesneleri modellemek için Java
dilinde soyut sınflar kullanılır.
• Soyut sınıflardan interface sınıflarında olduğu gibi
somut nesneler oluşturulamaz.
• package org.javatasarim.abstractclass;

•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•

/**
* BinekOto sinifi
public abstract class BinekOto
{
private String marka;
private int ueretimYili;
private int vitesAdedi;
/**
* Altsiniflar tarafindan implemente
* edilmek zorunda olan bir metod.
* @return marka String
*/
public abstract String getMarka();
/**
* Altsiniflar tarafindan kullanilabilir
* yada tekrar re-implemente edilebilir
* bir metod.
*/
public int getUeretimYili()
{
return this.ueretimYili;
}
}

• Interface sınıflarının aksine, soyut sınıflarda istenilen
sınıf metodları normal bir Java sınıfında
• olduğu gibi implemente edilebilir.
• BinekOto.java sınıfı bir soyut sınıftır. getMarka()
isminde bir soyut metodu ve
• getUeretimYili() isminde normal bir metodu
bulunmaktadır. getMarka() soyut olduğundan,
• alt sınıfların bu metodu mutlaka implemente
etmeleri gerekmektedir. Aksi taktirde Java
• compiler (derleyici) resim 3 de görüldüğü şekilde
hata mesajı verecektir.

•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•

Ford isminde, BinekOto sınıfındaki özellikleri devralan bir alt sınıf tanımlıyoruz. Bunun
için
Java dilinde extend direktifi kullanılır
package org.javatasarim.abstractclass;
/**
Ford marka binek otomobil
public class Ford extends BinekOto
{
public String getMarka()
{
return "Ford Focus";
}
/**
* getUeretimYili() metodu üst sinifta
* tanimlanmistir ve alt sinifta degistirilerek
* tekrar re-implemente edilebilir yada
* degistirilmeden kullanilabilir.
*/
public int getUeretimYili()
{
System.out.println(super.getUeretimYili());
return super.getUeretimYili();
}
}

•
•
•
•
•
•
•
•
•
•
•
•
•
•

BinekOto sınıfında getMarka() soyut olarak tanımlandığı için, alt sınıflarda mutlaka
getMarka() isminde implementasyonu yapılmıış bir metodun bulunması
gerekmektedir. Ford
sınıfı, tanımlamak zorunda olmadan, BinekOto sınıfında yeralan getUeretimYili()
metodunu
ve sınıf degiskenlerini kullanabilir. Java gibi nesneye yönelik programlama (OOP =
object
oriented programming) dillerinde, ortak değerler bir ana sınıfta toplanır ve alt
sınıflarda,
sadece alt sınıf için gerekli ekleme ve değişiklikler yapılarak kullanılır. Alt sınıflar,
istedikleri
taktirde, üst sınıfta tanımlanmış bir metodu, kendi bünyelerinde değiştirebilirler
(reimplementasyon).
Soyut sınıflar, interface sınıfların aksine tecrübeli Java programcıları tarafından
yazılımda
tercih edilmezler. Kompleks sınıf hiyerarşileri, kodun bakımını ve genişletilmesini
engeller.
Bu problemi çözmek için çesitli tasarım şablonları üretilmiştir. Bunlardan bir tanesi
Composite tasarım şablonudur. Composite tasarım şablonu ile, soyut sınıflar ve bu
sınıfların
alt sınıflarını oluşturan impelentasyonları birbirinden ayırmak ve bu şekilde sınıflar
arası
bağımlılığı azaltmak mümkündür.

Abstract Class ile Interface Arasındaki Farklar
•
•

•

•
•
•
•
•
•

Abstract Class ile Interface Arasındaki Farklar
1.
Abstract class; abstract methodları barındırabildiği gibi, implement
edilmiş methodları da barındırabilir. Interface’ler ise sadece method
tanımlarını barındırabilir. Interface’ler içinde method’lar implement edilemez.
Ayrıca interface içinde tanımlanmış metodlar varsayılan olarak “abstract”
olarak tanımlanmıştır.
2.
Abstract class içinde “final” ve “static” olmayan değişkenler, veya “final”
ve “static” olan sabitler tanımlanabildiği gibi, interface’ler de sadece sabitler
tanımlanabilir. Interface içinde tanımlanan sabitler varsayılan olarak “public
final static” olarak tanımlanırlar.
3.
Bir interface içinde yer alan tüm elemanlar public olarak tanımlanmalıdır.
Fakat abstract class içindeki herşey normal class’larda olduğu gibi public,
protected ya da private olarak tanımlanabilir.
4.
Interface’ler “implements” anahtar kelimesiyle implement edilir, abstract
class’lar ise “extends” anahtar kelimesi ile kendilerinden türetilirler.
5.
Bir interface sadece başka bir interface’den türetilebilir. Abstract class ise
normal class gibi kendisinden sınıf türetebildiği gibi birden fazla interface’i de
implement edebilir.
6.
Bir Java sınıfı birden fazla interface’i implement edebildiği gibi sadece bir
tane abstract class’dan türeyebilir.
7.
Interface’ler tamamiyle soyuttur ve bu sebepten dolayı interface’lerden
instance’lar oluşturulamaz. Abstract class’larda da instance oluşturulamaz
fakat içinde main() methodu barındırıyorsa çalıştırılabilirler.
8.
Java’da bir class birden fazla class’dan türetilemediği için bu işi
interface’ler yardımıyla gerçekleştiriyoruz. Java da multiple inheritance
interface’ler yardımıyla gerçekleştiriliyor. Bir Java class’ı birden fazla interface’i
implement edebilir.

•

•
•
•
•

•

•

9.
Abstract class varsayılan olarak “Object” class’ından
türediğinden dolayı abstract class içinde “hashCode”, “toString”,
“clone” gibi methodlar kullanılabilir. Fakat böyle bir durum
interface’ler için geçerli değildir çünkü kendi içinde implement
edilmiş bir method barındıramazlar.
10. Abstract class’lar constructor’a sahip olabilir fakat
interfaceler’ın constructor’ı bulunmaz.
11. Abstract class’ın tanımlanması “abstract” anahtar kelimesiyle
yapılırken; interface’in tanımını “interface” anahtar kelimesi ile
gerçekleştiriyoruz.
12. Abstract class’lar interface’lere göre daha hızlı çalışırlar.
13. Interface’lere daha sonradan eklenen metodlar interface’i
kullanan tüm class’lar tarafından implement edilmesi
gerekmektedir. Fakat abstract class’a daha sonradan eklenen bir
method aynı abstract class içinde implement edilerek, bu
abstract class’dan türeyen subclass’lar tarafından kullanılabilir.
14. İçinde sadece soyut metodları barındıran abstract
class’lara fully abstract class, içinde hem soyut hem de somut
metodlar bulunan abstract class’lara ise partially abstract
class denir. Fully abstract class ile interface arasında fonksiyonellik
açısından bir fark bulunmamaktadır. İkisi de soyut method
barındırmaktadır.
15. Abstract class’lar sadece bir tane class’dan extend
edilebilirken; interface’ler ise bir yada birden fazla interface’den
extend edilebilirler.

KAYNAKLAR
• http://hilmi.trakya.edu.tr/ders_notlari/Java/Nesneye
_Yonelik_Programlama.pdf
• Örnekler özgün olarak hazırlanmış konu akışından
faydalanılmıştır.
• Özcan ACAR – Java Tasarım Şablonları
• Interface
• Abstract Class
• http://javamuhendisligi.blogspot.com.tr/2011/12/ab
stract-class-ile-interface-arasndaki.html
• Abstract class ile interface arasındaki farklar

�ݺ�ߣ

Oopjava

Recommended

More Related Content

Similar to Oopjava (9)

Oopjava