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/