Giriş Sayfası ve CRUD Paneli (Servlet JSP / PHP)

Salı, Temmuz 07, 2015 kustemura 0 Yorum

Bu yazımda yapmış olduğum ufak bir projeyi paylaşıyorum.
Projeyi kaynak belirtmeden herhangi bir yerde kullanabilirsiniz.
Bir giriş sayfamız var,eğer giriş başarılı bir şekilde gerçekleşirse yine giriş sayfası için anlık olarak kullanıcı/yetkili oluşurup , listeleyip, güncelleyip , silebileceğimiz bir sayfa geliyor.
Veritabanı sunucusu olarak MySQL'i kullandım.Bazı işlemler için çok kısa JavaScript kullanılmıştır.

Servlet ile oluşturulan versiyonu JDBC , JSP sayfaları ise JSTL kullanılarak  MVC ve DAO Tasarım Şablonları uygulanarak Maven Project olarak Eclipse'de hazırlanmıştır.

PHP versiyonunda herhangi bir framework kullanılmamıştır.

Servlet  JSP versiyonu GitHub linki :
https://github.com/kustemura/LoginCrudServletJSPExample

Servlet JSP versiyonu Google Drive linki :
https://drive.google.com/file/d/0BytHrEwKQAMjOVJFMERZRThuRTg/view

PHP versiyonu GitHub linki :
https://github.com/kustemura/LoginCrudPHPExample

PHP versiyonu Google Drive linki :
https://drive.google.com/open?id=0BytHrEwKQAMjT3ZJRWhHTV80c1E

Aşağıdaki resimler projenin 2 versiyonundaki ekran görüntüleri bulunmaktadır.

Giriş Sayfası

 
    giriş sayfasında oluşan durumlar için bir validasyon sistemine sahip ve üst tarafta uyarılar oluşmakta .Kullanıcı adı veya şifre boş geçilirse ,

 

sistemdeki tüm kullanıcıları kaldırıp çıkış yaptıktan sonra tekrar giriş yapmayı denersek ,


 hatalı girilirse ,

 

eğer giriş yapan kişi yetkili değil ise ,  

 

kullanıcı adı ve şifre doğru girildikten sonra giren kişi yetkili ise CRUD paneli ve kullanıcı listesi sayfası ekranı gelmektedir.



Yapılan diğer işlemlerde oluşan ekran görüntüleri aşağıdadır.
         
 aynı isme sahip eklemelere izin verilmez.

 

Güncelleme yapılacağı zaman sadece kullanıcı adı değiştirilip şifre boş geçilirse aynı şifre geçerliliğini devam ettirmektedir.Güncellemeden önce



güncellendikten sonra ,


 
kullanıcı adı ve şifre güncellendiğinde , 

 
silinmek istendiğinde



DEVAMINI GÖRMEK İÇİN TIKLA..

0 yorum :

Java - Jenerikler ( Generics )

Pazar, Mayıs 24, 2015 kustemura 0 Yorum


Merhaba , bu yazımda Jenerikler(Generics)'den bahsedeceğim. Jenerikler Java'ya JDK 5 ile eklenmiştir.
Jeneriklerin kullanıldığı kaynak kodlar javac derleyicisinin daha önceki versiyonlarında derlenemez.
Jenerikler, Java'yı iki önemli bakımdan değiştirmiştir.Birincisi , bu yeni özellik dile yeni bir sözdizimi öğesi eklemiştir.İkincisi ise , çekirdek API'daki birçok sınıf ve method'da değişikliklere neden olmuştur.Java kodlarının yazılma biçimini temelden değiştirmiştir.
Temel olarak jenerikler terimi , parametreli tipler anlamına gelir.Bu yapı önemlidir , üzerinde çalışacakları veri tipinin bir parametre olarak belirtildiği sınıflar , arabirimler ve methodlar oluşturabilmenizi sağlar.
Jenerikler'den önce Object tipindeki referanslar yoluyla yazılan kaynak kodları hala günümüzde kullanıma devam etmektedir.Object tipindeki sorun tip güvenliği olmamasıydı.Jenerikler bu soruna çözüm olarak tasarlanmıştır.Ayrıca süreci hızlandırır artık Object ve üzerinde çalışan tip arasında dönüşüm yapılmasına gerek duyulmaz.Jeneriklerde tüm tip atamaları otomatik ve kapalı olarak yapılır.Bu şekilde Jenerikler kodunuzu tekrar kullanabilme yeteneğinizi arttırır , bunu güvenle ve kolaylıkla yapabilmenizi sağlar.Bir örnek üzerinden inceleyelim.

package com.blogger_project;
class NonGen {
 Object type;

 NonGen(final Object type) {
  this.type = type;
 }

 Object getObject() {
  return type;
 }

 void showType() {
  System.out.println("Object type'ın tipi :" + type.getClass().getName());
 }

}

class NonGenDemo {
 public static void main(final String args[]) {
  final NonGen intType = new NonGen(35);
  final int v = (Integer) intType.getObject();
  intType.showType();
  System.out.println("Değeri :" + v);

  System.out.println();

  final NonGen strType = new NonGen("Hello World!");
  final String str = (String) strType.getObject();
  strType.showType();
  System.out.println("Değeri : " + str);

  System.out.println();

  final NonGen doubleType = new NonGen(12.5);
  final Double d = (Double) doubleType.getObject();
  doubleType.showType();
  System.out.println("Değeri : " + d);

 }
}
Programın Çıktısı : 
Object type'ın tipi :java.lang.Integer
Değeri :35

Object type'ın tipi :java.lang.String
Değeri : Hello World!

Object type'ın tipi :java.lang.Double
Değeri : 12.5


Yukarıdaki programda Object tanımlamaları olduğu için NonGen'in jenerik versiyon gibi her tipte nesneyi depolayabilmesini sağlar.Ancak aynı zamanda java derleyicisinin gerçekte NonGen içerisinde depolanan verinin tipi hakkında gerçek bir bilgiye sahip olmasını önler.Bu , iki nedenle kötüdür.Birincisi depolanan veriyi elde etmek için açık tip atamaları gereklidir.İkincisi ise çalışma zamanında çeşitli türlerde tip uyuşmazlığı hataları oluşabilir. 

int v = (Integer) intType.getObject();

Burada , getObject() methodunun dönüş tipi Object olduğundan , değerin kutudan çıkartılıp v değişkeninde depolanmasını sağlamak için Integer'a tip ataması gereklidir.Tip atamasını kaldırırsanız program derlenmemez. 

intType = strType;
v = (Integer) intType.getObject();

Burada bir çalışma zamanı hatası oluşur.Çünkü intType'a strType atanır.Ancak strType bir tamsayı değil , karakter katarı içeren bir nesneye referans yapar.Bu atama sözdizimsel açıdan geçerli değildir.Çünkü tüm NonGen referansları aynıdır ve herhangi bir NonGen referansı bir başka NonGen nesnesine referans yapabilir.Ancak bu mantıksal olarak yanlıştır.getObject() methodunun döüş tipi tip atamasıyla integer yapılır ve sonra bu değeri v değişkenine atama yapılır.Sorun artık intType'in bir Integer değil bir String içeren nesneye referans yapmasıdır.İşte burada Jenerikler kullanılmadan java derleyicisinin bunu bilmesine imkan yoktur ve bir çalışma zamanı hatası ortaya çıkmıştır.Jeneriklerde aynı işlem denenseydi , derleyici sorunu yakalayacak ve bir hata bildirecekti.Bu da bir çalışma zamanı hatasını önleyecekti.Jenerikler sayesinde oluşan çalışma zamanı hataları , artık derlenme zamanı hatası haline gelmiştir.

Bir programcının en çok korktuğu şeydir bu! Eğer iyi bir programcı olmak istiyorsak , kullanacağımız herşey tüm kurallara uygun olmalıdır.İyi bir programcı çalışma zamanı hatalarına izin vermemelidir.Bir işi yapan her program doğru sonuçlar verebilir fakat doğru kullanıma sahip değildir  :)

Şimdi yukarıda ki programın Jenerik versiyonunu oluşturalım.

package com.blogger_project;

class Gen<T> {
 T type;

 Gen(final T type) {
  this.type = type;
 }

 T getType() {
  return type;
 }

 void showType() {
  System.out.println("Jenerik type'ın tipi : "+ type.getClass().getName());
 }

}

class GenDemo {
 public static void main(final String args[]) {
  final Gen<Integer> intType = new Gen<Integer>(35);
  intType.showType();
  final int v = intType.getType();
  System.out.println("Değeri :" + v);

  System.out.println();

  final Gen<String> strType = new Gen<String>("Hello World!");
  strType.showType();
  final String str = strType.getType();
  System.out.println("Değeri : " + str);

  System.out.println();

  final Gen<Double> doubleType = new Gen<Double>(12.5);
  doubleType.showType();
  final Double d = doubleType.getType();
  System.out.println("Değeri : " + d);
 }
}
Programın Çıktısı :
Jenerik type'ın tipi : java.lang.Integer
Değeri :35

Jenerik type'ın tipi : java.lang.String
Değeri : Hello World!

Jenerik type'ın tipi : java.lang.Double
Değeri : 12.5


class Gen<T> { ..

Bu kullanıma dikkat edelim.
T , bir tip parametresinin adıdır.Bu ad nesne oluşturulurken Gen sınıfına aktarılacak olan gerçek tip için bir yer tutucudur.Bu yüzden type , T'ye akratılan tipte bir nesne olucaktır.Örnekte olduğu gibi T'ye aktarılan tip Integer,String ve Double tipleri , type'ı o tipe ait bir nesne yapıyor.Java derleyicisinin gerçekte Gen'in ya da bir başka jenerik sınıfın değişik versiyonlarının oluşturulmadığını belirtmemiz gerekir.Derleyici , tüm jenerik tip bilgilerini ortadan kaldırır.Bu işleme silme( erasure ) denir.

Gen<Integer> intType = new Gen<Integer>(35);

Bu satır Gen constructoru çağrıldığında , Integer tip argümanının da belirtildiğine dikkat edelim.Bu gereklidir , çünkü referans atanacağı nesnenin (intType) tipi Gen < Integer >'dır.Bu yüzden new tarafından döndürülen referansda aynı tipe sahip olmalıdır.Değilse bir derleme zamanı hatası gerçekleşir.

Gen<Integer> intType;
intType = new Gen<Double>(35);

Yukarıdaki kod buna bir örnektir.Nesne Gen tipinde olduğundan Gen tipinde bir nesneye başvuramaz.Tip kontrolü Jeneriklerin en başlıca avantajlarından biridir.

 Jenerikler sadece nesnelerle çalışır.Jenerik bir tipte örnek deklare ederken , tip parametresine aktarılan tip sınıf tipi olmalıdır.int yada char gibi bir primitif tip kullanılamaz.

 
Gen<int> intType = new Gen<int>(35);
Örnek olarak Gen sınıfında , T'ye herhangi bir sınıf tipi aktarabilirsiniz,ancak tip parametresine bir primitif tip aktaramazsınız.


Jenerikler iki tip parametreli olarakda kullanılabilir.Aşağıdaki programı inceleyelim. 

package com.blogger_project;

class TwoGen<T, Y> {
 T type;
 Y type2;

 TwoGen(final T type, final Y type2) {
  this.type = type;
  this.type2 = type2;
 }

 T getType() {
  return type;
 }

 Y getType2() {
  return type2;
 }

 void showType() {
  System.out.println("Jenerik type'ın tipi : "
    + type.getClass().getName());
  System.out.println("Jenerik type2'ın tipi : "
    + type2.getClass().getName());
 }

}

class GenDemo {
 public static void main(final String args[]) {
  final TwoGen<Integer, String> twoType = new TwoGen<Integer, String>(35,
    "Hello World!");
  twoType.showType();
  final int v = twoType.getType();
  System.out.println("Değeri (int):" + v);

  final String str = twoType.getType2();
  System.out.println("Değeri (String):" + str);

 }
}
Programın Çıktısı : 
Jenerik type'ın tipi : java.lang.Integer
Jenerik type2'ın tipi : java.lang.String
Değeri (int):35
Değeri (String):Hello World!
DEVAMINI GÖRMEK İÇİN TIKLA..

0 yorum :

Java - instanceof Anahtar Sözcüğü

Pazar, Mayıs 24, 2015 kustemura 1 Yorum


Bu yazımda instanceof anahtar sözcüğünün ne işe yaradığını ve kullanımını anlatacağım.
Java'da geçersiz tip dönüşümü bir çalışma hatasına neden olur.Geçersiz tip dönüşümlerinin çoğu çalışma zamanında yakalanabilir.Ancak sınıf hiyerarşisindeki tip dönüşümleri ancak çalışma zamanında algılabilen geçersiz tip dönüşümleri üretebilirler.Bu bir çalışma zamanı hatası fırlatır.Java bu durumlara çözüm bulabilmek için instanceof adında bir çalışma zamanı operatoru tanımlar.
 Kullanım şekli aşağıda olduğu gibidir.

< Örnek Referans > instanceof < Sınıf Tipi>
"Örnek Referans" belirtilen sınıf tipinde ise veya belirtilen tipe dönüştürebiliyorsa true değerini döndürür. Bir örnek ile inceleyelim. 
package com.blogger_project;

/**
 * @Author    : Ali Can Kuştemur
 * @Date      : 24 May 2015
 * @File_Name : InstanceOf.java
 * @Blog      : http://kustemura.blogspot.com.tr 
 */
class Ford {
 int weight, model;
}

class Volkswagen {
 int weight, model;
}

class GT extends Ford {
 int speed;
}

class Mustang extends Ford {
 int speed;

}

class InstanceOf {
 public static void main(final String args[]) {
  final Ford car = new Ford();
  final Volkswagen car1 = new Volkswagen();
  final GT car2 = new GT();
  final Mustang car3 = new Mustang();

  if (car instanceof Ford) {
   System.out.println("car örnek referansı ,"
     + " Ford sınıf tipinin bir örneğidir.");
  }
  if (car1 instanceof Volkswagen) {
   System.out.println("car1 örnek referansı ,"
     + " Volkswagen sınıf tipinin bir örneğidir.");
  }
  if (car2 instanceof GT) {
   System.out.println("car2 örnek referansı ,"
     + " GT sınıf tipinin bir örneğidir.");
  }
  if (car3 instanceof Mustang) {
   System.out.println("car3 örnek referansı ,"
     + " Mustang sınıf tipinin bir örneğidir.");
  }
  if (car instanceof GT) {
   System.out.println("car örnek referansı ,"
     + " GT sınıf tipine dönüştürülebilir.");
  }

  System.out.println();

  Ford newCar;

  newCar = car3;

  if (newCar instanceof Mustang) {
   System.out.println("newCar örnek referansı ,"
     + " Mustang sınıf tipinin bir örneğidir.");
  }

  newCar = car2;

  if (newCar instanceof GT) {
   System.out.println("newCar örnek referansı ,"
     + " GT sınıf tipinin bir örneğidir.");
  }

  if (newCar instanceof Mustang) {
   System.out.println("newCar örnek referansı ,"
     + " Mustang sınıf tipine dönüştürülebilir.");
  } else {
   System.out.println("newCar örnek referansı ,"
     + " Mustang sınıf tipine dönüştürülemez!");
  }

  if (newCar instanceof Ford) {
   System.out.println("newCar örnek referansı ,"
     + " Ford sınıf tipine dönüştürülebilir.");
  }

 }
}
Programın Çıktısı:
car örnek değişkeni , Ford sınıf tipinin bir örneğidir.
car1 örnek referansı , Volkswagen sınıf tipinin bir örneğidir.
car2 örnek referansı , GT sınıf tipinin bir örneğidir.
car3 örnek referansı , Mustang sınıf tipinin bir örneğidir.

newCar örnek referansı , Mustang sınıf tipinin bir örneğidir.
newCar örnek referansı , GT sınıf tipinin bir örneğidir.
newCar örnek referansı , Mustang sınıf tipine dönüştürülemez!
newCar örnek referansı , Ford sınıf tipine dönüştürülebilir.
DEVAMINI GÖRMEK İÇİN TIKLA..

1 yorum :

Java - Dosya Okuma ve Dosya Yazma #2

Cumartesi, Mayıs 23, 2015 kustemura 0 Yorum


Bir önceki yazıma buradan ulaşabilirsiniz.

Bu yazımda daha gelişmiş JDK 7 sürümü ile gelen bir özellik try-with resources ile birlikte Dosya Okuma ve Dosya Yazma işlemlerini göstereceğim.

JDK 7'den önce dosya kapatma işlemi halen geçerli ve faydalı olmasına rağmen , yeni özellik ile kapatma işlemini otomatik hale getirerek daha kullanışlı bir yapı oluşturur.

Artık bu yeni özellik ile close() methodunu çağırmamıza gerek yoktur.Bir başka deyişle dosyayı kapatmayı unutmamıza imkan yoktur.
Hemen örnek üzerinde bunu görelim.


package com.blogger_project;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

class FileRead {
 public static void main(final String args[]) {
  int i;

  try (FileInputStream input = new FileInputStream("C:\\first.txt");
    FileOutputStream output = new FileOutputStream("C:\\second.txt")) {

   do {
    i = input.read();
    if (i != -1) {
     output.write(i);
    }

   } while (i != -1);
  } catch (final IOException e) {
   e.printStackTrace();
  }
 }
}
Bu program ile " Dosya Yazma " bölümündeki program aynı işlemi yapar.Daha kısa ve sade bir kullanıma sahiptir.Ayrıca daha kullanışlıdır.
try (FileInputStream input = new FileInputStream("C:\\first.txt");
    FileOutputStream output = new FileOutputStream("C:\\second.txt")) {
Buradaki kullanıma dikkat edelim.try bloğu sonlandığında otomatik olarak input ve output dosya işlemleri kapatılacaktır.
DEVAMINI GÖRMEK İÇİN TIKLA..

0 yorum :

Java - Dosya Okuma ve Dosya Yazma

Cumartesi, Mayıs 23, 2015 kustemura 0 Yorum


Merhaba bu yazımda Java'da Dosya İşlemleri ile ilgili en çok kullanılan 2 yapıyı anlatacağım. 

FileInputStream(String fileName) throws FileNotFoundException
FileOutputStream(String fileName) throws FileNotFoundException
Buradaki fileName açmak istediğiniz dosyanın ismini belirtir.Eğer dosya bulunamaz ise IOException sınıfının bir alt sınıfı olan FileNotFoundException'ı fırlatır.

Yapılan dosya işlemleri tamamlandığında close() methodu ile kapatılmalıdır.Aksi takdirde sistem kaynakları serbest kalır ve burada bir güvenlik açığı meydana gelmiş olur.

1 - Dosya Okuma

Örnek üzerinden anlatayım :

package com.blogger_project;

import java.io.FileInputStream;
import java.io.IOException;

class FileRead {
 public static void main(final String args[]) {
  int i;
  String str = "";
  FileInputStream input = null;

  try {
   input = new FileInputStream("C:\\first.txt");

   do {
    i = input.read();
    if (i != -1) {
     str += (char) i;
    }
   } while (i != -1);
  } catch (final IOException e) {
   e.printStackTrace();
  }

  try {
   input.close();
  } catch (final IOException e) {
   e.printStackTrace();
  }

  System.out.println(str);
 }
}
Programın Çıktısı : 
Hello World !
Yukarıda ki programda input değişkeni FileInputStream sınıfını referans etmektedir.try bloğunun içerisinde nesnemizi oluşturuyoruz ve bir parametreli Constructor'un aldığı argüman değeri dosyanın ismidir.(Dosya ismi içerisindeki argümanın iki adet "\" ifadesi almasının sebebi derleyicinin "\" karakterinden sonraki karakteri dikkate almadan derleme işlemine devam etmesini sağladık.Yani "C:\\first.txt" bu değerin çıktısı "C:\first.txt" bu olucaktır.Onu başka bir yazımda anlatacağım.[Escape Characters]) . do-while içerisinde ki i değişkenine atadığımız input değişkeni FileInputStream sınıfının read() methodunu çağırır ve bu method bir tamsayı değer döndürür.Eğer dosya okuma işleminin sonuna yaklaşırsa döndürdürüğü değer -1 olur.i değişkenini char tipinde cast ettikten sonra str'ye ekliyoruz.Ben örnek olarak first.txt içerisine "Hello World !" yazıp kaydettim.Okuma işlemini yaptıktan sonra yukarıda belirttiğim gibi dosyayı kapatmamız gerekiyor.Bunuda bir try-catch bloğunda close() methodunu çağırarak yapıyoruz.Yapılan bu işlemlerin hepsi birer IOException fırlatabilir.

 2 - Dosya Yazma

Buradaki program " first.txt " içerisindeki verileri " second.txt " 'ye aktarır.

package com.blogger_project;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

class FileRead {
 public static void main(final String args[]) {
  int i;
  FileInputStream input = null;
  FileOutputStream output = null;

  try {
   input = new FileInputStream("C:\\first.txt");
   output = new FileOutputStream("C:\\second.txt");

   do {
    i = input.read();
    if (i != -1) {
     output.write(i);
    }
   } while (i != -1);
  } catch (final IOException e) {
   e.printStackTrace();
  } finally {
   try {
    if (input != null) {
     input.close();
    }

   } catch (final IOException e) {
    e.printStackTrace();
   }
   try {
    if (output != null) {
     output.close();
    }
   } catch (final IOException e2) {
    e2.printStackTrace();
   }
  }

 }
}
Burada "Dosya Okuma" işlemlerinde yapmış olduğumuz str  değişkenine eklediğimiz değerleri output nesnesine FileOutputStream sınıfının write() methodunu kullanarak aktarıyoruz.Bir önceki işlemlerden farklı olarak try-catch bloğunda bir finally bloğu yer alıyor.Burası programımıza bir esneklik sağlıyor.finally bloğu her zaman try-catch bloklarından sonra kesinlikle çalıştırılır.Dosya kapatma işlemlerini burdan yönetmek hem daha önceden oluşan sorunlardan ötürü kapanmayan dosyaları kapatır hemde kodu kısaltır.
DEVAMINI GÖRMEK İÇİN TIKLA..

0 yorum :

Java - Enums ( Numaralandırmalar )

Cumartesi, Mayıs 23, 2015 kustemura 1 Yorum


Bu özellik Java'ya 1.5 sürümüyle beraber eklenmiştir.
Enum adlandırılmış sabitlerden oluşan bir listedir.Örneğin günler gibi.
Java'da numaralandırmalar bir sınıf tipini tanımlarlar.
Bir örnek ile ele alalım.

package com.blogger_project;

/**
 * @Author    : Ali Can Kuştemur
 * @Date      : 22 May 2015
 * @File_Name : EnumDemo.java
 * @Blog      : http://kustemura.blogspot.com.tr 
 */
public class EnumDemo {

 public enum Day {
  PAZARTESI, SALI, CARSAMBA, PERSEMBE, CUMA, CUMARTESİ, PAZAR
 }

 public static void main(final String[] args) {
  Day theDay = Day.PAZARTESI;
  printToday(theDay);

  theDay = Day.PERSEMBE;
  printToday(theDay);

  theDay = Day.valueOf("PERSEMBE");
  printToday(theDay);

  System.out.println();

  for (final Day allDay : Day.values()) {
   System.out.println(allDay);
  }

 }

 public static void printToday(final Day day) {
  if (day == Day.PAZARTESI) {
   System.out.println("Pazartesi gününe bir \"Merhaba\" de bakalım. ");
  } else {
   System.out.println("Bugün şanslı günündesin.");
  }
 }

}
Programın Çıktısı : 
Pazartesi gününe bir "Merhaba" de bakalım. 
Bugün şanslı günündesin.
Bugün şanslı günündesin.

PAZARTESI
SALI
CARSAMBA
PERSEMBE
CUMA
CUMARTESİ
PAZAR
Burada PAZARTESI,SALI ve diğer tanımlayıcılar , numaralandırma sabitleri olarak adlandırılırlar.Her biri kapalı olarak Day'in public,static ve final birer üyesi olarak deklare edilmiştir.Bu sabitlerin tipleri deklare edildikleri tiplerdir yani burada Day tipinde.Enum'lar bir sınıf tipi olmalarına rağmen new anahtar sözcüğü ile bir enum örneği oluşturulamaz;ama bir numaralandırma değişkenini ilkel değişken tiplerinde olduğu gibi aynı şekilde deklare edebilirsiniz. Örneğimizde theDay adında bir Day örneği oluşturduk ve bu örneğe PAZARTESI sabitini atadık.)enumlar if veya switch yapılarında kullanılabilirler.)Ardından printToday() methoduna argüman olarak geçtiğimiz theDay değişkeni ile dönen değere göre yazdırma işlemlerimizi yapıyoruz. valueOf() methoduna aktarılan karakter katarına karşılık gelen sabiti döndürür. "Bugün şanslı günündesin." çıktısının iki adet olduğuna dikkat edin.Bunun sebebi valueOf() methoduna argüman olarak yazdığımız "PERSEMBE" karakter katarının printToday() methodunda else bloğuna düşmesidir. values() methodu çağrıldı enum tipinde bir diziyi döndürür.Burada for-each içerisindeki allDay değişkenine Day enum'unun sabitleri birer birer aktarılır ve ekrana yazdırılır.

Java Numaralandırmaları Sınıf Tipleridir
enum'larda new kullanarak bir enum örneği oluşturamasakta , bunun dışında diğer sınıflar ile aynı yeteneklere sahiptirler.Örneğin numaralandırmalara yapılandırıcı verebilir ,örnek değişken ve methodlar ekleyebilir hatta arabirimler uygulayabilirsiniz.
Bir örnekle inceleyelim.

package com.blogger_project;

/**
 * @Author : Ali Can Kuştemur
 * @Date : 22 May 2015
 * @File_Name : EnumDemo.java
 * @Blog : http://kustemura.blogspot.com.tr
 */
public class EnumDemo {
 enum Fruit {
  Apple(5), Banana(7), Orange(2), Peach(4), Melon(6), WaterMelon;
  private int price;

  Fruit() {
   price = -1;
  }

  Fruit(final int price) {
   setPrice(price);
  }

  void setPrice(final int price) {
   this.price = price;
  }

  int getPrice() {
   return price;
  }

 }

 public static void main(final String args[]) {
  Fruit myFruit = Fruit.Orange;
  System.out.println(myFruit + " : " + myFruit.getPrice() + " $");

  myFruit = Fruit.Peach;
  System.out.println(myFruit + " : " + myFruit.getPrice() + " $");

  System.out.println("Fruit/Melon :" + Fruit.Melon.getPrice() + " $");

  System.out.println();

  System.out.println("Fruit Numaralandırma Sabitleri Listesi ");
  for (final Fruit fruit : Fruit.values()) {
   System.out.println(fruit + " : " + fruit.getPrice() + " $");
  }

 }
}
Orange : 2 $
Peach : 4 $
Fruit/Melon :6 $

Fruit Numaralandırma Sabitleri Listesi 
Apple : 5 $
Banana : 7 $
Orange : 2 $
Peach : 4 $
Melon : 6 $
WaterMelon : -1 $
Constructor değerlerini sabitlere tanımladıktan sonra getPrice() methodu ile Fruit numaralandırıcı sabitlerinin price değerlerine ulaşıp yazdırdık.Bir enum örnek değişkeni oluşturup new ifadesi kullanmadığımıza dikkat edelim. Constructor'u boş geçilen WaterMelon sabiti ise yine sınıflarda olduğu gibi aşırı yüklenebilir.Constructor argümanı boş geçilen sabit'in -1 değer aldığını görüyoruz.Buradaki önemli parçalar :

Fruit myFruit = Fruit.Orange;
myFruit.getPrice(); 
Fruit.Melon.getPrice();
Burada getPrice() methodunun 2 farklı çağrılma şeklini gördük. Numaralandırlar ile ilgili önemli kısıtlamalar: 1 - Bir numaralandırma bir başka sınıfı kalıtımla devralamaz. 2 - Bir enum bir üst sınıf olamaz. ( enum'lar genişletilemezler.) 3 - Her bir numaralandırma sabiti tanımlandığı sınıfın tipinde bir nesne olmalıdır. 


package com.blogger_project;

/**
 * @Author : Ali Can Kuştemur
 * @Date : 23 May 2015
 * @File_Name : EnumDemo2.java
 * @Blog : http://kustemura.blogspot.com.tr
 */
public class EnumDemo2 {
 enum Fruit {
  Apple, Banana, Orange, Peach, Melon, WaterMelon;
 }

 public static void main(final String args[]) {

  final Fruit fr1, fr2, fr3;

  for (final Fruit fruit : Fruit.values()) {
   System.out.println(fruit + " : " + fruit.ordinal());
  }

  System.out.println();

  fr1 = Fruit.Apple;
  fr2 = Fruit.Banana;
  fr3 = Fruit.Apple;

  if (fr1.compareTo(fr2) < 0) {
   System.out.println(fr1 + " " + fr2 + "'dan önce gelir.");
  }

  if (fr1.compareTo(fr2) > 0) {
   System.out.println(fr2 + " " + fr1 + "'dan önce gelir.");
  }

  if (fr1.compareTo(fr3) == 0) {
   System.out.println(fr1 + " eşittir " + fr3 + "'a");
  }

  if (fr1.equals(fr3)) {
   System.out.println(fr1 + " eşittir " + fr3 + "'a");
  }

 }
}
Programın Çıktısı : 
Apple : 0
Banana : 1
Orange : 2
Peach : 3
Melon : 4
WaterMelon : 5

Apple Banana'dan önce gelir.
Apple eşittir Apple'a
Apple eşittir Apple'a
Tüm numaralandırmalar java.lang.Enum sınıfını devralır.Bu sınıfın bazı methodları vardır.Bu örnekte for-each döngüsü içerisinde kullanmış olduğum ordinal() methodu ilgili enum sabitinin konumunu integer olarak dönderir.( Dizideki indis(index) mantığı ile aynı) compareTo() methodu ise çağrıldığı sabit ile parametresine aldığı sabit'in konumlarını karşılaştırır.Eğer çağıran sabitin ordinal değeri çağrılandan küçük ise negatif bir değer döndürür.Büyük ise pozitif değer döndürür.Eğer sıfır değerini döndürürse 2 sabitin konumu eşit demektir.Buradaki equals() methodu ise çağıran ve çağrılan sabitlerin her ikiside aynı numaralandırmadan gelen aynı sabite karşılık geliyorsa true döndürür.
DEVAMINI GÖRMEK İÇİN TIKLA..

1 yorum :

Java - Set ve Get Methodları

Cuma, Mayıs 22, 2015 kustemura 0 Yorum


Bu yazımdaki örnekleri this anahtar sözcüğü üzerinden devam etmek istiyorum.
Önceki programlarda oluşturduğumuz yapılar kullanışlı olsada tam olarak yeterli değildir.Hiçbir değişkene direk erişim mümkün olmamalıdır.Nesneye Yönelimli Programlama'nın en önemli özelliklerinden olan Encapsulation ( Kapsülleme ) kavramını tam olarak uygulamamız için değişkenlerimizin Set ve Get methodlarını oluşturmalıyız.
Örnek üzerinden devam edelim.


class Rectangle {
 double width;
 double height;
 double depth;

 Rectangle(double width, double height, double depth) {
  this.width = width;
  this.height = height;
  this.depth = depth;
 }
}
Buradaki değişkenler default değer olarak sadece kendi paketleri içerisinde çağrılabilirler , fakat direkt olarak çağrılıp üzerinde işlem yapılabilir durumdadırlar.Bu kullanım oldukça tehlikeli ve yanlıştır.Aşağıdaki programı inceleyelim: 
package com.blogger_project;

class Rectangle {
 private double width;
 private double height;
 private double depth;

 Rectangle(final double width, final double height, final double depth) {
  setWidth(width);
  setHeight(height);
  setDepth(depth);
 }

 Rectangle() {
  setWidth(-1);
  setHeight(-1);
  setDepth(-1);
 }

 double volume() {
  return width * height * depth;
 }

 public double getWidth() {
  return width;
 }

 public void setWidth(final double width) {
  this.width = width;
 }

 public double getHeight() {
  return height;
 }

 public void setHeight(final double height) {
  this.height = height;
 }

 public double getDepth() {
  return depth;
 }

 public void setDepth(final double depth) {
  this.depth = depth;
 }
}

class RectangleDemo {
 public static void main(final String args[]) {
  final Rectangle myRectangle = new Rectangle(5, 12, 6);
  System.out.println("Genişlik :" + myRectangle.getWidth());
  System.out.println("Yükseklik :" + myRectangle.getHeight());
  System.out.println("Derinlik :" + myRectangle.getDepth());
  System.out.println("Hacim : " + myRectangle.volume());

 }
}
Programın Çıktısı : 
Genişlik :5.0
Yükseklik :12.0
Derinlik :6.0
Hacim : 360.0
Bir önceki kullanımda 
        
 this.width = width;
 this.height = height;
 this.depth = depth;
olarak constructor'e uygulayarak değerlerimizi atamıştık.Fakat burada set< Değişken Adı> isimli methodlarımızda yaptığımız işlemler aslında üstteki üç işlem ile aynı işi yapar. ( set < Değişken Adı> ve get < Değişken Adı> kullanımı programcılıkta bir standart haline geldiği için bu örnekte bu şekilde kullanılmaktadır.Eclipse -> Sağ Tık -> Source -> Generate Setters and Getters işlemini uygulayarak Set ve Get methodlarını otomatik oluşturabilirsiniz.Eclipse standart kullanımı yapmakla beraber method isimlerini değiştirmenize olanak sağlar. )Ayrıca değişkenleri gizler ve dışardan herhangi bir değişime izin vermezler.Burada değişken değerini değiştirmek için sadece değişkenin set methodu kullanılabilir.Bu yapıyı kullanarak artık değişkenlere direkt bir şekilde erişilemez.Sadece get< Değişken Adı> methodu kullanılarak erişilebilir.
DEVAMINI GÖRMEK İÇİN TIKLA..

0 yorum :

Java - Çok Kanallı Programlama (Multi-Threaded
Programming) #3 Thread Sınıfını Genişletmek

Perşembe, Mayıs 21, 2015 kustemura 0 Yorum


Önceki örneklere aşağıdaki bağlantılardan ulaşabilirsiniz:
Java - Çok Kanallı Programlama (Multi-Threaded Programming)  #2
Java - Çok Kanallı Programlama (Multi-Threaded Programming)  #1

Bir önceki örneği daha iyi bir yoldan yapalım.

package com.blogger_project;

class NewThread extends Thread {
 NewThread() {
  super("Demo Thread");
  System.out.print("Çocuk Thread");
  System.out.print("Çocuk Thread" + this);
  start();
 }

 @Override
 public void run() {
  try {
   for (int i = 5; i > 0; i--) {
    System.out.println("Çocuk Thread" + i);
    Thread.sleep(500);
   }
  } catch (final InterruptedException e) {
   e.printStackTrace();
  }
  System.out.println("Çocuk Thread'den çıkıldı.");
 }
}

class ExtendThread {
 public static void main(final String args[]) {
  new NewThread();
  try {
   for (int i = 5; i > 0; i--) {
    System.out.println("Ana Thread" + i);
    Thread.sleep(1000);
   }
  } catch (final InterruptedException e) {
   e.printStackTrace();
  }
 }
}
Bir önceki program ile bu programın yaptığı iş aynıdır.Yeni bir kanal oluşturmanın bir diğer yolu ise Thread sınıfını genişleten bir sınıf oluşturup ve bu sınıfın bir örneğini oluşturmak. 
super("Demo Thread");
NewThread'in içindeki super()'e yapılan çağrı Thread yapılandırıcısının aşağıdaki formunu çağırır. 
public Thread(String threadName);
Buradaki threadName kanalın adını belirler.
DEVAMINI GÖRMEK İÇİN TIKLA..

0 yorum :

Java - Çok Kanallı Programlama (Multi-Threaded Programming) #2

Perşembe, Mayıs 21, 2015 kustemura 0 Yorum


Önceki örnek üzerinden devam ediyorum.Buradan ona ulaşabilirsiniz.
package com.blogger_project;

class NewThread implements Runnable {
 Thread thread;

 NewThread() {
  thread = new Thread(this, "Demo Thread");
  System.out.println("Çocuk Thread" + thread);
  thread.start();
 }

 @Override
 public void run() {
  try {
   for (int i = 5; i > 0; i--) {
    System.out.println("Çocuk Thread " + i);
    Thread.sleep(500);
   }
  } catch (final InterruptedException e) {
   e.printStackTrace();
  }
  System.out.println("Çocuk Thread'den çıkıldı.");
 }
}

class ThreadDemo {
 public static void main(final String args[]) {
  new NewThread();
  try {
   for (int i = 5; i > 0; i--) {
    System.out.println("Ana Thread " + i);
    Thread.sleep(1000);
   }
  } catch (final InterruptedException e) {
   e.printStackTrace();
   
  }
  System.out.println("Ana Thread'den çıkıldı.");
 }
}
Programın Çıktısı : 

run() methodunu oluşturabilmemiz için Runnable arabirimini sınıfımıza implement ediyoruz.
thread = new Thread(this, "Demo Thread");
Burada this argümanı nesne thread nesnesi üzerindeki run() methoduna göndermede bulunur.start() methodu ise run() methodunu başlatır.Bu Çocuk Thread'in başlamasına neden olur.Ardından main methodundaki NewThread() constructoru çalışmaya başlar ve main() methoduna geri döner.Burada her iki for döngüsü CPU'yu paylaşarak çalışmaya devam ederler.( Programı çalıştırdığınızda elde edeceğiniz çıktı buradaki çıktı ile aynı olmayabilir, işlemci hızına ve görev yüküne göre farklılıklar göstericektir.) Genellikle çalışmayı bitiren son kanal Ana Kanal olmak zorundadır.JVM'in bazı versiyonlarında ana kanal çocuk kanaldan önce biterse ,  Java çalışma zamanı sistemi askıya alınabilir.(suspended).Yukarıdaki program her zaman Ana Thread'in Çocuk Thread'den sonra bitmesini garantiler .Çünkü Çocuk Thread 500 milisaniye uyurken , Ana Thread 1000 milisaniye uyur ve bu yapı Çocuk Thread'in Ana Threadden daha hızlı bir şekilde sonlanmasına neden olur.
DEVAMINI GÖRMEK İÇİN TIKLA..

0 yorum :

Java - Çok Kanallı Programlama (Multi-Threaded Programming) #1

Perşembe, Mayıs 21, 2015 kustemura 0 Yorum


Merhaba bu yazım Çok Kanallı Programlama konusunu içeriyor.Vermiş olduğum link'te çok kanallı programlamanın temel işlemlerini , Runnable Interface'ini ve Deprecated olmuş methodların ayrıntılı ve anlaşılır bir biçimde açıklaması yer alıyor.
package com.blogger_project;

class CurrentThreadDemo {
 public static void main(final String args[]) {
  final Thread thread = Thread.currentThread();
  System.out.println("Varsayılan ismi :" + thread);
  thread.setName("myThread");
  System.out.println("Adı Değişti :" + thread);

  try {
   for (int i = 5; i > 0; i--) {
    System.out.println(i);
    Thread.sleep(1000);
   }

  } catch (final InterruptedException e) {
   e.printStackTrace();
  }

 }
}
Programın Çıktısı :

Burada Thread sınıfından referans ettiğimiz thread örnek değişkeni Thread sınıfının currentThread() methoduna göndermede bulunur.Oluşan çıktıların sıralaması , 
1 -Ana Kanalın Adı  , 2-  Önceliği , 3-Grubunun Adı. ( Thread[main,5,main])
Programın çıktısından da anlaşıldığı gibi try bloğu içerisinde ki for döngüsünde çağrılan i değişkeni 1000 milisaniye yani 1 saniye bekleyerek beşten geriye doğru ekrana yazdırıyor.Bu döngü tekrarındaki duraklama sleep() methodu tarafından sağlanır.sleep() methodu bir InterruptedException fırlatabilir.Bunu catch constructorunda yakalıyoruz.
setName() methodu varsayılan kanal adını değiştirmek için kullanılır.
getName() methodu ise kanal adını elde etmek için kullanılır.

package com.blogger_project;

class CurrentThreadDemo {
 public static void main(final String args[]) {
  final Thread thread = Thread.currentThread();
  thread.setName("myThread");
  System.out.println(thread.getName());

 }
}
Programın Çıktısı : 
myThread
DEVAMINI GÖRMEK İÇİN TIKLA..

0 yorum :

Java - Interface (Arabirim) Genişletmek

Cumartesi, Mayıs 16, 2015 kustemura 0 Yorum


Bir arabirim, extends anahtar sözcüğü ile aynı sınıflardaki gibi kalıtım aldığı arabirimi genişletebilir.Kalıtım zinciri tamamlanan arabirimin tanımlanan tüm methodlarını uyguladığı sınıf sağlamak zorundadır. Bunu bir örnek ile ele alalım. 
interface A {
 void method1();

 void method2();
}

interface B extends A {
 void method3();
}

class TestInterfaceInheritance implements B {
 @Override
 public void method1() {
  System.out.println("method1 çağrıldı!");
 }

 @Override
 public void method2() {
  System.out.println("method2 çağrıldı!");
 }

 @Override
 public void method3() {
  System.out.println("method3 çağrıldı!");
 }
}

class MainClass {
 public static void main(String args[]) {
  final TestInterfaceInheritance t = new TestInterfaceInheritance();
  t.method1();
  t.method2();
  t.method3();
 }
}
Programın Çıktısı :
method1 çağrıldı!
method2 çağrıldı!
method3 çağrıldı!
Burada B arabirimi , A arabiriminin bütün methodlarını içerir , method3()'ü ekler.B arabirimini uygulayan TestInterfaceInheritance sınıfı ise A ve B arabirimlerinin bütün methodlarını uygulamak zorundadır.
DEVAMINI GÖRMEK İÇİN TIKLA..

0 yorum :

Java - Genişleyen Stack Uygulaması

Perşembe, Mayıs 14, 2015 kustemura 0 Yorum

Bir önceki uygulamamızda sadece oluşturduğumuz nesnenin constructor'üne verdiğimiz değer sayısı kadar Stack'imizi oluşturuyorduk.Stack'de oluşan fazla değer ekleme durumunda " Stack dolu" uyarısını alıyorduk.Bir önceki uygulamaya buradan ulaşabilirsiniz.



Önceki örneğimizi genişletilebilir bir Stack uygulaması olarak güncelleyelim.


interface IFStack {
	void push(int item);
	int pop();
}
class ExpStack implements IFStack {
	private int stack[];
	private int stackStatus;
	ExpStack(int size){
		stack = new int[size];
		stackStatus = -1;
	}
	public void push (int item){
		if(stackStatus == stack.length-1){
			int temp[] = new int[stack.length*2];
			for(int i=0;i < stack.length;i++){
				temp[i] = stack[i];
			}
			stack = temp;
			stack[++stackStatus] = item;
		}else{
			stack[++stackStatus] = item;
		}
	}
	public int pop(){
		if(stackStatus<0){
			System.out.println("Stack boş");
		return 0;
		}
		else
		{
			return stack[stackStatus--];
		}
	}
}
class StackDemo {
	public static void main(String args[]){
		ExpStack myStack = new ExpStack (10);
		for(int i=1;i<12;i++)
			myStack.push(i);
		
		for(int i=1;i<12;i++){
			System.out.println(myStack.pop());
		}
	}
}

Programın Çıktısı:
11
10
9
8
7
6
5
4
3
2
1
Genişletmek için push methodu içerisinde bir önceki programda " Stack dolu " olarak yazdırdığımız bölüme bir oluşturduğumuz Stack boyutunun 2 katında yeni bir geçici dizi oluşturuyoruz ardından eski Stack dizisindeki elemanları buna aktarıp birebir atama yaptığımızda artık Stack sınıfımız 2 katı olarak genişletilmiş oluyor.Stack'e push işlemlerini ise yine buradan devam ettiriyoruz.
DEVAMINI GÖRMEK İÇİN TIKLA..

0 yorum :

Java - Stack Uygulaması

Perşembe, Mayıs 14, 2015 kustemura 0 Yorum 


interface IFStack {
 void push(int item);
 int pop();
}
class Stack implements IFStack {
 private int stack[];
 private int stackStatus;
 Stack(int size){
  stack = new int[size];
  stackStatus = -1;
 }
 public void push (int item){
  if(stackStatus == stack.length-1){
   System.out.println("Stack dolu");
  }else{
   stack[++stackStatus] = item;
  }
 }
 public int pop(){
  if(stackStatus<0){
   System.out.println("Stack boş");
  return 0;
  }
  else
  {
   return stack[stackStatus--];
  }
 }
}
class StackDemo {
 public static void main(String args[]){
  Stack myStack = new Stack (10);
  for(int i=1;i<12;i++)
   myStack.push(i);
  
  for(int i=1;i<12;i++){
   System.out.println(myStack.pop());
  }
 }
}
Programın Çıktısı :
Stack dolu
10
9
8
7
6
5
4
3
2
1
Stack boş
0
Stack sınıfımızın kaç elemanlı bir dizi olacağını constructorune verdiğimiz değer belirliyor.
stackStatus değişkenini başlangıçta -1 olarak ayarlıyoruz ki ilk değer atamasında dizinin 0'ın indisine değer atamasını yapmasını sağlıyoruz.push methodu için : stackStatus değişkeni stack dizisinin uzunluğundan 1 eksik durumda stack dizisi artık eleman alamaz durumda dolu oluyor.(Diziler'in indisleri 0'dan başladığı için -1 diyoruz )Ardından bu indise Constructor'e girilen argüman değerini item değişkeninden alıp deklare ediyoruz.
pop methodu için ise eğer stackStatus sıfırdan küçük ise stack dizisinin boş olduğunu belirtiyoruz , değilse de stack mantığında elemanları çekmek için postfix olarak azaltıp elemanı alıyoruz.
Burada Stack sınıfından oluşturduğumuz myStack nesnesi 10 elemanlı bir Stack dizisi tanımlar.11 eleman push etmeye çalıştığımızda "Stack dolu" uyarısı alırız , 10'dan fazla elemanı pop ettiğimizde ise Stack boş uyarısını alırız.
DEVAMINI GÖRMEK İÇİN TIKLA..

0 yorum :

Java - Interface & Abstract Örneği #2

Perşembe, Mayıs 14, 2015 kustemura 0 Yorum

Bir önceki örneğe buradan ulaşabilirsiniz.
Bu örneğe GitHub üzerinden erişebilirsiniz.
GitHub - InterfaceAbstractExampleTwo


package com.blogger_project;

/**
 * @Author : Ali Can Kuştemur
 * @Date : 14 May 2015
 * @File_Name : Animal.java
 * @Blog : http://kustemura.blogspot.com.tr
 */
interface BasicAnimals {
 String talk();

 void sit();

 void run();

 void features();
}

abstract class Animal implements BasicAnimals {
 private String name;
 private double height;
 private double weight;
 private String color;
 private String eyeColor;

 @Override
 abstract public String talk();

 protected Animal(final String name, final double height,
   final double weight, final String color, final String eyeColor) {
  setName(name);
  setHeight(height);
  setWeight(weight);
  setColor(eyeColor);
  setEyeColor(eyeColor);
 }

 protected Animal() {
  setName("İsimsiz bir hayvan");
  setHeight(-1);
  setWeight(-1);
  setColor("Siyah");
  setEyeColor("Siyah");
 }

 @Override
 public void sit() {
  System.out.println(" Oturuyorum !");
 }

 @Override
 public void run() {
  System.out.println(" Koşuyorum !");
 }

 @Override
 public void features() {
  System.out.println(" Adı :" + getName());
  System.out.println(" Boyu :" + getHeight() + " cm");
  System.out.println(" Ağırlığı :" + getWeight() + " kg");
  System.out.println(" Rengi :" + getColor());
  System.out.println(" Göz Rengi :" + getEyeColor());
 }

 public String getName() {
  return name;
 }

 public void setName(final String name) {
  this.name = name;
 }

 public double getHeight() {
  return height;
 }

 public void setHeight(final double height) {
  this.height = height;
 }

 public double getWeight() {
  return weight;
 }

 public void setWeight(final double weight) {
  this.weight = weight;
 }

 public String getColor() {
  return color;
 }

 public void setColor(final String color) {
  this.color = color;
 }

 public String getEyeColor() {
  return eyeColor;
 }

 public void setEyeColor(final String eyeColor) {
  this.eyeColor = eyeColor;
 }

}

class Dog extends Animal {
 Dog(final String name, final double height, final double weight,
   final String color, final String eyeColor) {
  super(name, height, weight, color, eyeColor);
 }

 Dog() {
  super();
 }

 @Override
 public String talk() {
  return " Hav Hav!";
 }
}

class Cat extends Animal {
 Cat(final String name, final double height, final double weight,
   final String color, final String eyeColor) {
  super(name, height, weight, color, eyeColor);
 }

 Cat() {
  super();
 }

 @Override
 public String talk() {
  return " Miyav Miyav";
 }
}

class AnimalDemo {
 public static void main(final String args[]) {
  final BasicAnimals myDog = new Dog("Karabaş", 45, 25, "Beyaz",
    "Kahverengi");
  myDog.features();
  myDog.sit();
  myDog.run();
  System.out.println(myDog.talk());

  System.out.println();

  final BasicAnimals myCat = new Cat("Minnoş", 20, 3, " Gri ", " Yeşil");
  myCat.features();
  myCat.sit();
  myCat.run();
  System.out.println(myCat.talk());

  System.out.println();

  final BasicAnimals dog = new Dog();
  dog.features();
  dog.sit();
  dog.run();
  System.out.println(dog.talk());
 }
}
Programın Çıktısı : 
 Adı :Karabaş
 Boyu :45.0 cm
 Ağırlığı :25.0 kg
 Rengi :Beyaz
 Göz Rengi :Kahverengi
 Oturuyorum !
 Koşuyorum !
 Hav Hav!

 Adı :Minnoş
 Boyu :20.0 cm
 Ağırlığı :3.0 kg
 Rengi : Gri 
 Göz Rengi : Yeşil
 Oturuyorum !
 Koşuyorum !
 Miyav Miyav

 Adı :İsimsiz bir hayvan
 Boyu :-1.0 cm
 Ağırlığı :-1.0 kg
 Rengi :Siyah
 Göz Rengi :Siyah
 Oturuyorum !
 Koşuyorum !
 Hav Hav!
BasicAnimals interface'i ile bir Hayvan örneği üzerinden çalışıyoruz.Temel hayvanların , temel özellikleri asla değişmeyeceğinden bunların birkaçını BasicAnimals'da topluyoruz.Ardından oluşturduğumuz tüm hayvanlar bu özellikleri zaten içermek zorunda.
Animals sınıfında tanımladığımız değişkenlerin private olarak tanımlandığına dikkat edin.Bu değişkenlere sadece get ve set methodları ile erişilebilir.Buradaki kavram Object-Oriented Programming'te Encapsulation (Kapsülleme) olarak adlandırılır.

BasicAnimals interface'i sayesinde alt sınıflara implement edeceğimiz methodları oluşturduk.Animals sınıfına BasicAnimals interface'ini implement ediyoruz.Oluşturduğumuz Animals soyut sınıfı , BasicAnimals'ın tüm özelliklerini aynı şekilde uygulamak zorundadır.sit() , run() ve features() methodları tüm hayvanlar için aynı şeyi ifade ettiğinden Animals sınıfı içerisinde methodlarımızı oluşturup oluşturduğumuz nesneler üzerinden bunlara erişebiliriz.Ancak her hayvanın konuşması kendine özgü bir yapıya sahip olduğu için diğer hayvanlardan bağımsız olmalıdır.Bu yüzden talk() methodunu soyut olarak tanımlıyoruz.Her sınıf kendi içerisinde talk() methodunu farklı biçimlerde işleyecektir.Animals sınıfından genişlettiğimiz Dog ve Cat sınıflarında görüldüğü gibi tüm sit() , run() ve features() methodları aynı yere çağrı yaparken , talk() methodu birbirinden bağımsız bir şekilde çağrılıyor.Bu kavram Object-Oriented Programming'te Polimorfizm(Çok Biçimlilik) olarak adlandırılır.
DEVAMINI GÖRMEK İÇİN TIKLA..

0 yorum :

Java - Interface & Abstract Örneği

Çarşamba, Mayıs 13, 2015 kustemura 0 Yorum


Önceki yazılarımda Interface ( Arabirim ) ve Abstract ( Özet / Soyut) konularından bahsetmiştim.
Şimdi daha geniş ve anlaşılabilir bir örnek ile bunu ele alalım. 
interface Living {
 String talk();
 String myNameIs();
}

abstract class People implements Living {
 private final String name;

 protected People(String name) {
  this.name = name;
 }

 @Override
 public String myNameIs() {
  return name;
 }

}

class Ali extends People {

 public Ali(String name) {
  super(name);

 }

 @Override
 public String talk() {
  return " Merhaba , Benim Adım";
 }

}

class Can extends People {
 public Can(String name) {
  super(name);
 }

 @Override
 public String talk() {
  return " Merhaba , Ben ";
 }
}

class PeopleDemo {
 public static void main(String args[]) {
  final Living[] peoples = { new Ali(" Ali "), new Can(" Can ") };
  for (final Living people : peoples) {
   System.out.println(people.talk() + people.myNameIs());
  }
 }
}
Programın Çıktısı : 
 Merhaba , Benim Adım Ali 
 Merhaba , Ben  Can
Bu programda Living (Canlılar) adında bir interface oluşturdum . Ardından bir abstract sınıfa bunu implement ettim. Daha sonra oluşturduğum bu abstract People (İnsan) sınıfından 2 adet alt sınıf (subclass) oluşturdum.Oluşturduğum 2 alt class'ında talk() methodu birbirinden bağımsız bir sonuç dönderiyor.Fakat name değişkeni ise hep aynı constructoru ve sadece abstract class içerisindeki myNameIs() methoduna gönderme yapıyor.Bu sayede myNameIs() methodunu tekrar tekrar yazmaktansa sadece 1 kere yazıp bütün alt classlarda çağırmış olduk.Bu yapı aynı zamanda Çok Biçimlilik özelliğini işaret eder.Temel sınıf ( People )'dan türetilmiş olan alt sınıflarda paylaşılan aynı methodun bu sınıflarda farklı şekillerde uyarlanabilmesidir.
DEVAMINI GÖRMEK İÇİN TIKLA..

0 yorum :

Java - Arabirim ( Interface )

Çarşamba, Mayıs 13, 2015 kustemura 0 Yorum


Bu yazımda arabimlerden (interface) bahsedeceğim . interface anahtar sözcüğünü kullanarak , bir sınıfın arabirimini onun uygulamasından tamamen özetleyebilirsiniz.Yani , interface kullanarak bir sınıfın nasıl yapacağını değil , ne yapması gerektiğini belirtebilirsiniz. Arabirimler söz dizimi olarak sınıflarla benzerlik gösterirler.Fakat arabirimlerin örnek değişkenleri yoktur ve methodları gövdesiz olarak deklare edilir.

- Arabirim bir kez tanımlandığında bir çok sınıf tarafından implement edilebilir.Ayrıca bir sınıf da bir çok arabirime sahip olabilir.
- Özet sınıflara benzemelerine rağmen arabirimlerin bir kabiliyeti daha vardır:Bir sınıf birden fazla arabirim uyguyabilir.Buna karşılık bir sınıf sadece tek bir üst sınıftan ( özet veya başka) türetilebilir.
- Bir arabirim implement etmek için sınıfın arabirim tarafından tanımlanan methodların tümünü uygulaması zorunludur.
- Implement edilen arabirimin methodları uyglandığında sınıf kendi methodlarını da ekleyebilir.
- Implement edildiği sınıfın arabirim ile aynı ismi taşıyan methodun aynı tip imzası ve public erişim belirtecine sahip olması gereklidir.

Basit bir örnek ile inceleyelim.

interface Callback {
 void callBack(int param);
}

class Client implements Callback {

 @Override
 public void callBack(int param) {
  System.out.println("callBack methodu çağrıldı " + param);
 }

 void nonIFaceMeth() {
  System.out
    .println("Bir sınıfa implement edilen arabirimden (interface) "
      + "üyelerinden başka kendi üyelerini tanımlayabilir. ");
 }

}

class TestInterface {
 public static void main(String args[]) {
  Callback c = new Client();
  c.callBack(5);
 }
}
Programın Çıktısı : 
callBack methodu çağrıldı 5
Burada c , Callback arabirim tipinde deklare edilmiştir.Ancak ona Client'in bir örneği atanmıştır.c, callBack() methoduna erişmek için kullanılabilmesine rağmen Client sınıfının diğer üyelerine erişemez.Bir arabirim referans değişkeni sadece kendi interface deklerasyonunda deklare edilen methodun bilgisine sahiptir.Bu sebepten ötürü c , nonIFaceMeth() methoduna erişemez.Çünkü c , Callback tarafından değil , Client tarafından tanımlanmıştır. Başka bir örnek ile açıklayayım. 
interface Callback {
 void callBack(int param);
}

class Client implements Callback {

 @Override
 public void callBack(int param) {
  System.out.println("Client \n callBack methodu çağrıldı " + param);
 }

 void nonIFaceMeth() {
  System.out
    .println("Bir sınıfa implement edilen arabirimden (interface) "
      + "üyelerinden başka kendi üyelerini tanımlayabilir. ");
 }

}

class AnotherClient implements Callback {
 @Override
 public void callBack(int param) {
  System.out.println("AnotherClient");
  System.out.println(" " + param + "'in Karesi " + (param * param));
 }
}

class TestInterface2 {
 public static void main(String args[]) {
  Callback c = new Client();
  final AnotherClient ac = new AnotherClient();

  c.callBack(5);
  c = ac;
  c.callBack(5);

 }
}
Programın Çıktısı : 
Client 
 callBack methodu çağrıldı 5
AnotherClient
 5'in Karesi 25
Yuvalanmış Arabimler Bir arabirim bir sınıfın yada başka bir arabirim üyesi olarak deklare edilebilir.Böyle bir arabirime üye arabirim veya yuvalanmış arabirim denir. Bir örnek yapalım. 
class A {
 public interface NestedIF {
  boolean isNotNegative(int x);
 }
}

class B implements A.NestedIF {
 @Override
 public boolean isNotNegative(int x) {
  if (x < 0) {
   return false;
  } else {
   return true;
  }
 }
}

class NestedIFDemo {
 public static void main(String args[]) {
   A.NestedIF nif = new B();
  if (nif.isNotNegative(10)) {
   System.out.println("10 : Bu bir pozitif sayıdır.");
  }

  if (nif.isNotNegative(-10)) {
   System.out.println("-10 : Bu bir pozitif sayıdır.");
  } else {
   System.out.println("-10 : Bu bir negatif sayıdır.");
  }
 }
}
Programın Çıktısı : 
10 : Bu bir pozitif sayıdır.
-10 : Bu bir negatif sayıdır.
A'nın NestedIF adlı bir üye arabirim tanımladığına ve bu arabirimin public olarak deklare edildiğine dikkat edelim.B sınıfı implements A.NestedIF şeklinde belirtilerek yuvalanmış arabirimi uygular.nif adlı A.NestedIF referansı oluşturulur ve B nesnesine referans atanır.B sınıfı A.NestedIF arabirimini uygulandığından bu kullanım geçerlidir.
DEVAMINI GÖRMEK İÇİN TIKLA..

0 yorum :

Java - Kalıtım #5 Abstract Sınıfları Kullanmak ( Özet/Soyut)

Çarşamba, Mayıs 13, 2015 kustemura 0 Yorum


Bir sınıf hiyerarşisinde , alt sınıfa ait bir method üst sınıfında ki bir method ile aynı tipe ve ada sahipse ve böyle bir method çağrıldığında her zaman methodun alt sınıf tarafından tanımlanan versiyonuna başvurulur.Üst sınıftaki method gizlenmiş olur.Bunu bir örnek ile inceleyelim. Önceki yazılarımda  Java - Kalıtım konularını işlemiştik. Şimdi kaldığımız yerden devam ediyoruz.Eğer bu konu hakkında pek bir bilginiz yok ise önceki konulara bakmakta yarar var.

Önceki örneklerimizde kullandığımız yapıların hepsinde içeriği hep üst sınıf tarafından doldurulan ve ona eklemeler yapan alt sınıfları incelemiştik.Bazen yalnızca alt sınıflar tarafından paylaşılacak ve içeriği onlar tarafından doldurulacak , genel bir form tanımlayan üst sınıflar oluşturmak isteyebilirsiniz.Böyle bir sınıf , alt sınıfların gerçekleştirmek zorunda olduğu methodların doğasını belirler.
Bu durumda alt sınıfın gerçekten de tüm gerekli methodları ezmesini sağlamak için bir yol olması gerekir.Java bu problemi özet-soyut method ( abstract method ) kavramı ile çözer.
Özet bir method deklara etmek için aşağıdaki genel form kullanılır.

abstract tip_adi ( parametre listesi );

Gördüğünüz gibi , bir method gövdesi yoktur.
Bir sınıfı özet olarak deklere etmek için class anahtar sözcüğünün sol tarafında abstract anahtar sözcüğünü kullanmak yeterlidir.
Anlattığım şeyleri bir örnek üzerinde inceleyelim.

abstract class A {
 abstract void callMe();

 void callMeToo() {
  System.out.println("Bu bir somut methoddur.");
 }
}

class B extends A {
 @Override
 void callMe() {
  System.out.println("B A'daki callMe() methodunu içermek zorundadır. ");
 }
}

class AbstractDemo {
 public static void main(String args[]) {
  final B b = new B();
  b.callMe();
  b.callMeToo();
 }
}
Programın Çıktısı : 
B A'daki callMe() methodunu içermek zorundadır. 
Bu bir somut methoddur.
Programda A sınıfından bir nesne deklare edilmediğine dikkat edin.Özet bir sınıfı örneklendirmek mümkün değildir.Bir başka nokta : A sınıfı callMeToo() adında somut bir method'a sahiptir.Özet sınıflar örneklendirmek için kullanılamazlar , sadece nesne referansları oluşturmak için kullanılabilirler.Çünkü Java'nın çalışma zamanı çok biçimliliğine yaklaşımı , üst sınıf referansları aracılığıyla gerçekleşir.Bu yüzden bir alt sınıf nesnesine işaret etmek üzere , özet bir sınıfa referans oluşturmak mümkündür. Bunu bir örnek ile ele alalım. 
abstract class Figure {
 double dim1;
 double dim2;

 Figure(double a, double b) {
  dim1 = a;
  dim2 = b;
 }

 abstract double area();
}

class Rectangle extends Figure {
 Rectangle(double a, double b) {
  super(a, b);
 }

 @Override
 double area() {
  System.out.println("Dikdörtgen'in İç Alanı ");
  return dim1 * dim2;
 }
}

class Triangle extends Figure {
 Triangle(double a, double b) {
  super(a, b);
 }

 @Override
 double area() {
  System.out.println("Üçgen'in İç Alanı ");
  return dim1 * dim2 / 2;
 }
}

class AbstractAreas {
 public static void main(String args[]) {
  // Figure f = new Figure(10,7); Geçersiz , oluşturulamaz.
  final Rectangle r = new Rectangle(5, 2);
  final Triangle t = new Triangle(3, 7);
  Figure figureReference;
  figureReference = r;
  System.out.println(figureReference.area());
  figureReference = t;
  System.out.println(figureReference.area());
 }
}
Programın Çıktısı:
Dikdörtgen'in İç Alanı 
10.0
Üçgen'in İç Alanı 
10.5
Gördüğünüz gibi , area() methodu abstract bırakılmıştır . Çünkü area() hesaplaması için her nesne farklı bir method kullanmaktadır.Dikdörtgenin iç alanı formülü ile Üçgenin iç alanı formülü farklı olduğu için aynı methodu kullanamayız.area() methodunu abstract oluşturmamız nedeni budur.Üst sınıf tarafından abstract oluşturulan methodlar alt sınıflar tarafından kendi içlerinde farklı özelliklerde oluşturulmak için tasarlanmıştır.
DEVAMINI GÖRMEK İÇİN TIKLA..

0 yorum :

Java - Kalıtım #4 - Methodu Ezmek

Salı, Mayıs 12, 2015 kustemura 0 Yorum


Bir sınıf hiyerarşisinde , alt sınıfa ait bir method üst sınıfında ki bir method ile aynı tipe ve ada sahipse ve böyle bir method çağrıldığında her zaman methodun alt sınıf tarafından tanımlanan versiyonuna başvurulur.Üst sınıftaki method gizlenmiş olur.Bunu bir örnek ile inceleyelim. 
class A {
 int i, j;

 A(int a, int b) {
  i = a;
  j = b;
 }

 void show() {
  System.out.println("i = " + i + " j = " + j);
 }

}

class B extends A {
 int k;

 B(int a, int b, int c) {
  super(a, b);
  k = c;
 }

 void show() {
  System.out.println("k = " + k);
 }
}

class Override {
 public static void main(String args[]) {
  final B subClone = new B(5, 10, 15);
 }
}
Programın Çıktısı :
k = 15
B tipinde oluşturulan bir nesne üzerinden , show() methodunu çağırdığımızda B içinde tanımlı olan show() methodu çağrılır , çünkü show()'un B içerisinde ki versiyonu A içerisindeki versiyonu ezer.(Override)Yine ezilen versiyona ulaşmak için super kullanılır. 
class A {
 int i, j;

 A(int a, int b) {
  i = a;
  j = b;
 }

 void show() {
  System.out.println("i = " + i + " j = " + j);
 }

}

class B extends A {
 int k;

 B(int a, int b, int c) {
  super(a, b);
  k = c;
 }


 void show() {
  super.show();
  System.out.println("k = " + k);
 }
}

class Override {
 public static void main(String args[]) {
  final B subClone = new B(5, 10, 15);
 }
}
Programın Çıktısı : 
i = 5 j = 10
k = 15
Method ezmesi sadece aynı adı ve tip imzasını taşıması durumunda geçerlidir.Aksi takdirde bir method ezmesi değil , aşırı yüklenme oluşur.Bunu bir örnekle açıklayayım. 
class A {
 int i, j;

 A(int a, int b) {
  i = a;
  j = b;
 }

 void show() {
  System.out.println("i = " + i + " j = " + j);
 }

}

class B extends A {
 int k;

 B(int a, int b, int c) {
  super(a, b);
  k = c;
 }

 void show(String msg) {

  System.out.println(msg + k);
 }
}

class Override {
 public static void main(String args[]) {
  final B subClone = new B(5, 10, 15);
  subClone.show("k adında bir değişken = ");
  subClone.show();
 }
}
Programın Çıktısı :
k adında bir değişken = 15
i = 5 j = 10
Burada B içerisinde ki show() methodu , A içerisindeki show() methodunu aşırı yüklemiştir.
DEVAMINI GÖRMEK İÇİN TIKLA..

0 yorum :

Java - Kalıtım #3 Yapılandırıcıların Çağrılma Sırası

Salı, Mayıs 12, 2015 kustemura 0 Yorum


Bir sınıf hiyerarşisinde türetilme sırasına göre çağrılırlar .Yani üst sınıftan alt sınıflara doğru bir şekilde. Bunu basit bir örnek ile ele alalım. 
class A {
 A() {
  System.out.println(" Ben A'nın Yapılandırıcısıyım !");
 }
}

class B extends A {
 B() {
  System.out.println(" Ben B'nin Yapılandırıcısıyım !");
 }
}

class C extends B {
 C() {
  System.out.println(" Ben C'nin Yapılandırıcısıyım !");
 }
}

class CallingConstuructors {
 public static void main(String args[]) {
  final C c = new C();
 }
}
Programın Çıktısı : 
 Ben A'nın Yapılandırıcısıyım !
 Ben B'nin Yapılandırıcısıyım !
 Ben C'nin Yapılandırıcısıyım !
Mantıklı olarak bu çağrılmanın sebebi bellidir.Bir üst sınıf hiçbir şekilde bir alt sınıfın bilgisine sahip değildir.
DEVAMINI GÖRMEK İÇİN TIKLA..

0 yorum :

Java - Kalıtım #2 Çok Düzeyli Bir Hiyerarşi Oluşturmak

Salı, Mayıs 12, 2015 kustemura 0 Yorum


Bir önceki yazılarımda kalıtım ile ilgili , bir üst sınıf birde alt sınıf oluşturmuştuk.Bu yapıyı istediğiniz kadar kalıtım katmanı içeren bir hiyerarşi oluşturabilirsiniz.Oluşturulmuş bir alt sınıfın  ( subclass) başka bir sınıfın üst sınıfı olabileceğinden önceki yazılarımda bahsetmiştim.
Şimdi örneğimize kaldığımız yerden devam edelim ve bu örneğe yeni bir sınıf ekleyelim.Dikdörtgen örneğinde Dikdörtgene Ağırlık özelliği vermiştik , şimdi size bir Nakliye özelliği ekleyelim ve bu Dikdörtgenimizin bir ürün veya mal olduğunu düşünelim.
"Shipment" adında bir sınıf ekliyorum.


class Rectangle {
 private final double width;
 private final double height;
 private final double depth;

 Rectangle(Rectangle clone) {
  width = clone.width;
  height = clone.height;
  depth = clone.depth;
 }

 Rectangle(double width, double height, double depth) {
  this.width = width;
  this.height = height;
  this.depth = depth;
 }

 Rectangle() {
  width = -1;
  height = -1;
  depth = -1;
 }

 double volume() {
  return width * height * depth;
 }

}

class RectangleWeight extends Rectangle {
 double weight;

 RectangleWeight(RectangleWeight clone) {
  super(clone);
  weight = clone.weight;
 }

 RectangleWeight(double width, double height, double depth, double weight) {
  super(width, height, depth);
  this.weight = weight;

 }

 RectangleWeight() {
  super();
  weight = -1;
 }
}

class Shipment extends RectangleWeight {
 double cost;

 Shipment(Shipment clone) {
  super(clone);
  cost = clone.cost;
 }

 Shipment(double width, double height, double depth, double weight,
   double cost) {
  super(width, height, depth, weight);
  this.cost = cost;
 }

 Shipment() {
  super();
  cost = -1;
 }

}

class DemoShipment {
 public static void main(String args[]) {
  final Shipment shipment = new Shipment(5, 10, 15, 20, 30);
  final Shipment shipment2 = new Shipment(shipment);

  double vol;
  vol = shipment.volume();
  System.out.println("( shipment için ) \n Dikdörtgenin Hacmi " + vol
    + " \n Dikdörtgenin Ağırlığı : " + shipment.weight
    + " \n Nakliye Ücreti : $" + shipment.cost);
  System.out.println();
  vol = shipment2.volume();
  System.out.println("( shipment2 için ) \n Dikdörtgenin Hacmi " + vol
    + " \n Dikdörtgenin Ağırlığı : " + shipment2.weight
    + " \n Nakliye Ücreti : $" + shipment2.cost);
 }
}
( shipment için ) 
 Dikdörtgenin Hacmi 750.0 
 Dikdörtgenin Ağırlığı : 20.0 
 Nakliye Ücreti : $30.0

( shipment2 için ) 
 Dikdörtgenin Hacmi 750.0 
 Dikdörtgenin Ağırlığı : 20.0 
 Nakliye Ücreti : $30.0
super() devamlı en yakındaki üst sınıfın yapılandırıcısına göndermede bulunur.Shipment içindeki super(),RectangleWeight içerisindeki yapılandırıcıyı çağırır .RectangleWeight içerisindeki super() , Rectangle içindeki yapılandırıcıyı çağırır.Örneklerimin daha iyi anlaşılması için aynı dosya içerisinde oluşturarak anlatıyorum , aslında gerçekte her sınıfın farklı dosyalarda tutulması bir standarttır.
DEVAMINI GÖRMEK İÇİN TIKLA..

0 yorum :

super Anahtar Sözcüğü

Salı, Mayıs 12, 2015 kustemura 0 Yorum


Bir önceki  Java - Kalıtım adlı yazımdan kaldığım yerden devam ediyorum.
Önceki konularda kullandığımız örnekler bu yazımda da devam etmektedir.

Örneğin , RectangleWeight'in (subclasss) yapılandırıcısı , Rectangle ( superclass )'ın width,height ve depth alanlarına açıkca değer ataması yapabilir.Bu işlem yalnızca üst sınıftan kodu kopyalayıp verimi azaltmaz , aynı zamanda bir alt sınıfın üyelere erişimini de sağlar.
Üst sınıfın alanlarını kapatmak isteyeceğimiz ( yani , veri üyelerini private olarak korumak) zamanlar olucaktır. Bu durumda bir önceki örneklerde kullandığımız yapıyı kullanamayız.Bu yöntem ise Sarmalama olarak adlandırılır.Nesneye yönelimli programlamanın birincil özellikliğidir.
Bir alt sınıfın , üst sınıfına göndermede bulunması gerekirse bunu super anahtar sözcüğünü kullanarak yapmalıyız.
super anahtar sözcüğünün iki genel formu vardır,Birincisi  , üst sınıfın yapılandırıcısını çağırır.İkincisi ise bir üst sınıfın,bir alt sınıf üyesi tarafından gizlenen bir üyesine erişmek için kullanılır.

1 - Üst Sınıf Yapılandırıcılarını Çağırmak İçin super Kullanmak

class Rectangle {
 private final double width;
 private final double height;
 private final double depth;

 Rectangle(Rectangle clone) {
  width = clone.width;
  height = clone.height;
  depth = clone.depth;
 }

 Rectangle(double width, double height, double depth) {
  this.width = width;
  this.height = height;
  this.depth = depth;
 }

 Rectangle() {
  width = -1;
  height = -1;
  depth = -1;
 }

 double volume() {
  return width * height * depth;
 }

}

class RectangleWeight extends Rectangle {
 double weight;

 RectangleWeight(RectangleWeight clone) {
  super(clone);
  weight = clone.weight;
 }

 RectangleWeight(double width, double height, double depth, double weight) {
  super(width, height, depth);
  this.weight = weight;

 }

 RectangleWeight() {
  super();
  weight = -1;
 }

}

class DemoRectangleWeight {
 public static void main(String[] args) {
  final RectangleWeight myRectangle = new RectangleWeight(5, 10, 15, 25);
  final RectangleWeight myRectangle2 = new RectangleWeight(myRectangle);

  System.out.println("(myRectangle için)\nDikdörtgenin Hacmi :  "
    + myRectangle.volume());
  System.out.println("Dikdörtgenin Ağırlığı : " + myRectangle.weight);
  System.out.println();
  System.out.println("(myRectangle2 için)\nDikdörtgenin Hacmi  : "
    + myRectangle2.volume());
  System.out.println("Dikdörtgenin Ağırlığı : " + myRectangle2.weight);
 }
}
(myRectangle için)
Dikdörtgenin Hacmi :  750.0
Dikdörtgenin Ağırlığı : 25.0

(myRectangle2 için)
Dikdörtgenin Hacmi  : 750.0
Dikdörtgenin Ağırlığı : 25.0
Bu programın çıktısı da bir önceki yazımda yazdığım program ile aynıdır.

RectangleWeight(double width, double height, double depth, double w) {
  this.width = width;
  this.height = height;
  this.depth = depth;
  weight = w;
 
 }
Yani bu program ile , 
RectangleWeight(double width, double height, double depth, double w) {
  super(width, height, depth);
  weight = w;

 }
bu programın yaptığı iş aynıdır.Fakat ikinci program hem verimliliği arttırır , tekrarlamayı önler ve ayrıca Sarmalama özelliğini birebir uygular.

2 - super'in İkinci Bir Kullanımı

 super'in ikinci kullanımı bir açıdan this gibidir.Tek farkı,her zaman , kullanıldığı alt sınıfın üst sınıfına göndermede bulunuyor olmasıdır.


super.uye
Burada ki uye , ya bir method ya da bir örnek değişkendir. super'in bu ikinci kullanımı , bir alt sınıfın üye adlarının , üst sınıf içinde ki aynı adlı üyeler ile gizlendiği durumlarda çok sık görülür.Bunu bir örnek ile inceleyelim. 
class A {
 int i;
}

class B extends A {
 int i;

 B(int a, int b) {
  super.i = a;
  i = b;
 }

 void show() {
  System.out.println(" Superclass i = " + super.i);
  System.out.println(" Subclass i = " + i);
 }
}

class useSuper {
 public static void main(String[] args) {
  final B subClone = new B(1, 2);

  subClone.show();
 }
}
 Superclass i = 1
 Subclass i = 2
B'deki i örnek değişkeni A'dakini gizlemesine rağmen super , üst sınıf içerisinde tanımlanan i'ye erişime izin verir.Gördüğünüz gibi super , ayrıca alt sınıf tarafından gizlenen methodları çağırmak için de kullanılabilir.
DEVAMINI GÖRMEK İÇİN TIKLA..

0 yorum :

this Anahtar Sözcüğü

Salı, Mayıs 12, 2015 kustemura 0 Yorum

Bu yazımda this anahtar sözcüğünün kullanımını anlatacağım , bu konuyu daha iyi anlamak için bir önceki yazım Java - Yapılandırıcılar ( Constructors ) konusuna bakmakta fayda var.

package com.blogger_project;

class Rectangle {
 double width;
 double height;
 double depth;

 Rectangle(final double w, final double h, final double d) {
  width = w;
  height = h;
  depth = d;
 }
 Rectangle(double w,double h){
  width = w;
  height = h;
 }

 Rectangle() {
  width = -1;
  height = -1;
  depth = -1;
 }

 double volume() {
  return width * height * depth;
 }
}

Bir önceki örnekde parametreli yapılandırıcımızı tanımlarken parametre isimlerini w , h , d olarak tanımlamıştık.Farklı isimlerde tanımlamamızın sebebi sınıfın değişkenleri ile aynı isme sahip olmamasından kaynaklanır. this anahtar sözcüğü ile sınıfın değişkenlerini referans edip aynı ismi verebiliriz.Bunu bir örnekle inceleyelim ;


package com.blogger_project;

class Rectangle {
 double width;
 double height;
 double depth;

 Rectangle(final double width, final double height, final double depth) {
  this.width = width;
  this.height = height;
  this.depth = depth;
 }
 
 Rectangle(double width,double height){
  this.width=width;
  this.height=height;
 }
 
 Rectangle() {
  width = -1;
  height = -1;
  depth = -1;
 }

 double volume() {
  return width * height * depth;
 }
}

Burada ki this. ile başlayan değişkenlerin hepsi aslında sınıfın değişkenlerini referans etmektedir.Daha sonra koda baktığımızda anlaşılabilirliği arttırmak için bu yöntem kullanılabilir.

this'in Diğer Kullanımı

 
this(argüman listesi);

 Burada argüman listesine karşılık gelen yapılandırıcı çağrılır. 
package com.blogger_project;

package com.blogger_project;

class Rectangle {
 double width;
 double height;
 double depth;

 Rectangle(final double width, final double height) {
  this.width = width;
  this.height = height;
 }

 Rectangle(final double width, final double height, final double depth) {
  this(width, height);
  this.depth = depth;
 }

 Rectangle() {
  this(-1, -1, -1);
 }

 double volume() {
  return width * height * depth;
 }
}
Bu programda bir önceki program ile aynı işlemi yapar.Üç parametreli constructor çağrıldığında iki parametreli constructor'e göndermede bulunur.

1 - Aynı anda hem this() hemde super() kullanılamaz.
2 - Yapılandırıcıya ait herhangi bir değişken kullanılamaz.
DEVAMINI GÖRMEK İÇİN TIKLA..

0 yorum :

Kaydol: Kayıtlar ( Atom )