Operatörler

         Bugünkü konumuz operatörler olacak. Hepimizin yakından tanıdığı birçoğunu bildiğimiz şeyler, fakat gözden kaçan kısımları tekrardan ele alacağız. Umarım hepimiz için iyi bir yazı olur. Sözü fazla uzatmadan başlayalım.
Atama Operatörü ile başlayalım.
public class OperatorTest {
public static void main(String[] args) {
int i=257;
byte b=(byte)i; //daha önce de dediğimiz gibi byte ve 
                short s =(short) i; //shortlarda casting işlemi 
System.out.println(b+" " + s);  //1 257
}
}
Birlesik Atama Operatoru
public class OperatorTest {
public static void main(String[] args) {

int y = 10;
y -= 5; // y = y - 5;
y += 20; // y=y+20;
y *= 4; // y=y*4;
y /=25; //y=y/25;
System.out.println(y);  //4

int x = 3,z,m;
x *=2+5;
            z = 3 + 2 * 5; // yanlis  3+(2*5)=13
                m=3 *(2+5); //  dogru 3*(7) = 21
                System.out.println("z:"+z+"m:"+m);   
}

}
Eşitlik Operatörü
public class CompareReference {
public static void main(String[] args)  {
StringBuilder sb = new StringBuilder("referans");
StringBuilder sb2 = new StringBuilder("referans");
StringBuilder sb3=sb;
                String st="primative";
                String st2="primative";
                
System.out.println("sb==sb2 "+(sb==sb2)); //false
System.out.println("sb==sb3 "+(sb==sb3));  // true
System.out.println("sb2==sb3 "+(sb2==sb3));//false
                System.out.println("Stringler  "+(st==st2)); //true
                //eşitlik operatörü referansların içeriklerini kontrol edemez
                //fakat Stringleri gösterdiğimiz şekilde karşılaştırabilir
           
}

}
Tip Karsilastirma Operatoru
public class Test {
public static void main(String[] args) {

String name = "blogspot";
if (name instanceof String) {
System.out.println("name is a String");  // instanceof kontrolu // IS-A
}

int age = 24;
                Integer numara=23;
                // if(age instanceof int) {} //derleme hatasi
// primitive tipler icin instanceof kontrolu yapilamaz.
// if(age instanceof Integer){} //derleme hatasi  // 
                if(numara instanceof Integer){
                    System.out.println("bumara is a Integer");                
                }
                //int primative iken Integer Referanstır
}

}

instanceOf Kullanımı
abstract class Tiger{}

class Cat {}

interface IFace {}

public class Dog {
public static void main(String[] args) {
Dog dog = new Dog();
System.out.println(dog instanceof Dog);
// farkli sinif hiyerasisinde bulunan siniflar arasinda instanceof 
// operatoru derleme hatasina neden olur.
                //System.out.println(dog instanceof Cat); // derleme hatasi 
                //System.out.println(dog instanceof Tiger);//soyut sınıfta için de geçerli
System.out.println(dog instanceof IFace); //false
//Bu durum interface icin soz konusu degildir.
}

}
Aritmetik Operatörler
public class StringConcatenation {
    
    public static void main(String[] args) {
String a = "java";
int b = 10;
int c = 5;
System.out.println(a + b + c);//java105
        System.out.println(b + c + a);//15java
        //ikisi arasındaki farka dikkat edin
        //2.cide b ve c int olduğundan toplandıktan sonra String ekleniyor!!
}

}

Artırma/Azaltma Operatörü
public class Test {
public static void main(String[] args) {
int i = 5;
int k = 5;
System.out.println(i++); // postfix 5
System.out.println(++k); // prefix  6

int t = 0;
int[][] a = { { 1, 2,3 }, { 4,5,6 }, { 7, 7,9 }};
System.out.println(a[t++][++t]); // a[0][2]=3
}

}

Şart Operatörü
public class Ternary {

public static void main(String[] args) {
int point = 75;
String result = point < 50 ? "Fail" : "Success";
System.out.println(result); //Success

String result2 = point < 50 ? "F" : point > 90 ? "A" : "B";
System.out.println(result2); //B
}
}

//Bitsel ve Mantıksal Opertörler
public class Bitwise {

public static void main(String[] args) {

int i1=6&8; 

//0110 --->6
//1000 --->8
//----- & ve islemi
//0000
System.out.println(i1);

byte b=7>>2;
//00000111 --->7
// 2 bit saga kaydirirsak
//00000001 --->1
System.out.println(b);


                int i=5; //ilk koşul uygunsa yeterli
if(i>4 || i/0>1){
System.out.println(i);
}

if(i>4 | i/0>1){ // tüm koşullara bakacağınan hata fırlatır(run)
System.out.println(i);
}
}

}

      Yazacaklarımızı kod içerisinde yazmaya çalıştık. Umarız faydalı bir yazı olmuştur. Ama unutmayın bunları daha iyi anlayabilmeniz için daha çok örnek yaparsanız iyi olur.

Kaynakça
http://www.injavawetrust.com/pure-java-39-operators-01/
http://www.injavawetrust.com/pure-java-40-operators-02/
http://www.injavawetrust.com/pure-java-41operators-03/
http://www.injavawetrust.com/pure-java-42-operators-04/

Overload Ek Özellikler

       S.a. Arkadaşlar,
       Bugünkü konumuzda daha önce işlediğimiz overload özelliğini işleyeceğiz, fakat bu  sefer farklı özellikleri ve bir kaç farklı kavram üzerinde duracağız. Ne demek istediğimizi yazı ilerledikçe daha iyi anlayacağınızı umuyoruz. Yazımıza bu sefer bir örnek ile başlamak istiyorum daha sonra ne demek istediğimizi anlatacağız.

public class CoolClass {
static void coolMethod(int x) {
System.out.print("int ");
}
static void coolMethod(long x) {
System.out.print("long ");
}
static void coolMethod(double x) {
System.out.print("double ");
}
     
public static void main(String[] args) {

byte b = 10;
short s = 10;
long l = 10;
float f = 5.0f;

coolMethod(b);
coolMethod(s);
coolMethod(l);
coolMethod(f);
}
}

Çıktı
int int long double

    Burada 'b' değişkenini ele alalım. Byte kendisinden büyük , fakat ortamdaki en küçük tanımlayıcıya gidecektir. Yani ne demek istiyoruz. 3 tip de kendisinden büyüktür fakat kendisinden büyük en küçük olan int olduğu için int değerine gidecektir. Şöyle dersek belki daha iyi anlarız, eğer
static void coolMethod(short x) {
System.out.print("short ");
}
kod kısmında bulunmuş olsaydı (kod içerisine yapıştırabilirsiniz) çıktı short olacaktı. Bunun sebebi dediğimiz gibi kendisinden büyük en küçük olana gitme kuralıdır. Eğer (int x) metodu olmasaydı o zaman long , o da olmasa tüm çıktı double olacaktı. Bu söylediklerimizi daha iyi anlayabilmek için kodu değiştirip derleminizi tevsiye ederiz.  O zaman daha iyi anlayacağınızdan eminiz.


     Şimdi de bu konuyla ilgili 3 kavrama bakacağız. Wideing, Boxing ve Var-args . Bu kavramları daha önceki yazılarımızdan yabancı değilsinizdir. Wideing'i ilk kez ele alıyoruz. Fakat bu kavramların overload ile birlikte kullanımı inceleceğiz. Şimdi kodumuza geçelim onun üstünden devam edelim.

public class Test3 {
 
        static void go(byte x, byte y) {
System.out.println("byte,byte");
}

        //ilk metodu yorumlarsak bu metod
        static void go(int x, int y) { //wideing
System.out.println("int,int");
}
     
         //ilk 2 metodu yorumlarsak bu metod
        static void go(Byte x, Byte y) { //boxing
System.out.println("Byte,Byte");
}
     
         //ilk 3 metodu yorumlarsak bu metod çalışacaktır
static void go(byte... x) { //var args
System.out.println("byte ...");
}

public static void main(String[] args) {
byte b = 10;
go(b, b);

}
}

     Şimdi konuyu biraz daha açalım. Burada wideing,boxing,var-args yapılarının hangisinin öncelikli olduğunu anlamaya çalışıyoruz. Bunun için dediğimiz satırları yorumlayarak anlayabiliriz. Yani tüm kodlar aktiften çıktımız byte,byte olacaktır, fakat ilk blocku yorumlarsak wideing bpxing var args arasından wideing çalışacaktır. Bunun diğerlerine önceliği vardır. Daha sonra boxing ve en son var args önceliklidir. Kodları derlediğinizde daha iyi anlayacağınızı düşünüyoruz.

Wrapper Classes Metod ve Özellikleri

        Bugünkü konumuz yine Wrapper Classes olacak. Bir önceki yazımızda nedir ne değildir sorusunun cevabını aramıştık. Bugün ise biraz daha işin derinlerine girmeyi düşünüyoruz. Önceki yazımıza erişmek isterseniz buraya tıklayınız. Peki nedir bu metodlar:

valueOf()   String ---> Wrapper    Örn : String-> Long
xxxValue()  Wrapper ---> primitive  Örn ; Long->long
parseXXX()  String ---> primitive  Örn; String-> long

Şimdi burada ne demek istediğimizi kodlarla açıklamaya çalışacağız. O zaman konunun daha iyi oturacağını temenni ederiz. Sizi şimdi kodlarla baş başa bırakalım.

public class Wripper3lu {
    public static void main(String[] args) {
        //ValueOf metodu Kullanımı
        //aynı işlemleri diğerleri için de yapabiliriz
        Float f1 = Float.valueOf("10.5"); // Sting->Wrapper
Float f2 = Float.valueOf("10.5f");
Float f3 = Float.valueOf(10);    //float->Float| primative->Wrapper
Float f4 = Float.valueOf("10");
System.out.println(f1 + " " + f2 + " " + f3 + " " + f4 );
     
        //xxxValue metodu Kullanımı
        Integer i1 = new Integer(100);
        short s = i1.byteValue();
short s2 = i1.shortValue();
// short s3 = i1.intValue(); // int>short olduğundan error
// short s4= i1.longValue(); //long>short olduğundan error
System.out.println(s + " " + s2);
     
      long lo1 = i1.byteValue();
long lo2 = i1.shortValue();
long lo3 = i1.intValue();
long lo4 = i1.longValue();
        //dikkat edin long'ta hiç hata olmuyor.Çünkü veri kaybı söz konusu değil
System.out.println(lo1 + " " + lo2 + " " + lo3 + " " + lo4);
     
        //ParseXXX Metodu Kullanımı
        byte b1 = Byte.parseByte("10");
//byte b2 = Short.parseShort("10"); 
        //bunlarla ilgili bol bol örnek yapmak faydanıza olacaktır
        //Çünkü biz tek tek yazsak da sizin kodlamanızın önemi apayrıdır
     
float f11 = Byte.parseByte("10");
float f21 = Short.parseShort("10");
float f31 = Integer.parseInt("10");
float f41 = Long.parseLong("10");
//float f51 = Double.parseDouble("10"); double>float error
        System.out.println(f1 + " " + f2 + " " + f3 + " " + f4);  
    }
}

       Yukarıda metodları elimizden geldiğince yorum satırlarıyla anlatmaya çalıştık , fakat dediğimiz gibi örneklerle konuyu daha iyi pekiştirebilirsiniz diye düşünüyoruz. Şimdi de bazı özelliklere bakalım. Boxing, autoboxing, unboxing , autounboxing gibi bazı özelliklere de kısaaca göz atıp yazımızı tamamlayalım.

        Integer boxing = Integer.valueOf(10);
        Integer autoboxing =10;
        int unboxing = boxing.intValue();
        int autounboxing=10;

Değişken isimlerini barındırdığı özellik ile yazdık. Belki de bildiğimiz şeylerdir, fakat isim olarak nedir ne değildir bilmiyorduk, bununla birlikte yazımızı burada son veriyoruz. İyi çalışmalar

Kaynak
http://www.injavawetrust.com/pure-java-35-wrapper-03/
http://www.injavawetrust.com/pure-java-34-wrapper-classes-02/

Wrapper Classes

            Bugünkü konumuz Wrapper Classes olacak. Türkçe olarak sarmalanmış sınıflar diyebiliriz. Peki nedir bu sarmalanmış sınıflar ? Bildiğimiz gibi 2 tür değişkenimiz vardı. Obje ve İlkel . Bunları daha önceki yazılarımızda az da olsa yer vermiştik. Peki sarmalanmış sınıflar bu işin neresinde diye soracak olursanız şöyle cevap verebiliriz. Biz ilkel değişkenlerle çalıştığımız zaman (int, long gibi) bazen Objelere ihtiyaç duyabiliriz. Özellikle koleksiyon sınıfında bu gibi durumlar ortaya çıkabilir. İşte tam da bu durumda bu sınıflar ilkel değişkenimizi alıp, sarmalayıp ,obje yapar. Ve bu nedenle sarlanmış sınıflar diyoruz. Şimdi hangi tipin hangi objelere döndürüldüğüne ait bir resim paylaşacağız daha sonra da kodla bunu destekleyeceğiz.

Resim-1 

      

      Şimdi burada ne demek istiyor kısaca açıklamaya çalışalım. boolen değişkenini ele alalım. Bunun sarmalayıcı sınıfı Boolean'dır diyor. Peki hangi değerleri içine yazarsak sarmalayabiliriz sorusunun cevabı ise boolean ve Stringdir. Yani argüman olaran ya String yazmamız lazım ya da 'false/true' yazmamız lazım. Bunun dışındaki değişkenlerde hata verecektir derleyici. Mesela argüman olarak 10, 10.5 gibi nümerik değerler verdiğimizde derleyici hata verecektir. Ne istediğimizi şimdi koda dökelim. Daha iyi anlaşılacağını umuyorum.

public class Test {

public static void main(String[] args) {

Boolean b = new Boolean("tRuE"); //büyük hüçük harf farketmez

Boolean b2 = new Boolean("anything");

Boolean b3 = new Boolean(true);

Boolean b4 = new Boolean(false);

                //Boolean b5 = new Boolean(45);

                //Sadece String ve false/true değerleri alabilir

System.out.println("Boolean Test");

System.out.println(b + " " + b2 + " " + b3 + " " + b4);

               

Byte bt = new Byte((byte) 10);

Byte bt2 = new Byte("10");

                //Byte bt = new Byte(10); 

                //10'nun varsayılan değeri int olduğu için cast yapılmalı

System.out.println("Byte Test");

System.out.println(bt + " " + bt2);

                

                Short st= new Short((short)10);

                Short st2= new Short("10");

                //cast işlemi short için de geçerlidir

                System.out.println("Short Test");

System.out.println(st + " " + st2);

Character c = new Character('c');

                //Character c1 = new Character("ss");

                //character string alamaz,char alır!!

System.out.println("Character Test");

System.out.println(c);

Integer i1 = new Integer(10);

Integer i2 = new Integer("10");

System.out.println("Integer Test");

System.out.println(i1 + " " + i2);

                

                Long lo1 = new Long(10); 

Long lo2 = new Long("10");

System.out.println("Long Test");

System.out.println(lo1 + " " + lo2);

Float f1 = new Float(10);

Float f2 = new Float(10.5);

Float f4 = new Float("10.5");

Float f5 = new Float("10.5f");

System.out.println("Float Test");

System.out.println(f1 + " " + f2 +  " " + f4 + " " + f5);

                Double db1= new Double(10);

                Double db2=new Double(10.5);

                System.out.println("Double Test");

                System.out.println(db1+ "" + db2 + "");

}

}

    Kod içerisinde yorumları kısa kısa da olsa yazmaya çalıştık. Umarım anlamanıza vesile oluruz.

Metoda ilkel Veri ve Nesne Gönderimi

                Bugün metoda veri tipi gönderme üzerinde duracağız. Ayrıntı olarak metodları anlatmayacağız. Anlatacağımız konu ilkel verileri ile nesnelerin gönderimi arasındaki farktan bahsedeceğiz. Bildiğimiz gibi Java’da 8 tane ilkel tip vardı (Long, int, double, byte, short, float, char, boolean). Ve bunun dışında kalan her şey nesneydi. Şimdi bu iki tür arasında nasıl bir fark olduğunu birlikte inceleyelim. Bu konuda benim de daha önceden kafam karışıyordu. Fakat aşağıdaki kodlar sayesinde bu konuyu daha iyi anladım. Umarım okuyanlara da faydalı olur diye anlatmaya çalışacağım. Öncelikle ilkel veri gönderimi göndereceğiz. Burada bir sorun yok beklenen oluyor. Sözü fazla uzatmadan koda geçelim.

public class OrnekTemelTip{

    public static void main(String[] args){

        int sayi = 5; ;//int değil de diğer ilkel değişkenler de olabilir

        System.out.println("Metottan Once = " + sayi);//5

        degerArttir(sayi);

        System.out.println("Metottan Sonra = " + sayi); // 5

    }

   

    public static void degerArttir(int deger){

        deger += 1;

        System.out.println("Metod İçinde = " + deger); //6

    }

}

        Önceden bildiğimiz gibi burada 5 değerini gönderiyoruz. Metoddan değer 6 oluyor fakat main içindeki değişkenin değeri aynı kalıyor. Fakat bu nesnede nasıl oluyor bir de ona bakalım

public class OrnekReferansTip{

    public static void main(String[] args){

        TamsayiSinifi d = new TamsayiSinifi();

        d.sayi = 5;

        System.out.println("Metottan Once = " + d.sayi);//5

        degerArttir(d);

        System.out.println("Metottan Sonra = " + d.sayi);//6

    }

   

    public static void degerArttir(TamsayiSinifi d){

        d.sayi += 1;

        System.out.println("Metod içinde = " + d.sayi);//6

    }

}

class TamsayiSinifi{ 

    public int sayi;

}

Burada ilkel veri göndermeden farklı olarak main içindeki değişken de artık 6 değerini alıyor. Bunun nedeni objenin kendisini değil de referansını göndermemizden kaynaklanıyor. Ama temel veride sayının bizzat kendisi gönderiliyordu. Umarım aradaki farkı anlamanıza yardımcı olabilmişizdir.

Kaynak:

Kodlar Aybars Uğur'dan alınıp bir kısmı değiştirilmiştir

Diziler

                Bugünkü yazımızda dizileri ele alacağız. Dizilerin bu işle ilgilenen herkes az çok nedir, neden kullanılır gibisinden bir şeyler biliyordur. Biz de hem bildiklerimizi bir gözden geçirmek hem de birkaç ince noktasını gözden geçirmek istiyoruz.

                Peki nasıl tanımlanır bu diziler diye bir bakalım

int[] dizi veya int dizi[] olarak tanımlayabiliriz fakat bu işin standardı olarak görülen ilk tanımlamadır, fakat ikinci tanımlama da hata vermez.

int[] dizi= new int[10]; burada dizimizin boyutunu belirlemiş oluyoruz. 10’dan fazla değer girdiğimizde derleyici bize hata verecektir. Peki 2 boyutlu bir dizi tanımlamak istersek ne yapmamız gerekecek. Hemen onu da kodlayalım.

String[][] dizi= new String[10][]; burada String dizisi oluşturduk 2 boyutlu olarak , eğer 2den fazla oluşturmak istersek sağına ve soluna eşit sayılarda köşeli parantezler ekliyoruz. Şimdi biraz daha 2 boyutlu diziyle ilgili bir şey söyleyelim. Aşağıdaki kodu incelerken yanına not edelim söyleyeceklerimizi.

            int [][] myArray = new int[3][];

            myArray[0] = new int[3]; // 0.nci elemana 3 elemanlı bir dizi atıyoruz

            myArray[0][0] = 6;

            myArray[0][1] = 7;

            //myArray[0][2] = 0; burada tanımlanadığımız halde otomatik 0 olur

            myArray[1] = new int[3];

            myArray[1][0] = 9;

            myArray[1][1] = 8;

            myArray[1][2] = 5;

            myArray[2]=new int[3]; //3 satırdaki tüm elemanlar sıfır olacak

            for(int i=0; i<2;i++){

                for(int j=0; j<3;j++){

                    System.out.print(" "+myArray[i][j]);

                }

                   System.out.println("");

            }

Çıktı:

6 7 0

 9 8 5

 0 0 0

                Son olarak da dizinin başlangıçta değer nasıl atanır ona bakıp dizi yazımıza son verelim. Onu da şu şekilde yapabiliriz.

int [] ages2= new int[]{20,30,40,50}; // değerleri burada girdiğimiz zaman dizinin boyutuna herhangi bir değer girmiyoruz, yoksa derleyici hata verecektir.

int [] ages2= new int[4]{20,30,40,50}; //error

Peki bu dizi birden fazla boyutlu olursa nasıl tanımlama yapacağız

int[][] scores = { 2, 4, 5 }, { 10, 20, 3, 9 }, { 4 }, {} }; // dikkat ettiyseniz burda new int[] gibi bir tanımlama yok, yani bunu koymak opsiyonel birşeydir. Seçeneğe bağlı. New [][] koysak da olur, derleyici hata vermeyecektir.

Değişkenlerle İlgili

Bu yazımızda değişken tanımlamalarından, neyin nerde tanımlanabileceği ve ne kadar süre varlığını sürdürebilir gibi sorulara cevap vermeye çalışacağız. Şimdi konumuza bir kod örneği ile devam edelim.

class Sinif {

static int count = 20; // static değişken, her yerde geçerlidir

String s; // instance değişken, staticten sonra en kapsamlı değişken

                //new operatörü ile kullanılır

int i; // instance variable – yukarıdaki String ile aynı tanımlama

void coolMethod() {

                int k = 25; // local (yerel) değişken, sadece bu metodda

                for (int t = 0; t < 10; t++)

                          k += k + t; // block variable, sadece bu blokta

                }//metod

}//sinif

           Daha önceki yazılarımızda söylemiştik , static olmayan değişkenleri static olan yerden çağıramıyoruz. Yani ne demek istiyoruz derseniz, şöyle:

public static void main(String[] args) {

       //  s="error"; // yukarıdaki kodda s tanımlanmış olduğu halde hata verir

                           //sebebi ise new operatörü ile ancak çağırabilmesidir

          Sinif  sinif= new Sinif();

          npe.s="run"; //burada doğru bir şekilde çalışır

          count=5; // burada herhangi bir hata olmayacaktır. Çünkü count statictir

      }

Şimdi de değişkenlerin değer atanmadan önceki hallerini inceleyecek olursak ;

Bildiğiniz gibi 2 çeşit değişken vardı. Primative (ilkel) ve nesneler vardı

İnt,long,short,byte = 0

Float,doube=0.0

Boolean=false

Char=’\u0000’

Tüm nesneler ise = null olur.

           Hatırlatacağımız bir nokta daha instance olan değişkenler değer atanmandan da kullanabilir. Çünkü otomatik olarak null değer atanır. Aynı şeyler diğer tipteki değişkenler için de geçerlidir. Fakat local olan değişkenler kesinlikle tanımlanmalıdır. Yani ;

class NPE {

String s; // instance variable

         public static void main(String[] args) {

             String h;

             //System.out.println(h); burada hata veriyorken, o nedenle localler kesinlikle tanımlanmalı

             NPE npe= new NPE();

             System.out.println(npe.s); //burada null değeri verir. Çünkü otomatik tanımlama vardır          

         }

}

Literal-Assignment

       S.a. Arkadaşlar,
        Bugünkü yazımız ise literaller olacak. Burada primitave (ilkel değişkenler) nasıl tanımlanır , onu öğreneceğiz. Bilmediğimiz ya da gözden kaçırdığımız bir yer var mı onu bakacağız. Burada kodu verip onun üzerinden anlatmaya çalışacağım. Siz de kodu derleyip kafanıza takılan kısımları kod üzerinden derleyip neyin ne olduğunu daha iyi analrsınız diye düşünüyorum

public static void main(String[] args) {
        //a,b,c değişkenleri hepsi 15 tanımladık gibi ama çıktısına dikkat ediniz
        int a = 15;  // 10luk tabanda
int b = 015; // 8lik tabanda , değerden önce 0 yazılmalı
int c = 0x15;//16lık tabanda , değerden önce 0x|X yazılmalı
             
        double d=100.343d; // d|D olsa da olur olmasa da 
        float f = 100.343f; // f|F koymak zorunlu yoksa hata alırız
             
        boolean  dogru=true; // sadece true|false alır
        byte k =(byte) 10;    // varsayılan int olduğu için cast yapmakta fayda var
        //byte hata= 128;      //[-128,127] aralığında olduğundan hata verir
             
        char m = 'm'; //charlar tek karekter alır 'xy' hata verir
char n = 100; // 100 hangi karektere karşılık geliyorsa o yazılır
char h = (char) 90000; // char [0-65535] aralığındadır.Unutmayalım
        char g = (char) -20;  // o nedenle cast yapmamız gerekti
char x = '\'';  // bir karekteri yazmak isterken önüne \ koymalıyız

System.out.println("int değerler: "+a + "  " + b + "  " + c  );
        System.out.println("float değerler:"+ d + " " + f);
        System.out.println("boolean değer:"+dogru+"byte değer:"+k);
        System.out.println("char derğerler:"+m +" "+ n+ " "+h+ " " +g+ " "+ x);
    }

ÇIKTI
int değerler: 15  13  21
float değerler:100.343 100.343
boolean değer:true byte değer:10
char derğerler:m  d  徐 ￬ '

Kaynak
http://www.injavawetrust.com/pure-java-22-literals/

Coupling - Cohesion

       S.a. Arkadaşlar,        
       Bugünkü yazımızda coupling ve cohesion kavramlarından bahsedeceğiz kısaca. Bu iki kavramı kullanmasak ne olur diye düşünebilirsiniz. Hatta kullanmadan kod da yazabilirsiniz fakat bir değişiklik yapmak istediğinizde beklemediğiniz hatalar alabilirsiniz veya sizden sonra gelen bir kişi sizin yazdığın kodlarda çok fazla zorlanabilir. Bu nedenle bu yöntemleri kullanmakta faydalı olduğunu düşünüyorum. Şimdi gelelim bu kavramaların ne olduğuna.

                Coupling: Bağlantı/bağlanma anlamına gelen coupling sınıfların birbiriyle olan ilişkisidir. Yani her bir sınıf diğer sınıflarla ne kadar ilişkilidir. Burada amaç her sınıf başka sınıf ile minimum etkileşimde bulunmasıdır. Tabi bu ne kadar mümkün olabilir o da ayrı mesele , fakat biz elimizden geldiğince sınıfları özgürleştirebilmeliyiz. Yoksa dediğimiz gibi bir kodu değiştirirken başka bir sınıfı da etkilediği için onu da göz önüne almalıyız. O da başka bir sınıfla ilişkiliyse işin içinden çıkmakta zorlanabiliriz. Buna ek olarak da değişkenlerimizi private olarak tanımlamamız mümkünse öncelik private tanımlamalıyız , olmazsa default, procted ve mecbur kalmadıkça public kullanmamalıyız. Şimdi kısa bir kod coupling konusunu umarım daha iyi anlayabiliriz.

class A {

                void metod() {

                               B b = new B();

                               b.isim = "Kotu Tanimlama";

                               System.out.println(b.isim);

                }

}

class B {

                public String isim;

}

//

class A {

                void metod() {

                               B b = new B();

                               b.setIsim("iyi Tanimlama");

                               System.out.println(b.getIsim());

                }

}

class B {

                private String isim;

    public String getIsim() {

        return isim;

    }

    public void setIsim(String isim) {

        this.isim = isim;

    }

       

}

                Şimdi de Cohesion konusunu bakıp yazıyı tamamlayalım. Burada ise her sınıfın çok iyi tanımlanmış olmasıdır. Örneğin bir odamız olduğunu düşünüp her yerde eşyalar var. Bunu mu tercih ederseniz yoksa ufak ufak odalarımızda ve her birinde ne olduğunu tam olarak bildiğimiz bir şey mi tercih edersiniz. İşte tam da bu noktada cohesion ortaya çıkıyor. Bir de kodla açıklarsak ;

Class Sinif(){

Void oda1(){}

Void oda2()[}

Void oda3(){}

}

//yerine

Class SinifOda1(){

Void oda1(){}

}

Class SinifOda2(){

Void oda2(){}

}

Class SinifOda3(){

Void oda3(){}

}

Static Değişken ve Metodlar

S.a. Arkadaşlar,
Bugünkü yazımızda static değişken ve metorları incelemeye çalışacağız. Nedir peki bu static olma konusu, bir sınıfta çağırılıp her yerde erişilebilen değişkenlerdir. Tek bir kopyası vardır ve her yerde o kopya üzerinde işlem yapılır. Örneğin elimizde farklı sınıflardan erişmek istediğimiz bir değişkenimiz olsun. Bunu nasıl kullanabiliriz. İşte tam da bu sorunun cevabıdır aslında static kavramı. Şimdi yazdığımız bir kod üzerinde bunu incelersek umuyorum ki taşlar yerine daha iyi oturacaktır.

public class SayacArtir {

    

static int count = 0;

        int sayac=0;

SayacArtir() {

count++;

                sayac++;

}

void method1() {

System.out.println("metod1 içinde count Değeri:"+count); 

          System.out.println("metod1 içinde sayac Değeri:"+sayac);          

}

     
static void method2(){

         System.out.println("Metod2 içinde count Değeri:"+count); // OK

        //System.out.println(sayac); // ERROR

        //static olan metoddan static olmayan değer çağrılmaz 

 }

public static void main(String[] args) {

        new SayacArtir();

        new SayacArtir();

new SayacArtir();

                

//method1(); //static olan metod içinden static olmayan metod çağrılmaz

SayacArtir sayacArtir= new SayacArtir();

        sayacArtir.method1();//ancak böyle tanımlayıp çağırırız

        method2(); //fakat static metodu nesne oluşturmadan direkt çağırabiliriz

        System.out.println("Main içinde Count Değeri:" + count); 

        //System.err.println(""+sayac); static olmadığından error verir

        System.out.println("Main içinde Sayac Değeri:"+sayacArtir.sayac);

}

}

ÇIKTI:

metod1 içinde count Değeri:4

metod1 içinde sayac Değeri:1

Metod2 içinde count Değeri:4

Main içinde Count Değeri:4

Main içinde Sayac Değeri:1

       Burada önemli bir konu daha vardı o da static metodların override edilmemesiydi.Bunu yukarıda da belirmiştik ama şimdi bunu kod ile incelersek daha iyi ifade etmiş oluruz kendimizi ve böylece konuyu noktalamış oluyoruz. Not: Aşağıdaki kod scjp kitabından alıntıdır.

class Animal {
  static void doStuff() {
    System.out.print("a ");
  }
}
class Dog extends Animal {
  static void doStuff() {
    System.out.print("d ");  //burada override olmamıştır.
    //eğer metod static olmasaydı çıktığımız a d olacaktı
  }
  public static void main(String [] args) {
    Animal [] a = {new Animal(), new Dog()};
    for(int x = 0; x < a.length; x++)
      a[x].doStuff();          
  }
}

ÇIKTI
a a

Constructor

      S.a. Arkadaşlar,
      Bugünkü konumuz constructor yani yapılandırıcılardır. Her ne kadar yapılandırıcı kelimesi olsa da Türkçe karşılığı olarak biz yine constructorı kullanacağız. Nedir peki bu constructor ?

        Bir nesnenin otomatik olarak oluşmasını sağlayan metodlara benzeyen , fakat dönüş tipi olmayan sınıfla aynı isimdeki yapıya diyoruz. Her sınıf bir constructori vardır. Fakat eğer biz bunu tanımlamazsak derleyici bunu bize otomatik olarak tanımlar. Ve de tanımlanan constructor class ile aynı erişim belirticine sahiptir. Yani public sınıfımız varsa constructor da public olmalıdır. Tabi private, procted de olabilirler.

         Bu kadar tanım herhalde şimdilik yetmiş olmalı. Peki kod kısmına geçelim yavaş yavaş gerekli yerlerde yine kısa yorumlarla konuyu daha iyi pekiştireceğimize inanıyorum.

Class A{

         A(){ } // A sınıfının yapılandırıcı

}

         Fakat şöyle bir durum da var. Yukarıda otomatik olarak constructor tanımlanır demiştik ama bu arka planda olur . Biz görmüyoruz diye yok değildir. Bu konuya dikkat etmemiz gerekir. Fakat şöyle bir nokta da vardır. Biz kendimiz bir constructor tanımladığımızda artık otomatik olarak derleyici tarafından constructor tanımlanmaz. Bunu ise şöyle bir örnek üzerinden yaparsak belki daha iyi anlamış olacağız.

Class A{

                A(int a, int b){

//kodlar

}

}

       Main içinde bildiğiniz üzere A a = new  A(); il obje oluşturup bunu kullanabiliyorduk fakat burada derleyici hata verecektir. Bunun sebebi ise constructor içinde parametre tanımlanmış ve objemiz de argüman almalı yani A a = new A(10,20); gibi olmalıdır. Peki yukarıdaki obje tanımının doğru olabilmesi ne yapmamız lazm. Hemen söyleyelim. A sınıfın içine A(){} eklememiz gerekmektedir. Tekrardan toparlamak gerekirse ; otomatik olarak çağırıldığında böyle bir tanıma gerek duymazdık , fakat elle tanımladığımız için constructorı , bu sefer A() {} eklememiz de gerekti.

Özelliklerine bakmaya devam edelim birlikte ,

Class A{

       Void A(){} // bu tanımla doğrudur fakat bu constructor değil,metoddur.

                          //burada A(){} otomatik tanımlanır, ama görünmez

}

                Tekrar bir sınıf ve bir constructor tanımlayıp bazı özelliklerinin üzerinde duralım

Private Class A{

         Private A(){ //erişim belirteci sınıfınki ile aynı olmalı demiştik

         Super(); // ilk satır super()/this() olmalı !!

          //kodlar

          Private A(int a) {} // overload yapabiliyoruz, fakat override yapamayız.

}

}

Kaynak

http://www.injavawetrust.com/pure-java-18-constructor-01/

Interface (Arayüz)

S.a. Arkadaşlar,
İnterface, bir class'ta olması gereken method ve property'leri tanımlayan yapıdır. Kendisi normal bir class değildir, sadece neyin yapılacağını göstermekte, ancak nasıl yapılacağını göstermemektedir. Kalıtımı gerekli kıldığı için pek tercih edilmiyor ama zorunlu olduğumuz kullanılabiliriz .[1]

İnterface (arayüz)ler %100 abstractırlar. Yani bu ne demektir. İçerdiği metodlar boş gövdelidir. Ve herhangi bir kod içermezler. Aslında biz interface aracılığıyla kısmen tasarım yapıyoruz diyebiliriz. Daha sonra implement edilerek o arayüzü (interface) kullanabiliriz. Fakat içerisinde kesinlikle başka bir metod tanımlayamayız. Derleyici bize hata verir. Ve bu yüzden biz interfacelere %100 abstract diyoruz.

Bir sınıf eğer bu metodları kullanacaksa kesinlikle override yapması gerekmektedir. Çünkü metodlar gövdesizdir. Ve onu override ederek kendimiz doldurmuş oluyoruzç. Yoksa boş olan metod işimize yaramayacaktır. Fakat burada dikkat edilmesi gereken kısım abstractların böyle bir zorunluluğu yoktur. Override etmek zrounda değiller yani.

Kısaca bir interface tanımlayalım ve ne dediğimizi oradan anlatmaya çalışalım.

public interface Cokgen exetnds interface1, interface2 {

//double hacim();  hepsi aynı anlamdadır.

//public abstract double hacim();

 public double hacim();

  abstract public double alan();   

  int kenar=1;

//public static final int=1;

}

            Burada gördüğümüz gibi , metodlar tanımlanmış ve gövdeleri boştur. Noktalı virgül ile sonlandırılmışlardır. Dikkat etmemiz gereken diğer bir husus ise her metod kendiliğinden “abstract public/ public abstract” tanımlıdır. Yani yukarıda gösterdiğimiz tüm satırlar aynı şekilde doğru çalışır. Derleyici bunu kendiliğinden ekliyor.

            Burada dikkat çekeceğimiz başka bir konu ise çoklu kalıtım izin verilmesidir interfacelerde. Bilindiği gibi classlarda çoklu kalıtıma izin verilmezdi. Derleyici hata verirdi ama burada böyle bir şey yok. Birden fazla sınıftan da ara yüzümüzü kalıtabiliriz. Fakat unutmamak gerekir ki hiçbir şekilde implement edilemezler. Böyle bir şey yaptığınızda zaten derleyici size hatayı verecektir.

            Dikkat çekmek istediğimzi bir başka konu ise değişken tanımlamaları. Burada tanımladığımız her değişken sabit tanımlayıcı değerindedir. Yani ne demek istiyoruz. Yukarıda da belirtilmiş int ile static int değeriminiz bir farkı yoktur. Her tanımladığımız değer final olarak algılanmaktadır.

             
Kaynakça
[1]www.kurumsaljava.com/download/68/