Labeled Statements

Iyigunler arkedeslar aslinda daha onceki yazilrimde labeled ifadesini gecmistim hatirlayacak olursaniz labeled iki nokta ust uste manasina gelir. Ornek olarak switch olustururken her bir case icin ":" isratei kullanilir.

Ama bu kunuyu ayri bir baslik alitinda yazmamin sebebi break to labeled ve continue to labeled konularinin incelemek ve bu konu ile ilgili uygulama gerceklestirmek oncelile break to labeled ile basliyalim.

Break to Labeled Statement : break ne alama gel;digini oncelikle hatirlayalim.  Donguyu aniden sonlandirmak veya donguyu kirmak icin break komutu kullanilir dongunun bitisinin nerede olacagini bilmedigimiz bir donguyu ancak break komutuyla sonlandirabiliriz Sartlar saglandiginda break komutu devreye girer ve dongu sonlanir. Break ile ilgili kucuk bir uygulama yapalim.

public class BreakTest {
       public static void main(String args[]){
            for (int i = 0; i < 5; i++) {
                    if(i == 2){
                          break;
                    }
                    System.out.println(i+" . deger");
            }
       }
}
//Console Output
 0 . deger
1 . deger
 Gorulduyu gibi sarta for dongusu besdafa donmesi gerekirken i == 2 sartina geldiyinde if icine girdi ve break gorduyu icin for bittirdi. Yada switch konusunu dusunelim case'lerden hangi sart uygun ise o sarta girer ve sartin sonuna break konulirki switch islemi sona ersin uygun sart bulunmus islem yapilmis altaki sartlara bakmaya gerek yok manasinda. Simdide gelelim break to labeled konusuna yukarda gorulduyu gibi break ancak bulungugu blog terkederken break to labeled yontemi ile istenilen blogu terketmesini saglayabiliriz
simdi bu konuyu anlama icin break ve btreak to labeled konusu ile ilgili iki uygulama gerceklestirince konu daha iyi analasilacak.

public class BreakTest {
       public static void main(String args[]) {
              for (int i = 0; i < 5; i++) {
                    System.out.println("i : "+i);
                    for (int j = 0; j < 5; j++) {
                           System.out.println("j : "+j);
                           if (j == 2) {
                                 break;
                           }
                    }
              }
       }
}

//Console Output 
i : 0
j : 0
j : 1
j : 2
 
i : 1
j : 0
j : 1
j : 2
 
i : 2
j : 0
j : 1
j : 2
 
i : 3
j : 0
j : 1
j : 2
 
i : 4
j : 0
j : 1
j : 2

Gorulduyu gibi i =0 icin ilk degeri almis ve j=0,1,2 degerlerinden sonra her seferinde break komutu ile bulundugu dongu terk etmis ve i'nin bir sonraki degerine gecmis yine j=yi gelince terk etmis ve bu olay 5 defa tekrar etmis. Ama dusunun ben istiyorumki j=2 ye gelince tum dongudeki islemler sonlansin iste burada devreye break to labeled konusu giriyor  ayni uygulamayi break to labeled ile yapip tum donguyu terk etmesini saglayacam.

public class BreakTest {
        public static void main(String args[]) {
                //Terk edilmesi istenilen yere
                terket:
                for (int i = 0; i < 5; i++) {
                        System.out.println("i : "+i);
                        for (int j = 0; j < 5; j++) {
                                 System.out.println("j : "+j);
                                 if (j == 2) {
                                       break terket;
                                 }
                        }
                }
        }
}
//Console Output
 i : 0
j : 0
j : 1
j : 2

Gorulduyu gibi i=0 icin dongu basladi ve j=0,1,2 icin calisti ve break gorduyu yerde terk etmesi gereken yeri bildirdiyim icin dongu tamamen sonlandi.

Continue to Labeled Statement :  Bu konuya girmeden once continue ifadesini bir hatirlayalim İşlem yapmadan döngüyü devam ettirmek için ise continue komutunu kullanırız.  Once continue ile ingili bir uygulama yapacam sonrada continue to label ile ilgili bir ugulama yapacam ve bu sayade hem aralarindaki farki hemde continue to ifacesini anlamis olursunuz

public class ContinueTest {
       public static void main(String args[]){
              for (int i = 0; i < 5; i++) {   
                       if(i == 2){
                              continue;
                       }
                       System.out.println("i : "+ i);
              }
      }
}
//Console Output
i : 0
i : 1
i : 3
i : 4
Gorulduyu gibi i=0 icin ekranda gosterdi i=1 icin ekranda gosterdi i=2 icin geldi sarta girdi continue ifadesini gordu ve altaki isleme gelmede for saygacina geri dondu ve i=3 icin ekranda gosterdo i=4 icin ekranda gosterdi i=5 olunca fongu saglamadigi icin donguden cikti. Simdide gelelim continue to labeled islemine ama bunun ile ilgili uygulamayi anlatmadan once bu ifadenin sandece continue ile kullanilinca ne olucagi ile continue to labeled kullanilinca ne gibi bir yarar saglayacagini gosterecegim.

public class ContinueTest {
        public static void main(String args[]) {
               for (int i = 0; i < 5; i++) {
                       System.out.println("i : "+i);
                       for (int j = 0; j < 5; j++) {
                             if (j == 2) {
                                   continue;
                             }
                             System.out.println("j : " + j);
                       }
               }
        }
}
//Console Output
i : 0
j : 0
j : 1
j : 3
j : 4
 
i : 1
j : 0
j : 1
j : 3
j : 4
 
i : 2
j : 0
j : 1
j : 3
j : 4
 
i : 3
j : 0
j : 1
j : 3
j : 4
 
i : 4
j : 0
j : 1
j : 3
j : 4

Gorulduyu gibi i=0,1,2,3,4 degerleri icin j=2 degerine gelinde sadece isteki dongu altaki islemleri yapmadan icteki dongonun basina dondu. Ama ben continue to label kullanarak icteki j=2 her geldiginde istedigim blogtan tekrardan baslamasini saglayabilirim bu degimin uygulamasini yapalim.

public class ContinueTest { 
        public static void main(String args[]) {
                //Tekrardan baslamak istedigim blog yerini belirliyorun
                tekrar:
                for (int i = 0; i < 5; i++) {
                      System.out.println("i : "+i);
                      for (int j = 0; j < 5; j++) {
                            if (j == 2) {
                                    continue tekrar;
                            }
                            System.out.println("j : " + j);
                      }
                }
        }
}
//Console Output
i : 0
j : 0
j : 1
 
i : 1
j : 0
j : 1
 
i : 2
j : 0
j : 1
 
i : 3
j : 0
j : 1
 
i : 4
j : 0
j : 1
 
Gorulduyu i=0,1,2,3,4 degerlari icin j=2 olunca benim tekrar yazdigim yere donup kaldigi yerden isleme devam ediyor

Not : Tabiki bu break to labeled ve continue to labeled sadece for dongusune mahsus birsey degil istenilen blogun terk etmek yada tekrardan basina donmek icin kullanabilirsiniz 

Conditional Operator(Şartlı Operatör)

Bu konuda sartlari yoklamanin farkli bir yolunu inceliyecez. Bildiyimiz gibi sartlari pek cok degisik yolla kullana biliyoz mesela if ile oldugu gibi ama bu kullaniminda nasil oldugunu gostermek istedim pek kullanilmiyor ama bence cok guzel ve bilinmesi gereken bir kullanim
public class MainTest {
      public static void main(String args[]){
             int x = 3;
            int y = (x>6) ? 4 : 2;
            System.out.println("Value : "+y);
            String state = (x<0) ? "NEGATIVE" : (x>0) ? "POZITIVE" : "SIFIR" ;
            System.out.println("Number State : "+state);
     }
}


//Console Output

Value : 2
Number State : POZITIVE

instanceof keyword

instanceof anahtar kelimesi sayesinde çalışma anında , Object dizisi içersindeki elemanların asil tiplerini kontrol etme imkanına sahip oluruz.
Aslinda bu konuyu analamanin en iyi yolu kucuk bir uygulama

public class Insan {
}

public class Abdulkadir extends Insan{
}
public class Ertugrul extends Insan {
}


public class Rasim extends Insan {
}

public class Nazim extends Insan {
}

public class Murat extends Insan {
}

public class Huseyin extends Insan{
}


public class Main {
        public static void main(String args[]){
               Abdulkadir a = new Abdulkadir();
               kim(a);
               Nazim n = new Nazim();
               kim(n);
               Huseyin h = new Huseyin();
               kim(h);
               Ertugrul e = new Ertugrul();
               kim(e);
       }

       public static void kim(Insan i){
            if(i instanceof Abdulkadir){
                  System.out.println("Abdulkadir Selcukoglu");
            }if(i instanceof Ertugrul){
                  System.out.println("Ertugrul Aslan");
            }if(i instanceof Rasim){
                  System.out.println("Rasim Imanov");
            }if(i instanceof Nazim){
                 System.out.println("Nazim Memedov");
            }if(i instanceof Murat){
                 System.out.println("Murat Tagiyev");
            }if(i instanceof Huseyin){
                 System.out.println("Huseyin Kacar");
            }
     }
}

//Console Output
Abdulkadir Selcukoglu
Nazim Memedov
Huseyin Kacar
Ertugrul Aslan

public class Main {
    public static void main(String args[]) {
            Insan i[] = {new Abdulkadir(), new Ertugrul(), new Rasim(), new Nazim(), new Murat(), new Huseyin()};
           for (Insan ii : i) {
               if (ii instanceof Abdulkadir) {
                     System.out.println("Abdulkadir Selcukoglu");
               }if (ii instanceof Ertugrul) {
                     System.out.println("Ertugrul Aslan");
              }if (ii instanceof Rasim) {
                    System.out.println("Rasim Imanov");
             }if (ii instanceof Nazim) {
                    System.out.println("Nazim Memedov");
             }if (ii instanceof Murat) {
                   System.out.println("Murat Tagiyev");
            }if (ii instanceof Huseyin) {
                  System.out.println("Huseyin Kacar");
           }
       }
    }
}

//Console Output
 Abdulkadir Selcukoglu
Ertugrul Aslan
Rasim Imanov
Nazim Memedov
Murat Tagiyev
Huseyin Kacar

Tanimi yaparken bu kaynaktan yararlandim
http://www.yigitemre.com/iticu/Kisa_Notlar/java_yilmaz_aydin/java/Bolum%201-12/bolum%206b.doc 

Garbage Collection

İleri düzeyde C programlama öğrendiğimden beri memory yönetimine(dynamic memory allocation) ve yazdığım kodlar içinde memory kullanımına dikkat etmeye başladım. Son günlerde uzun bir ara verdiğin Java ya hızlı bir geri dönüş yaptım ve eskiden kalma alışkanlıklarımın sürdüğünün farkına vardım ve bunu değiştirme kararı aldım kendimce. Nese önce yazdığım kod bloklarını incelemeye koyuldum ve bir çok yerde ihtiyacımdan fazla nesne türetiğimin farkına vardım ve system üzerinden memory kullanımını incelemeye başladım. Daha sonra tanımlayıp kullanmadığım nesneleri kapatıp yazdığım kodu tekrar derledim ve memory i incelemeye koyuldum. Çok ciddi fark olmasada run time de memory kullanımının daha da azaldığını gördüm. Bu olayı C dilinde kendim rahatça handle edebiliyordum fakat Javada nesneler çoğaldıkça bu iş karmaşıklaşıyordu bunun kontrolü gittikçe zorlaşıyordu bunun farkındaydım ve bu durum için birşeyler olabilirmi diye düşünmeye koyuldum aynı zamanda netten de bakııyordum. Neyseki aramalarım çok uzun sürmeden Garbage Collections ın varlığından haberdar oldum. Bu konu hakkında araştırmamı sürdürürken garbage collectionsların run time da programcıdan habersiz çalıştıklarını öğrendim yani benim memory kullanımına dair endişem birazda boşunaymış java memory optimizasyonunu otomatik olarak garbage collector ler sayesinde yapıyormuş. Bu olayı okyunca Java nın bir kez daha çok güçlü ve bir okadarda düşünceli :) bir dil olduğu kanısına vardım. Garbage Collections run time de random bir zamanda kendi kendiliğinden çalışıyor fakat bunu programcı istediği zaman tetikleyebiliyor.

Garbage Collections Java.lang.system kütüphanesinin içinde mevcut ve istediğimiz bir yerde System.gc(); olarak çağırdığımızda manuel olarakta tetiklemiş oluyoruz ve collectorumuz çalışıp memory deki çöpleri topluyor ve yer açıyor.


public class CheckGC {
        public static void main(String[] args) {
               Runtime rt = Runtime.getRuntime();
               System.out.println("Total JVM memory: " + rt.totalMemory());
               System.out.println("Before Memory = " + rt.freeMemory());
               Date d = null;
               for (int i = 0; i < 10000; i++) {
                     d = new Date();
                     d  = null;
               }
               System.out.println("After Memory = " + rt.freeMemory());
               System.gc();
               System.out.println("After GC Memory = "+ rt.freeMemory());
      }
}

//Console Output  
 Total JVM memory: 5177344
Before Memory = 4660704
After Memory = 4403968
After GC Memory = 5011864



Bu yaziyi direk bu linkten kopyaladim kisa oz yazilmis Emrah Mete hocamizin elerine saglikhttp://emrahmete.blogcu.com/java-garbage-collection/4899593

Wrapper Classes

Wrapper classes ne oldugunu anlatmadan evel birkac seyi hatirlayalim.
Java programlama dilinde iki tür değişken tipi vardır,

• Primitive Types  
• Reference Types

Primitive Types : Primitive tipleri hepimiz biliyoruz, sayısal veya boolean değerler tutuğumuz en temel tiplerimizdir (byte, int, short, long, char, float ve double gibi ).İlkel tipler hafızanın stack bölümünde yar alırlar.Bir metoda değişken olarak geçildiğinde bir kopyası alınıp kopyası üzerinden işlem yapılır, dolayısı ile mevcut değer değişmemiş olur.
Reference Types : Referans tipleri sınıflar ve arraylar dir. Referans tipleri değer tiplerinin aksine metodlara geçtiğimizde kopyaları üzerinden işlem yapılmazlar, mevcut nesneler üzerinden işlem yapılırlar.

Wrapper Classes : Java da program yazarken bazen Primitive tiplerin yukarıdaki gibi başka bir sınıf tarafından sarmalanmasına ihtiyaç duyarız. Özellikle collections sınıfları ile çalışıyorsak bu kaçınılmazdır.
Bunun sebebi collections nesneleri içerlerinde sadece object tutabilirler. Eğer biz bir collections nesnesinin içerisinde bir Primitive tip tutmak istiyorsak mecburen o Primitive tipi başka bir sınıf ile sarmalamamız gerekecek. Bu yüzden Java da java.lang package altında her ilkel tip için bir sarmalayıcı (wrapper classes) sınıf vardır.

Bir Primitive tipi bir wrapper class sınıf içerisine koyma işlemine Boxing (kutulama), wrapper class'in içerisinden Primitive tipi geri alma işleminede Unboxing (kutudan çıkarma) işlemi denilmektedir.
int x = 100;
Integer box = new Integer (x); //BOXING
int y = box.intValue(); //UNBOXING

Java 5.0 dan önce her wrapper sınıf kullandığımızda mecburen boxing ve unboxing işlemi yapmak zorundaydık.Fakat Java 5.0 ile artık bunu yapmak zorunda değiliz.Çünkü bu işlem Java 5.0 tarafından otomatik olarak yapılıyor.

Aşağıdaki kod örnekleri Java 5.0 dan önce hangi durumlarda hatalarla karşılaşacağımızı göstermektedir.

Integer i = new Integer(100); 
i++; //ERROR

Integer x = new Integer(12);
Integer y = new Integer(13); 
Integer z = x + y; //ERROR
 
int a = new Integer(99); //ERROR 
Integer b = 555; //ERROR

int w = 100;
Vector v = new Vector(); 
v.add(w); //ERROR

int k = 777;
Integer l = new Integer(333); 
int m = k + l; //ERROR 

Fakat aynı kodu Java 5.0 ile derlerseniz hiçbir hata ile karşılaşmazsınız, sebebi Boxing veya Unboxing işlemlerinin gereken yerlerde Java 5.0 ile gelen Autoboxing/Unboxing özelliği sayesinde otomatik olarak yapılıyor olmasıdır.

 Önemli Nokta;
Wrapper sınıflar immutable (değişmez) özelliğe sahiptirler, sıradan nesneler gibi davranmazlar.



Bu yaziyi yazarken http://www.csharpnedir.com kaynaktan yararlandim yazar arkadasimizi eline saglik

Initialization Blocks(Class'ta Bloglarin Calisma Prensibi )

Bu yazimda bir class icinde bloglar hangi siraya gore calistigi hakinda bir ugulama ile anlatmaya calisacam. Ama uygulamaya gecmeden sunlar demek istiyorum blog kavrami biraz genitir yani blog deyince akliniza hemen method gelmesi mesele bir kac blog cesidi yazayim

• public class TestBlockClass{}  
• public void testBlockMethod (){}
• public  TestBlockClass(){}
• static {} 
• {} 

Gorduyunuz gibi bir class'in icinde bulunan bloglardan bir kactaneyi siraldim ben bugun constructor , static blog ve sadece blog olan bloglari inceliyecem.

class Init {

         static { 
               System.out.println("1 static init"); 
          }

         static { 
                  System.out.println("2 static init");
         }

         { 
                   System.out.println("1 instance init");
          }

         {
                   System.out.println("2 instance init"); 
          }

         Init() {
                 System.out.println("1 constructor init");
         }

         Init(int x) {
                 System.out.println("2 constructor init");
         }

         Init(int x , int y) {
                 System.out.println("3 constructor init");
         }
}


public class InitMain {
      public static void main(String[] args) {
          Init i = new Init();
      }
}
 
//Console  Output
1 static init
2 static init
1 instance init
2 instance init
1 constructor init

Aslinda su olay gerceklesir bir sinif ilk cagirildigida once sinifa remde bir yer ayriliyor ve bu yere ayni zamanda static olan tum nesneler , methodlar , bloglar yukleniyor ve yuklenmesi demek bir kere calismasi demekoluyor ama her  Init class'mizi cagirdik ve remde yer olusturdu ondan sonra her Init icin olusturulan referansta tabiki program sonlanmadigi surece remde yer olusturmaz cunku artik vardir. Sadece Init ile ilgili olusturulan her referansta normal bloglar her seferinde yenide calistirilir


public class InitMain {
      public static void main(String[] args) {
          Init i = new Init();
          Init i1 = new Init(22);
      }
}


//Console  Output
1 static init
2 static init
1 instance init
2 instance init
1 constructor init
 
1 instance init
2 instance init
2 constructor init

Yukardaki yazdigim aciklama biraz karisik gibi gelsede ikinci olusturdugum InitMain ile hersey daha iyi anlasilir. Goruldiyi gibi TestMain calistirdigimizda ilk once Init class remde yer ayrilip olusuyor ve onunla beraber static bloglarimizda olusyor yani calisiyor ve referans olusturdugun icin normal bloglarimda bir kere calistir ve tabiki cagirilan constructor calisir. ama ikinsi satirda tekrar Init'in referansi olustururken sadece bloglar calisir ve constructor calisir yani static bloglar tekrar calismaz. 
 
 public class InitMain {
      public static void main(String[] args) {
          Init i = new Init();
          Init i1 = new Init(22);
          Init i2 = new Init(22,11); 
      }
}

//Console  Output 
1 static init
2 static init
1 instance init
2 instance init
1 constructor init

1 instance init
2 instance init
2 constructor init

1 instance init
2 instance init
3 constructor init


Bir uygulama daha yapip konuyu daha iyi analayalim 

public class Bird {
         static {
                System.out.print("A");
         }

         {
               System.out.print("K");
         }

         public Bird() {
               System.out.print("A");
         }
}


public class Raptor extends Bird {

       static {
             System.out.print("B");
       }

       public Raptor() {
              System.out.print("I");
       }

       {
             System.out.print("D");
       }

       static {
              System.out.print("D");
       }
}

public class Hawk extends Raptor {

       static {
                 System.out.print("U");
       }

       public Hawk() {
                 System.out.print("4");
       }

       {
                 System.out.print("R");
       }

       public static void main(String args[]){
                System.out.print("L");
                new Hawk();
                System.out.println("7");
       }
}
//Console Output
ABDULKADIR47 




 

Varargs

Java 5.0'ın bize sundugu guzel bir kullanim Array farkli bir tanim sekli ama yapilan islem ayni Arrayda yaptigimiz bir cok islemden bizi kurtariyor. Asagidaki uygulamayi gorunce dedigimi daha iyi anliyacaksiniz. Vararg'ler su sekilde tanimlanir.
String str...
int i...
Long l...

Burda dikkat etmemiz gereken method parametresi olarak kullanildigi.



public class VarargsTest {
       public static void main(String args[] ){
               names("Abdulkadir" ,"Ertugrul","Rasim","Nazim");
        }

        public static void names(String... name){
              for (String n : name) {
                    System.out.println("Name : "+n);
             }
        }
}

//Console Output
Name : Abdulkadir
Name : Ertugrul
Name : Rasim
Name : Nazim




public class VarargsTest {
       public static void main(String args[] ){
               String name[]={"Abdulkadir","Ertugrul","Rasim","Nazim"};
                names(name);
        }

        public static void names(String... name){
              for (String n : name) {
                    System.out.println("Name : "+n);
             }
        }
}

//Console Output
Name : Abdulkadir
Name : Ertugrul
Name : Rasim
Name : Nazim

public class VarargsTest {
       public static void main(String args[] ){
              System.out.println("2 + 6 = "+toplama(2,6));
       }

       public static int toplama(int... sayi){
             int sonuc = 0;
             for (int n : sayi) {
                   sonuc = sonuc + n;
             }
             return sonuc;
      }
}

//Console Output
2 + 6 = 8 
 

 
 

Passing Variables into Methods

Bu yazida method icindeki degiskenlerin bir kac deger verildikten sonra en son hangi degeri sakladiklarini ele alacam basit bir konu ama dikkat gerektiriyor. Ben bu yaziyi ornekler uzerinde anlatmanin daha iyi olacagini dusunerekten ilk uygulamama basliyom.

• Ilk once primitive tiplerteki degiskienleri incelemekle basliyorum acama primitif tiplere b ir deger verdikten sonra ve beli basli islemlerden ve deger atamalaridan gectiten sonra en son degeri ne olur.

public class PrimitifTypeTest {
     public static void main(String args[]) {
           int value = 1;
           System.out.println("Before : " + value);
           modify(value);
           System.out.println("After : " + value);
     }

     public static void modify(int valueOne) {
             valueOne = valueOne + 2;
             System.out.println("Modify : " + valueOne);
      }
}
//Console Output
Before : 1
Modify : 3
After : 1
Gorulduyu gibi oncelikle  value ilk basta 1 degerini aliyor ve sonra modify methodu cagiriliyor ve methodun parametresi valueOne'ye 1 degeri veriliyor modify methodu 1 deger ile 2 degerini topluyor ve valueOne 3 oluyor ve sonraki satirda value'nin degerine bakilinca hicbir degisiklik olmaz yani value yine 1 olur. Sebebi ise her primitive tip degerini farkli adreste saklar. Birde uygulamada value degerini modify(int valueOne) verince sadece degeri vermis oluyorum degeri kaydettikleri adreste herhangi bir degisme olmuyor

• Simdide Reference  tipteki degiskenleri inceliyelim burada olay tamamen farkli bir reference degiskenini baska bir reference degiskenine verdiyimizde hem degeri veriyor hemde kendi adresine yonlendiriyor.

public class Student {
              public String name;
             public String surname;
}

public class ReferenceTest {
     public static void main(String[] args) {
           Student studentOne = new Student();
           studentOne.name = "Abdulkadir";
           studentOne.surname = "Selcukoglu";
           System.out.println("Before : " + studentOne.name + " " + studentOne.surname);
           modify(studentOne);
           System.out.println("After : " + studentOne.name + " " + studentOne.surname);
      }

      static void modify(Student studentTwo) {
            studentTwo.name = "Ertugrul";
            studentTwo.surname = "Aslan";
            System.out.println("Modify : " + studentTwo.name + " " + studentTwo.surname);
      }
}


public class ReferenceTest {
     public static void main(String[] args) {
                Student studentOne = new Student();
                studentOne.name = "Abdulkadir";
                studentOne.surname = "Selcukoglu";
                System.out.println("Before : " + studentOne.name + " " + studentOne.surname);
                modify(studentOne);
                System.out.println("After : " + studentOne.name + " " + studentOne.surname);
      }

     static void modify(Student studentTwo) {
           studentTwo.name = "Ertugrul";
           studentTwo.surname = "Aslan";
           System.out.println("Modify : " + studentTwo.name + " " + studentTwo.surname);
     }
}
 
//Console Output
 Before : Abdulkadir Selcukoglu
Modify : Ertugrul Aslan
After : Ertugrul Aslan
Uygulamayi inceliyelim oncelikler bir tane Student diye bir reference bir degisken  olusturdum ve adina  studentOne dedim ve orencinin name ve surname field'lerine Abdulkadir Selcukoglu degerlerini verdim System.out.println ekranda yazdim sonra modify() methodundaki studentTwo'ya studentOne atadim bu atama sirasinda hem degerleri veridim hemde adres'indeki degeri verdim yani ve degisklik yapinca yani Ertugrul Aslan degerini name ve surname ye verince adresi verdigi icin onceki degeri siler ve yeni degeri verir ve boylece hem studentOne hemde studentTwo uzerinde degisiklik yapilmis olur. yani modify methodu ile studentTwoda yapilacak tum degisiklikler studentOne'yide etkiler sebebinide dedigim gibi biz studentOne degeri studentTwo verince studentTwo artik studentOne adresini gorduyunden degisikliklerden birebir etkilenir.

 

•  Simdide Array tipdeki degiskenler nasil hareket eder ona bakalim

public class ArrayTypeTest {
       public static void main(String args[]){
             int a[] = {1,2,3};
            System.out.print("Before : ");
            for (int i : a) {
                  System.out.print(" - "+i);
            }
            System.out.println();
            modify(a);
            System.out.print("After : ");
            for (int i : a) {
                 System.out.print(" - "+i);
             }
             System.out.println();
      }

      public static void modify(int b[]){
            b[0]=4;
            b[1]=5;
            b[2]=6;
            System.out.print("Modify : ");
            for (int i : b) {
                System.out.print(" - "+i);
            }
           System.out.println();
      }
}

//Console Output 
Before : - 1 - 2 - 3
Modify : - 4 - 5 - 6
After : - 4 - 5 - 6

Gorulduyu gibi reference degiskenlerindeki gibi Array tipleride bir array baska bir arry degiskene atadigimizda adres yollu atanan oluyor.

• Simdide bir bir uyari ile konuyu bittirecem Object,String,Long,Short,Byte,Integer ,Double ,Float gibi siniflarde reference olusmalarina ragmen primitive tip gibi haraket eder sebeb aynende ozel bir durumda diyebiliriz bu siniflar her olusturulan degisken iciin bir adres olusturur ve birini digerine atadiginizda ancak deger atanir adreslerde bir degisiklik olmaz.

 

 public class Test {
       public static void main(String[] args) {
             String d = new String("Abdulkadir");
             System.out.println("Before d = " + d);
             modify(d);
             System.out.println("After d = " + d);
      }

      static void modify(String s) {
             s = s + " Selcukoglu";
            System.out.println("Modify = " + s);
       }
}

//Console Output 
Before d = Abdulkadir
Modify = Abdulkadir Selcukoglu
After d = Abdulkadir

Uygulamadanda gorulduyu gibi ilk deger Abdulkadir ve daha sonra modify methodunda deger bir digerine atanmasina ragmen yapilan degislikten atkilanmiyor

Bu konu ile ilgili guzel bir uygulama daha
public class Laser {
       public static void main(String[] args) {
             Box b1 = new Box(5);
             Box[] ba = go(b1, new Box(6));
             ba[0] = b1;
             for (Box b : ba) {
                  System.out.print(b.size + " ");
             }
       }
       
       static Box[] go(Box b1, Box b2) {
              b1.size = 4;
              Box[] ma = {b2, b1};
              return ma;
       }
}

//Console Output
4 4 

Interface Class

• Interface(Arayuz) abstract siniflarin gelismi bir hali diyebiliriz.
• Bir interface interface keyword ile tanimlaniyor ve sisteme bir class dosyasi olarak kaydedilen bir yapidir
• Interface tamamen birlestirici bir rol oynamak icin gelistirilmistir.
• Interface'ler iclerinde govdesiz methodlar ve degiskenler icerir.
• Bir interface bir class'a implements keyword declare olur
• Interface class'a implementsolunca icindeki tum govdesiz methodlari Override etmek zorunda
• Interface  siniflar icin bir yol gostericidir. Yani interface icinde govdesiz methodlarin oldugunu soylemistik iste bu govdesiz methodlar olusturuken diyorki bak method senin ismin bu olacak sen bunu dondereceksin ve bu parametreleri alacaksin gibisinde olusturulan govdesiz methodlar bulundugu interfaceyi biz bir class'a implements  ettigimizde bu methodlar implements ettigimiz class'a Override olunca artik kullanicinin yapmasi gereken bu methodlari govde kismini doldurmak yani kullanici artik biliyor bu method hangi parametreleri iceriyor neyi dondurecegi gibi bilgiler ile ugrasma zahmetinden kurtuluyor.
• Interface methodlarinin erisim belirtecleri public olmak zorundadir.
• Interfacenin en onemli ozeliklerinden biriside class'lar uzerinde coklu kalitima izin vermesidir.
• Interfaceler birbirlerinden turetilebilir. Bu turutme extends keyword ile oluyor. Birdenfazla intreface extends edilmesine izin veriyor. extends olunan interface'ler Override edilmez . Ama bir sinifa implements edilince kendisi ile beraber extends olundudu tum methodlar Override olunur.
• Bir interface'yi abstract class implements edince methodlari Override edilmez. Ama abstract class bir sinifa extends olunca hem abstract'teki hemde interface'deki methodlar Override olunur.
• Interface icerisinde ayno zamanda degiskenlerde bulunur. Bu degiskenler otomatik olarak hem public hem final hemde static  ozeligine sahiptir.
• Interface icerisinde tanimlanan degiskenler ilk degerini calisma aninda verilebilir
• Interface ile ilgili bir tek sorun ile karsilasilabilir o da birden cok interfacede extends olunmis bir interface dusunelim diyelimki bu interface ikitane interfacede turemis ve bu iki interfacede geridous degerlerinin disinda ayni olan methodlari barindirmasi bazi sorunlara neden olabilir.

       public interface Insanlar {
                     String getName();
                     String getSurname();
                     int getBoy();
                     String getGozRengi();
                     int getKilo();
                     int getYas();
      }

      public class Abdulkadir implements Insanlar{

              public String getName() {
                      return "Abdulkadir";
             }

             public String getSurname() {
                   return "Selcukoglu";
             }

             public int getBoy() {
                    return 180;
             }

             public String getGozRengi() {
                     return "Ela";
             }

            public int getKilo() {
                     return 71;
           }

           public int getYas() {
                 return 27;
            }

      }
 


      public class Ertugrul implements Insanlar{

              public String getName() {
                      return "Ertugrul";
               }

              public String getSurname() {
                      return "Aslan";
              }

              public int getBoy() {
                       return 182;
              }

              public String getGozRengi() {
                      return "Kahverengi";
              }

              public int getKilo() {
                       return 70;
              }

              public int getYas() {
                     return 26;
             }
     }


      public class TestMain {
              public static void main(String argsp[]) {
                      Abdulkadir a = new Abdulkadir();
                      System.out.println("Name : " + a.getName());
                      System.out.println("Surname : " + a.getSurname());
                      System.out.println("Yas : " + a.getYas());
                      System.out.println("Kilo : " + a.getKilo());
                      System.out.println("Boy : " + a.getBoy());
                      System.out.println("Goz Rengi : " + a.getGozRengi());
                      System.out.println("----------------------------------------"); 
                      Ertugrul e = new Ertugrul();
                      System.out.println("Name : " + e.getName());
                      System.out.println("Surname : " + e.getSurname());
                      System.out.println("Yas : " + e.getYas());
                      System.out.println("Kilo : " + e.getKilo());
                      System.out.println("Boy : " + e.getBoy());
                      System.out.println("Goz Rengi : " + e.getGozRengi());
             }
      }

//Console Output
Name : Abdulkadir
Surname : Selcukoglu
Yas : 27
Kilo : 71
Boy : 180
Goz Rengi : Ela
----------------------------------------
Name : Ertugrul
Surname : Aslan
Yas : 26
Kilo : 70
Boy : 182
Goz Rengi : Kahverengi


Simdi ayni ornegi interface kullanimi sayesinde polimorfizim ile gorelim 

      public class TestMain {
              public static void main(String argsp[]) {
                     Abdulkadir a = new Abdulkadir();
                     insanP(a);
                     Ertugrul e = new Ertugrul();
                     insanP(e);
            }

          public static void insanP(Insanlar i){
                   System.out.println("Name : " + i.getName());
                   System.out.println("Surname : " + i.getSurname());
                   System.out.println("Yas : " + i.getYas());
                   System.out.println("Kilo : " + i.getKilo());
                   System.out.println("Boy : " + i.getBoy());
                   System.out.println("Goz Rengi : " + i.getGozRengi());
                   System.out.println("----------------------------------------");
          }
    }
 
//Console Output 
Name : Abdulkadir
Surname : Selcukoglu
Yas : 27
Kilo : 71
Boy : 180
Goz Rengi : Ela
----------------------------------------
Name : Ertugrul
Surname : Aslan
Yas : 26
Kilo : 70
Boy : 182
Goz Rengi : Kahverengi
----------------------------------------
 
 Simdide bir interface'nin bir cok interface'de turetilmesine bakalim yukarda yazdigim gibi bir interface'yi diger interfacede turetmek icin extends ifadesinden kullaniyoruz. Asagidaki ornektede anlasilacagi gibi Insanlar interface'si Canlikar'dan turemis ve turme sirasinda herhangi bir override islemi olmamisitir. Biz Insanlar interfacesini bir class implements edince hem Canlilar'daki hemde Insalar'daki methodlar override olunur.
  
        public interface Canlilar {
                  void yemek();
                  void sinirlenmek();
                  void acikmak();
                  String gulmek();
       }
.  
 
         public interface Insanlar extends Canlilar{
                     String getName();
                     String getSurname();
                     int getBoy();
                     String getGozRengi();
                     int getKilo();
                     int getYas();
        }
 
       public class Rasim implements Insanlar{

             public String getName() {
                     return "Rasim";
            }
            public String getSurname() {
                  return "Imanov";
           }
          public int getBoy() {
                return 165;
         }
         public String getGozRengi() {
               return "Kahverengi";
         }
         public int getKilo() {
              return 82;
         }
         public int getYas() {
            return 36;
         }
         public void yemek() {
             System.out.println("Yemek yemyi sever");
         }
         public void sinirlenmek() {
               System.out.println("Cok sinirli degil");
        }
        public void acikmak() {
             System.out.println("Normal acikir");
       }
       public String gulmek() {
             return "Ha ha ha ..... :)";
       }
  }
 

Simdide bir interface'ye bircok inteface'nin extends olunmasi uygulamasi  


public interface B { 
       // -------------------------------------
}
 

public interface C { 
       // -------------------------------------
}


public interface D { 
       // -------------------------------------
}

 public interface A extends B,C,D{
      //-------------------------------------
}

Enum

Javaya enum yapisi 1.5 versiyonundan sonra geldi.enum'lar normal siniflara benze ama bircok kisitlama getirilmistir. enum yapisi olusturulmada evel static final int seklinde tanimlanan degiskenler tanimlaniyordu ama bu bir cok sorunun cikmasina neden oluyordu. Aslinda enum tanimini yapmak yrine enum'larin nasil kullanildigi ile ilgili uygulamalar ile anlatma istiyorum.

Javada enum tanimlamak icin enum keyword yararlanilir. Daha sonra enum elemanlari {} arasina yazilir.

public enum Sebzeler {
    DOMATEZ,BIBER,PATLICAN,SALATALIK
}

Yukarda bir enum tanimladik simdi biraz daha ilerleyere bu enumdaki degerleri nasil alabiliriz.

public class TestMain {
    public static void main(String args[]) {
        System.out.println(Sebzeler.DOMATEZ);
        System.out.println(Sebzeler.BIBER);
        System.out.println(Sebzeler.PATLICAN);
        System.out.println(Sebzeler.SALATALIK);
    }
}

 //Console Output

DOMATEZ
BIBER
PATLICAN
SALATALIK 

Simdide enum icindeki methodlari inceliyelim

values() : Enum'daki elemanlari bir dizi seklinde elde etmemizi sagliyor

public class TestMain {
   
    public static void main(String args[]) {
       for (Sebzeler s : Sebzeler.values()) {
            System.out.println(s.ordinal());
        }
    }
}

//Console Output

DOMATEZ
BIBER
PATLICAN
SALATALIK

ordinal() : Isetile bir enum elemanin kacinci sirada oldugunu bildirir. burada ilk deger sifirdan basliyor.

public class TestMain {
    public static void main(String args[]) {
        System.out.println(Sebzeler.BIBER.ordinal());
        System.out.println(Sebzeler.DOMATEZ.ordinal());
        System.out.println(Sebzeler.SALATALIK.ordinal());
        System.out.println(Sebzeler.PATLICAN.ordinal());
    }
}

//Console Output

1
0
3
2

valueOf(String name) :Enum isindeki elemanlarin ismini biliyorsak valueOf methodunun parametresine istenilen enum elemanin adini yazarak elde edebiliriz.

 public class TestMain {
    public static void main(String args[]) {
        for (Sebzeler s : Sebzeler.values()) {
            System.out.println(Sebzeler.valueOf(s.name()));
        }
    }
}

//Console Output

DOMATEZ
BIBER
PATLICAN
SALATALIK

Yada bu methodun daha iyi anlasilmasi icin sunu yapabiliriz

public class TestMain {
    public static void main(String args[]) {
        System.out.println(Sebzeler.valueOf("BIBER"));

    }
}

//Console Output

BIBER 

Simdide enumlar ile ilgili farkli noktalara deyinelim

•  Enum elemanlarinin deger almasi ve bu degerlerini kullanilmasi

public enum Sebzeler {

    DOMATEZ(100), BIBER(200), PATLICAN(300), SALATALIK(400);
    int fiyat;

    Sebzeler(int fiyat) {
        this.fiyat = fiyat;
    }
}

Yukarida enum elemanlarina deger verdim ama bu degerleri Constructor parametre degeri ne ise elemanlarda o tipte degerler aliyor.

public class TestMain {
    public static void main(String args[]) {
        for (Sebzeler f : Sebzeler.values()) {
            System.out.println(f.name() +" : "+f.fiyat);
        }

    }
}

//Console Output

DOMATEZ : 100
BIBER : 200
PATLICAN : 300
SALATALIK : 400

public enum Sebzeler {
    DOMATEZ("Kirmizi"), BIBER("Yesil"), PATLICAN("Siyah"), SALATALIK("Yesil");

    String renkler;

    Sebzeler(String renkler) {
        this.renkler = renkler;
    }
}

public class TestMain {
    public static void main(String args[]) {
        for (Sebzeler f : Sebzeler.values()) {
            System.out.println(f.name() +" : "+f.renkler);
        }
    }
}

//Console Output

DOMATEZ : Kirmizi
BIBER : Yesil
PATLICAN : Siyah
SALATALIK : Yesil

• Simdide enum elemanlarina method ekleme islemine geciyoruz

public enum Hesapla {
  TOPLA{ double islem(double x, double y) { return x + y; } },
  CIKAR{ double islem(double x, double y) { return x - y; } },
  CARP { double islem(double x, double y) { return x * y; } },
  BOL  { double islem(double x, double y) { return x / y; } };

    abstract double islem(double x, double y);
}

public class TestMain {
    public static void main(String args[]) {
        System.out.println("2 + 3 : "+Hesapla.TOPLA.islem(2, 3));
    }
}

//Console Output

2 + 3 : 5.0

• Enum'lar kalitim yetenegine sahip degiller
• Enum'larin Constructor public olamaz.
• Enum yapisi interface'yi implement edebilir.

Az once yaptigimiz Hesapla enum'unu interface yetenegi ile beraber yapalim

public interface Hesap {
    double islem(double x, double y);
}

public enum Hesapla implements Hesap {

    TOPLA{
        @Override
        public double islem(double x, double y) {
            return x + y;
        }
    },
    CIKAR{
        @Override
        public double islem(double x, double y) {
            return x - y;
        }
    },
    CARP{
        @Override
        public double islem(double x, double y) {
            return x * y;
        }
    },
    BOL{
        @Override
        public double islem(double x, double y) {
            return x / y;
        }
    };

}

public class TestMain {
    public static void main(String args[]) {
        System.out.println("2 + 3 : "+Hesapla.TOPLA.islem(2, 3));
        System.out.println("2 * 3 : "+Hesapla.CARP.islem(2, 3));
        System.out.println("2 - 3 : "+Hesapla.CIKAR.islem(2, 3));
    }
}

//Console Output

2 + 3 : 5.0
2 * 3 : 6.0
2 - 3 : -1.0

Yukeridaki interface kullanarak yazdigim ornegi bir baska sekilde kullanimi

public class TestMain {
    public static void main(String args[]) {
        for(Hesapla h : Hesapla.values()){
            System.out.println(h.name() +" : "+ h.islem(4, 2));
        }
    }
}

//Console Output

TOPLA : 6.0
CIKAR : 2.0
CARP : 8.0
BOL : 2.0

• Enum konusunu inceliyorken EnumSet sinifinida incelemeden gecemiyecem

public enum Gunler {
    PAZARTESI("Monday") , SALI("Tuesday") , CARSAMBA("Wednesday") , PERSEMBE("Thursday") , CUMA("Friday") , CUMARTESI("Saturday") , PAZAR("Sunday");

    String eng;

    Gunler(String eng){
        this.eng = eng;
    }
}

public class TestMain {

    public static void main(String args[]) {
        EnumSet d = EnumSet.range(Gunler.PAZARTESI, Gunler.PERSEMBE);
        System.out.println(d);
    }
}

//Console Output

[PAZARTESI, SALI, CARSAMBA, PERSEMBE]

public class TestMain {
    public static void main(String args[]) {
        EnumSet d = EnumSet.allOf(Gunler.class);
        for(Gunler g: d.clone()){
            System.out.println(g);
        }
    }
}

//Console Output

 PAZARTESI
SALI
CARSAMBA
PERSEMBE
CUMA
CUMARTESI
PAZAR

public class TestMain {

    public static void main(String args[]) {

        for(Gunler g: EnumSet.allOf(Gunler.class)){

            System.out.println(g);

        }

    }

}

//Console Output

 PAZARTESI
SALI
CARSAMBA
PERSEMBE
CUMA
CUMARTESI
PAZAR

public class TestMain {

    public static void main(String args[]) {
        for(Gunler g : EnumSet.of(Gunler.PAZARTESI, Gunler.CUMA)){
            System.out.println(g);
        }
    }
}

//Console Output

PAZARTESI
CUMA

public class TestMain {

    public static void main(String args[]) {
        EnumSet es = EnumSet.allOf(Gunler.class);
        EnumSet e=  EnumSet.complementOf(es);
        e.add(Gunler.SALI);
        System.out.println(e);
    }
}

//Console Output

[SALI]

public class TestMain {

    public static void main(String args[]) {
        System.out.println(EnumSet.noneOf(Gunler.class));
    }
}

//Console Output

[]