Inner Classes-2

       S.a. Arkadaşlar,
      Bugünkü konumuz yine dahili sınıflar olacak. Birinci yazıda dahili ve interface dahili sınıfları işlemiştik. Bu yazımızda ise anonymous ve static dahili sınıfları işlemeyi düşünüyoruz. Böylece dahili sınıfları bitireceğiz. Şimdi devam kaldığımız yerden. Öncelikle anonymous dahili sınıfına başlayalım. Adından da anlayacağımız gibi belirsiz ya da adı olmayan sınıf olarak da nitelendirebiliriz. Peki bu ne demektir , isimsiz sınıf mı olur dediğini duyar gibiyim, burada isim olmasından kasıt direkt bir ad yazmak yerine , obje ile birlikte kullanılmasından kaynaklanıyor. Kod tarafına geçeceğimiz zaman yorum satırlarıyla destekleyip ne demek istediğimizi umarım daha iyi anlayacaksınız.

class Keyboard {//extends Computer, run time error
public void write() {
System.out.println("Keyboard Write");
}
        public void anotherWrite(){
               System.out.println("kEYBOARD wRITE");
        }
}
interface  Mouse { //diğer dahil sınıflardaki gibi interface
       public void move();
       public final static int sensivity=5;
       int speed=5; //yukarıdaki tanımlama ile aşağıda aynıydı hatırlarsanız
}

abstract  class Printer{ // ve soyut sınıf tanımlanabilir
        public abstract void scan();
     
}

public class Computer {

Keyboard keyboard = new Keyboard() {
@Override
public  void write() {
System.out.println("Anonymous Write");
}
                public  void bigWrite(){
                        System.out.println("ANANYMOUS WRITE");
                }
}; // noktali virgulu unutmayalim!

Keyboard keyboard2 = new Keyboard();

public static void main(String[] args) {
Computer com = new Computer();
com.keyboard.write();
com.keyboard2.write();
                //com.keyboard.bigWrite();
                com.keyboard.anotherWrite();
                com.keyboard2.anotherWrite();
             
                Mouse mouse = new Mouse() {
@Override
public void move() {
System.out.println("Anonymous Move");
}
};//noktalı virgüllere dikkat
                mouse.move();
             
                String localVariable="local";
                final String localFinal="local Final";
                Printer printer = new Printer (){
                   // static String staticVariable = "compile error"; error
                    static final String staticVariable = "run";
                    //static final void metod();
                    //metod her haliyle hata verir hatırlarsanız
                    @Override
                    public void scan(){
                            System.out.println("Anonymous Scan");
                            //System.out.println(localVariable);
                            //final olursa dışarıdaki local değişkene erişebilir
                            System.out.println(localFinal);
                         
                    }
                };//noktalı virgüller dikkat
                printer.scan();    
         }

}

      Yorum satırlarıyla elimiz geldiğince gerekli yerlerde konuyu anlatmaya çalıştık ama karışık gelmiş olabilir bazı şeyler , belki de yeterince sade anlatamamış olabiliriz. Anlamadığımız yerler olduğu zaman sormakta çekinmeyin. Birlikte öğrenmeye gayret ederiz. Şimdi de static dahili sınıflara geçelim. Static dahili sınıf aslında tam olarak dahili sınıf olarak da tanımlanmayabilir. Bu ne demek şimdi diye sorduğunuzu duyar gibiyim. Şöyle anlatalım. Bir sınıf içerisinde sıradan bir metod çağırdığımızda ne yapmamız gerekiyordu. Öncelikle bir nesne oluşturup Sinif sinif= new Sinif(); sinif.metod(); demememiz gerekliydi bildiğiniz gibi fakat bu metod static olduğunda ne yapıyorduk her hangi bir obje oluşturmadan da metodu çağırabiliyorduk. Bu static dahili sınıf da öyle , dışarıdaki sınıfa ihtiyaç olmadan değişken ve metodlara ulaşılabilir. Kod kısmına geçip örneklendirdiğimiz zaman daha iyi anlayacağınızı düşünüyoruz.

public class Outer {

static class StaticNested {
                private String instanceVariable = "I am instance variable";
private static String staticVariable = "i am static variable";
void method() {
System.out.println("StaticNested method");
                        System.out.println(instanceVariable);
                        System.out.println(staticVariable);
}

static void staticMethod() {
System.out.println("StaticNested static method");
                        //System.out.println(instanceVariable);
                        //beklenen yine oldu ve staticte static olmayan çalışmaz
                        //staticleri asil olarak düşünün, ve asiller kendi aralarına
                        //diğer tabakadakileri almıyorlar ...
                        //ama diğer tabakalardaki insanların olduğu yere
                        //asiller girebiliyor. Umarım iyi bir örnek olmuştur
                        System.out.println(staticVariable);
}
}

class InnerClass {
void method() {
System.out.println("InnerClass method");
}

                //static void staticMethod() {
                //System.out.println("compile error");
                //}
                //static olmayan sınıf içinde static metod tanımlanmaz
}

public static void main(String[] args) {

                Outer.InnerClass innerClass = new Outer().new InnerClass();
InnerClass innerClass2 = new Outer().new InnerClass();
                //yukarıdaki static olmayan dahili sınıf tanımlaması
                //aşağıdaki ise static sınıf tanımlaması
                //aradaki farka dikkat edin lütfen

StaticNested staticNested = new StaticNested();
                staticNested.method();
                //Static.method desek hata çünkü metod static değildir!!
                StaticNested.staticMethod();
                //baş harfe dikkat, küçük harf yaptığımız zaman warning veriyor
                //diyor ki obje tanımlamanıza gerek yoktur direk çağırabilirsiniz
                //bunu söylemesinin sebebi static oluşudur
}

}

    Static dahili sınıflarla birlikte hem yazımızı hem de dahili sınıfları geride bıraktık. Umarız en iyi şekilde verim alabilirsiniz. Çalışmalarınıza başarılar dileriz. Kolay gelsin

Inner Classes

        S.a. Arkadaşlar,
        Bugünkü konumuz inner classes olacak. Türkçeye dahili sınıf olarak da çevirebiliriz. Java sınıf içinde sınıf tanımlamamıza izin verir. Peki bunun bize verdiği avantajlar nelerdir dersek, Java'da bildiğimiz üzere çoklu kalıtım yoktur. Yani SubClass extends SuperClass,Super2Class gibi bir tanımlama yoktur. Bunu Java'da dahili sınıflar ve interfaceler yapar. Öncelikle kod okunurluğunu sağlar. Çünkü bir sürü sınıf yerine , her sınıfın ilgili olduğu alt sınıflarını oluşturabiliriz. Bu da bize bir sürü ayrı sınıflar yerine daha derli toplu , hiyerarşik bir yapı sağlar. Tabi bunun değerini büyük projelerde daha iyi anlayabiliriz. Ayrıca bu iç sınıflar private olarak tanımlanabilir ve kendi dış sınıfının temel elemanları hariç , diğer inner classlar erişemez, fakat bizim classlarda public ve default erişimi dışında private veya protected erişimi yoktu. Bu da bize daha iyi kapsülleme sağlar. Şimdi de bu sınıfların kullanım ve özelliklerine geçelim. Burda ise kod üzerinden ilerlemekte fayda var

public class OuterClass {

    private String gizli = "static olmayan gizli";
    private static String gizliStatic = "static ve gizli";

    public static void main(String[] args) {
OuterClass.InnerClass innerRef = new OuterClass().new InnerClass();
innerRef.innerTestMethod();
        //içinde bulunduğumuz main static ama çağırdığımız metod
        //static olmadığı için obje yardımıyla çağırmalıyız
System.out.println(innerRef.kelime);//yukarıdaki kural yine geçerli
    }

    private void outerTestMethod() {
System.out.println("Dış Test Metodu");
    }

    private static void outerStaticTestMethod() {
System.out.println("Static Dış Test Metodu");
    }

    private class InnerClass { //class olsa ya default ya public olurdu
private String kelime = "Private Tanımlama";
        //burada staticle birlikte final kullanılmazsa error verir
        private static final String staticInner = "Innerde Statiklik";
        //private static final void metod(); Hatalı
        //metod static olmaz. Çünkü static olmayan bir metod içinde
        //static bir metod tanımlamaya çalışmış oluruz
        private void innerTestMethod() {
System.out.println(gizli);
System.out.println(gizliStatic);
                     
outerTestMethod();
         //dikkat edin bir obje oluşturup çağırmıyoruz
         //çünkü zaten hem iç sınıf static değil hem metod static değil
outerStaticTestMethod();
                //staticlerde zaten direkt olarak çağırabiliyorduk
        }
    }
}

    Classlar durum şimdilik böyle , peki interfacelerde nasıl olacak peki ? İnterfaceler biraz daha farklı mesela interface , herhangi bir sınıf veya interface içerisinde tanımlasa dahi private veya protected değeri alamaz. Nedeni de hatırlayacağımız üzere interfacelerin public abstract özelliği taşıyor olmasındandır. Başka bir konu ise override konusu. Bildiğimiz gibi interfaceler içerisinde gövdesiz metod  ve sabit değişken tanımlayabiliyorduk. Peki metodları nerede override etmemiz gerekir diye soracak olursak , eğer içerideki interfaceyi kullanırsak sadece inner interfaceleri override tanımlamamız yeterlidir. Aynı şey dışarıdaki interfaceler için de geçerlidir. Kısa bir örnek yaparsak belki daha iyi anlamış oluruz.

interface OuterNestedInterface {

public abstract void outerMethod();

public interface PublicNestedInterface {
public abstract void innerMethod();
}
}

//implement ederken önce dış sonra iç sınıf yazılmasına dikkat
public class OuterNestedTest implements OuterNestedInterface.PublicNestedInterface {
 
@Override
public void innerMethod() {
//sadece içerideki metod override edilmiş !!
}

}

class Outer2 implements OuterNestedInterface {
     
@Override
public void outerMethod() {
//sadece dışarıdaki metod override edilmiş
}

}

//birden fazla extends kullanılmaz(çoklu kalıtım yoktur), fakat implementler edilebilir
class Outer3 implements OuterNestedInterface, OuterNestedInterface.PublicNestedInterface {

@Override
public void outerMethod() {
            //hem dış metod
}

@Override
public void innerMethod() {
            //hem iç metod override edilmeli
        }
}