Java – Nesneye Dayalı Programlama Örneği(Static, Kurucu metot, Getter-Setter ve Overload içerir)

Merhaba arkadaşlar bugün nesneye dayalı programlama için bir örnek yapacağız. Aslında kafamda belirgin birşey yok. Fakat yazdıkça neler ekleyebilirim diye düşüneceğim. Öncelikle Person isimli bir class ve sadece ana metodumuzu çalıştıracağımız MainMethod adında bir class daha yarattık. Ben şöyle bir uygulama yapmak istiyorum. Şimdi bunu maddeler halinde yazayım.

1. Kişinin adı, soyadı, email, doğum yılı, boy, kilo bilgisi alınsın.
2. Email kontrolü yapılsın. Eğer içinde @ işareti yoksa “Geçersiz Mail” olarak kayıt yapılsın.
3. getYasDondur() adında bir metot olsun. Kullanıcının yaş bilgisini döndürsün. (2014’den çıkartarak)
4. Kaç kullanıcı eklendiği bilgisi alınabilsin. (Static değişken)
5. Ad ile Soyad bilgisi oluşturulan bir fonksiyonla alınabilsin.

Bu işlemleri sadece Person isimli class da yapacağız. Main fonksiyonumuz sadece person sınıfından üretilen nesneleri kullanarak bu istediklerimize erişebilcek. Aslında bu yaptıklarımızla Static anahtar kelimesinin ne işe yaradığını, private tanımlamanın önemini, nesneye dayalı programlamanın ne kadar düzenli ve ne kadar kolay olduğunu öğrenebileceksiniz.
Öncelikle değişkenlerimizi tanımlayalım.

[java] public class Person {
private String ad;
private String soyad;
private String email;
private int dogumyili;
private int boy;
private int kilo;
}
[/java]

Tanımladıktan sonra getter setter’ları oluşturalım bunun için eclipse bize bir kolaylık sunuyor. Öncelikle tüm değişkenlerimizi seçiyoruz.

Daha sonra aşağıdaki ekrandan hangi değişkenlerimiz için oluşturmak istiyorsak onları seçiyoruz. Ben hepsini seçiyorum. Daha sonra Ok diyorum.

Böylelikle getter-setter’lar oluşmuş oldu.

[java] public class Person {

private String ad;
private String soyad;
private String email;
private int dogumyili;
private int boy;
private int kilo;

public String getAd() {
return ad;
}
public void setAd(String ad) {
this.ad = ad;
}
public String getSoyad() {
return soyad;
}
public void setSoyad(String soyad) {
this.soyad = soyad;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public int getDogumyili() {
return dogumyili;
}
public void setDogumyili(int dogumyili) {
this.dogumyili = dogumyili;
}
public int getBoy() {
return boy;
}
public void setBoy(int boy) {
this.boy = boy;
}
public int getKilo() {
return kilo;
}
public void setKilo(int kilo) {
this.kilo = kilo;
}
}
[/java]

Getter-Setter’lar oluşturduk. Peki neden oluşturduk. Neden private tanımladık. Public tanımlarsak daha iyi olmaz mıydı? Diye sorular gelebilir. Ben bunlara sırasıyla cevap vermek istiyorum.
Öncelikle private nedir bundan başlamak istiyorum. Private oluşturulan değişkenler ya da fonksiyonlar sadece bulunduğu sınıf içinde kullanılabilir. Yani başka bir sınıftan asla erişilemez. Buna bir tür güvenlik önlemi diyebiliriz. Fakat private yarattığımız değişkenler için  getter-setter lar oluşturuyoruz. Yani bir nevi public hale getiriyoruz. Peki ne gerek var. Yani public tanımlayalım hiç uğraşmayalım getter setterlarla diyebiliriz. Fakat öyle değil arkadaşlar. Mesela getter-setter oluşturduğumuzda email kontrolü yapabiliriz ki yapacağız örneğimizde. daha iyi anlayacaksınız. Veya mesela kişinin isminin değişmesini istemeyebilirsiniz. isim değişkeninin setter’ını silersek kullanıcı ismi girilemez(Kurucu metot da içermiyorsa). Peki giremeyeceği bir değişkeni neden tanımlarız. İşte bu noktada da devreye kurucu metodumuz giriyor. İşte sizlere bunları anlatmaya çalışacağım. Ve umarım kafanıza bu yapılar oturacak.

Eveeet. Şimdi MainMethod isimli class’ımızın içindeki main fonksiyonunda person isimli classımızdan nesne üretip kişi bilgilerini girelim.

[java] public class MainMethod {
public static void main(String[] args) {
Person p1 = new Person();// p1 adında ilk nesnemiz
p1.setAd("Ali");//Oluşturduğumu set fonksiyonunu çağırarak işlemimizi yaptık.
p1.setSoyad("Demirci");
System.out.println("Kullanıcının Adı : "+p1.getAd());//Oluşturduğumu get fonksiyonunu çağırarak bilgimizi aldık.
}
}
[/java]

Üstteki komutları incelediğimizde ilk olarak Person sınıfımızdan p1 adında bir nesne türettik ve o nesnenin içindeki değişkenlere değer vermek için. Oluşturduğumuz Set fonksiyonunu kullandık. Verdiğimiz değerleri göstermek için Get metodunu kullandık. Böylelikle private olarak yarattığımız değişkenlere erişebilmiş olduk.
Şimdi ekran çıktısını görelim.

Şimdi ikinci bir nesne yaratalım. Ve nesneye dayalı programlamanın neden gerekli olduğunu anlamış olalım.

[java] public class MainMethod {
public static void main(String[] args) {
Person p1 = new Person();// p1 adında ilk nesnemiz
p1.setAd("Ali");//Oluşturduğumu set fonksiyonunu çağırarak işlemimizi yaptık.
p1.setSoyad("Demirci");
System.out.println("Kullanıcının Adı : "+p1.getAd());//Oluşturduğumu get fonksiyonunu çağırarak bilgimizi aldık.
Person p2 = new Person();//ikinci nesnemizi oluşturduk
p2.setAd("Veli");
System.out.println("Kullanıcının Adı : "+p2.getAd());
}
}
[/java]

Eveeeet. Böylelikle istediğimiz kadar nesne oluşturup istediğimiz kadar kişinin bilgisini girebiliriz. Nesne çağırarak böyle kolay bir biçimde istediğimizi yapabiliriz.

Şimdi neden getter-setter bunu uygulamalı olarak anlayalım. Ve en başta yazdığım ikinci soruyu yapmaya başlayalım.
2. Sorum : Email kontrolü yapılsın. Eğer içinde @ işareti yoksa “Geçersiz Mail” olarak kayıt yapılsın.
Bunu iki yolla yapabiliriz.(Düşününce bir sürü yol daha çıkabilir)
1. YOL : Bildiğiniz gibi mail adresini girmek istediğimizde set metodunu çağırarak işlemimizi yapıyorduk. Bunun için setEmail metodumuzu buluyoruz. Ve aşağıdaki şekilde değiştiriyoruz.

[java] public void setEmail(String email) {
if(email.contains("@")){// eğer @ işareti içeriyorsa true döner
this.email = email;
}else{
this.email = "Geçersiz Mail";
}
}
[/java]

Şimdi main fonksiyonumuzda p1 nesnesi için @ işareti bulunan bir mail adresi, p2 nesnesi için ise @ bulunmayan bir mail adresi girelim.

[java] public class MainMethod {
public static void main(String[] args) {
Person p1 = new Person();// p1 adında ilk nesnemiz
p1.setAd("Ali");//Oluşturduğumu set fonksiyonunu çağırarak işlemimizi yaptık.
p1.setSoyad("Demirci");
p1.setEmail("[email protected]");
Person p2 = new Person();//ikinci nesnemizi oluşturduk
p2.setAd("Veli");
p2.setEmail("velikomurcugmail.com");
System.out.println("p1 nesnesinin maili : "+p1.getEmail());
System.out.println("p2 nesnesinin maili : "+p2.getEmail());
}
}
[/java]

Ve F11 e basıp çalıştırdığımızda aşağıdaki gibi çıktı alırız.

Görüldüğü üzere istediğimizi yapabildik. Getter-Setter kullanmasak bunu yapmamız imkansızdı. İşte bu yüzden private oluşturalım ki kontrolünü de yapabilelim. Şimdi ikinci yola geçelim. Aslında ne gerek var diyebilirsiniz. Fakat gerek görünüm olarak gerek düzen olarak bu yapıyı kullanmanızı öneririm.
Bunun için düzenlediğimiz setEmail metodunu ve kendimizin oluşturacağı getEmailKontrol adlı metodu kullancağız.
getEmailKontrol metodunu görelim şimdi.

[java] private String getEmailKontrol(String email){
if(email.contains("@")){// eğer @ işareti içeriyorsa true döner
return email;
}else{
return "Geçersiz Mail";
}
}
[/java]

private tanımlamamızın sebebi sadece kendi classımızda kullancağımız için. Public tanımlayıp diğer sınıfların görmesine gerek yok.

Şimdi setEmail metodumuzu görelim.

[java] public void setEmail(String email) {
this.email = getEmailKontrol(email);
}
[/java]

Şimdi aşağıdaki main fonksiyonumu çalıştırıp sonucu tekrar görelim.

[java] public class MainMethod {
public static void main(String[] args) {
Person p1 = new Person();// p1 adında ilk nesnemiz
p1.setAd("Ali");//Oluşturduğumu set fonksiyonunu çağırarak işlemimizi yaptık.
p1.setSoyad("Demirci");
p1.setEmail("[email protected]");
Person p2 = new Person();//ikinci nesnemizi oluşturduk
p2.setAd("Veli");
p2.setEmail("velikomurcugmail.com");
System.out.println("p1 nesnesinin maili : "+p1.getEmail());
System.out.println("p2 nesnesinin maili : "+p2.getEmail());

}
}
[/java]

Gördüğünüz gibi aynı sonuç döndü. Fakat daha düzenli bir yapıya büründü.

Şimdi üçüncü sorumuza geçelim.
Soru 3 : getYasDondur() adında bir metot olsun. Kullanıcının yaş bilgisini döndürsün. (2014’den çıkartarak)
Bunu public yapmamız gerekmektedir. Çünkü diğer sınıflardan direk yaş bilgisini alarak işlem yapabiliriz. Zaten private tanımlarsak sadece kendi sınıfında erişilebileceğinden oldukça mantıksız oluyor böyle bir fonksiyon oluşturmamız.
Aşağıdaki komutları Person classımız içine yazıyoruz.

[java] public int getYasDondur(){
return 2014 – this.dogumyili;
}
[/java]

main fonksiyonumu aşağıdaki gibi düzenleyip F11′ basıp çalıştırıyoruz.

[java] public class MainMethod {
public static void main(String[] args) {
Person p1 = new Person();// p1 adında ilk nesnemiz
p1.setAd("Ali");//Oluşturduğumu set fonksiyonunu çağırarak işlemimizi yaptık.
p1.setSoyad("Demirci");
p1.setEmail("[email protected]");
p1.setDogumyili(1991);
Person p2 = new Person();//ikinci nesnemizi oluşturduk
p2.setAd("Veli");
p2.setEmail("velikomurcugmail.com");
p2.setDogumyili(1990);
System.out.println("p1 nesnesinin yaşı : "+p1.getYasDondur());//return tipli oluşturduğumuz için int türünde bir değişkene de istersek atabiliriz
System.out.println("p2 nesnesinin yaşı : "+p2.getYasDondur());
}
}
[/java]

Ve şimdi static oluşturacağımız değişkene.. Static oluşturmadan önce kurucu metot oluşturmayı ve ne işe yaradığını anlatmaya çalışayım.
Kurucu metot, void ya da return değeri olmayan sadece barındığı class ismiyle oluşturulabilen, istenirse birden fazla oluşturulup(farklı tür parametreler olmak zorunda), veri girmemizi kolaylaştıran metotlardır. Şimdi kurucu metodumuzu oluşturalım. Bunun için CTRL+SPACE tuşlarına basıp ilk seçeneği seçersek otomatik olarak oluşturacaktır.

[java] public Person() {
// TODO Auto-generated constructor stub
}
[/java]

Aslında bunu biz oluşturmasak bile java(JVM) kendi kendine arkaplanda oluşturuyordu. Fakat biz değişiklikler yapacağımız için oluşturmamız gerekti.

Şimdi 4. Sorumuz olan “Kaç kullanıcı eklendiği bilgisi alınabilsin. (Static değişken)” sorusunu çözebilmek için aşağıdaki komutları Person sınıfına ekliyoruz.

[java] public static int kisiSayisi= 0;
[/java]

kişi sayısını dinamik bir biçimde artması için yani her nesne yarattığımızda(p1,p2) baştan başlamayarak(ilk değeri 0 vermiştik) artması için static anahtar kelimesini de ekledik. Eğer static yazmasaydık, Her nesne ürettiğimizde kisisayisi 0 dan tekrar başlardı ve 1 değerini asla geçmezdi. static kelimesini yazdığımız değişkenler ya da metotlar bellekte bir yeri işgal eder. Biz onları çağırdığımızda, kullandığımızda aynı bellek adresi üzerinden işlem yapar. Bu yüzden gereksiz görülen metotlara ya da değişkenlere static anahtar kelimesini atayarak belleğimizi boşuna harcamayalım. Fakat böyle bir problem için static anahtar kelimesini kullanmak doğru bir adımdır.
Şimdi sorumuza dönelim ve kurucu metodumuza aşağıdaki komutlarla tekrar düzenleyelim.

[java] public Person() {
// TODO Auto-generated constructor stub
kisiSayisi++;
}
[/java]

Böylelikle her nesne oluşturduğumuzda kurucu metotu da çağıracağından otomatik olarak kisi sayısı 1 artacaktır. Şimdi main fonksiyonunda kişi sayımızı görelim.

[java] public class MainMethod {
public static void main(String[] args) {
Person p1 = new Person();// p1 adında ilk nesnemiz // kisisayisi = 1
Person p2 = new Person();//ikinci nesnemizi oluşturduk // kisisayisi = 2
System.out.println(Person.kisiSayisi); // static değişkenimiz bellekte otomatik olarak yer kapladığından Classismi.StaticDegiskenAdı yazarak çağırabiliriz.
}
}
[/java]

Eğer static oluşturmasak private olarak getter-setterlarını oluşturarak arttırsak ya da public yaratıp kurucu metodun içinde arttırsak asla 2 cevabını alamazdık. İsterseniz deneyebilirsiniz:)
Üstteki main fonksiyonunu çağırdığımızda aşağıdaki gibi konsol çıktısı verir.

Ve sıra geldi son sorumuza.
Soru : Ad ile Soyad bilgisi, oluşturulan bir fonksiyonla alınabilsin.
Person sınıfımıza aşağıdaki fonksiyonu oluşturalım.

[java] public String getAdSoyadGetir(){
return this.ad + " "+this.soyad;
}
[/java]

Ve main fonksiyonumuza da aşağıdaki gibi düzenleyerek çalıştıralım.

[java] public class MainMethod {
public static void main(String[] args) {
Person p1 = new Person();// p1 adında ilk nesnemiz // kisisayisi = 1
p1.setAd("Ali");
p1.setSoyad("Demirci");
System.out.println(p1.getAdSoyadGetir());
}
}
[/java]

Görüldüğü gibi tüm sorularımızı başarıyla çok az kod yazarak gerçekleştirdik.
Şimdi sizlere birkaç bilgi daha vermek istiyorum. Biraz önce kurucu metotumuzu oluşturmuştuk. Şimdi o metodu overload edelim. Yani farklı parametrelerle aynı adla bir metot daha oluşturalım.

[java] public Person(String ad, String soyad, String email) {
this.ad = ad; // this anahtar kelimesi böyle durumlarda değişkenlerin karışmamasını sağlıyor.
// yani buradaki this kelimesi en üstte oluşturduğumuz private değişkenleri işaret ediyor.
this.soyad = soyad;
setEmail(email); // kontrol mekanizmasının işlemesi için setEmail fonksiyonunu çağırdım
//this.email = email; yazabilirdim. Fakat kontrol mekanizmam çalışmadan her yazılanı olduğu gibi eklerdi.
kisiSayisi++;
}
[/java]

Ve şimdi main fonksiyonumuzda bu oluşturduğumuz kurucu metodu çağıralım.

[java] public class MainMethod {
public static void main(String[] args) {
Person p1 = new Person("Ali", "Demirci", "alidemircigmail.com");//bakalım email kontrolu yapacak mı? Yapcak yapcak:)
System.out.println("Ad ve Soyad : "+p1.getAdSoyadGetir());
System.out.println("Email : "+p1.getEmail());
System.out.println("Sadece p1 nesnesi varken ki Kişi Sayısı : "+Person.kisiSayisi);
Person p2 = new Person();
System.out.println("p1 ve p2 nesnesi varken ki Kişi Sayısı : "+Person.kisiSayisi);
}
}
[/java]

main fonksiyonunu çağırdımızda ekran çıktısı aşağıdaki gibi olur.

Ve eveeet. Artık örneğimizi bitirdik. Umarım sizlere yararlı olmuştur. Yorumlarınızı iletirseniz sevinirim arkadaşlar. Hepinizi iyi çalışmalar.