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
        }
}

Generics-2

      S.a. Arkadaşlar,
      Bugünkü konumuz genericsler olacak. Daha önce özet maheyetinde bir yazı yazmıştım ama şimdi daha farklı bir özellikleri ile ele alacağız. Birinci yazıya buradan erişebilirsiniz. Bu konuyla ilgili temel bilgileri orada bulabilirsiniz. Burada biraz daha ayrıntılı olarak ele almaya çalışacağız. Belki konuya paldır küldür girmiş gibi olacağız ama yaptığımız örnekler jeneriklerin özellikleri ile ilgili neler yapılıp neler yapılmayacağı ile ilgili gibi düşünün. Şöyle söylememek gerekirse bildiğimiz gibi dizilerde IS-A kavramını kullanmamıza izin veriyordu, fakat jeneriklerde nasıl oluyor diye bir soru aklımıza gelirse ? Bir bakalım hemen nasıl olduğuna ..

class Living {
 
}

class Animal extends Living{
 
}

class Dog extends Animal {

}

public class ArrayTestMethod {

public static void main(String[] args) {
Animal[] animalArray = new Animal[5];
Dog[] dogArray = new Dog[5];
Animal[] animalDogArray = new Dog[5];
                //burada görüldüğü gibi Dog IS-A Animal
                //olduğundan hata olmayacaktır
             
arrayRules(animalArray);
arrayRules(dogArray);
arrayRules(animalDogArray);
                /******************************/
                List<Animal> animalList = new ArrayList<Animal>();
List<Dog> dogList = new ArrayList<Dog>();
                List<Living> livinglist= new ArrayList<>();

addAnimal(animalList);
addAnimal(dogList);//dikkat
                //eğer = extends wildcardsı kullanılmasa
                //Dog subclass bile olsa error verecektir
                //ama dizilerde böyle bir durum yok
             
                //addAnimal(livinglist);//dikkat ? extends wildcardı
                //yerine ? super olsa bu kod çalışacaktır fakat bu sefer de
                //dogList çalışmayacaktır. Çünkü Super üst sınıflara izin verirken
                //extends ise altı sınıflara izin verir.
             
             
}

public static void arrayRules(Animal[] animal) {
System.out.println("test");
}
     
        public static void addAnimal(List<? extends Animal> animalList) {
            //burada ise sadece null ekleyebiliriz
            animalList.add(null);
            //? extends kaldırdığımız zaman
            //addAnimal(new Dog()); gibi bir tanımla yapılabilir
}
}

Set && Map

      S.a. Arkadaşlar,
      Bugünkü konumuzda yine koleksiyonlardan devam edeceğiz , fakat bu sefer farklı bir yazıyla devam edeceğiz. Bu sefer de set ve map sınıflarını inceleyeceğiz. Öncelikle Set sınıfımızla başlayalım. Set sınıfımızda hashSet,linkedHashSet ve treeSet lerden bahsedeceğiz. Genel olarak arrayListlerle aynı olsa da bazı yönleriyle farklıdır gösterirler. Mesela aynı 2 eleman eklenemez. Derleyici hata vermez, fakat hafızasına bir adetini alır. treeSette order ve sorted iken diğerleri bu iki özelliği aynı anda taşımaz. Daha önce de zaman zaman açıkladık ordered ve sorted konusunu yine kısaca söylemek gerekirse bir tür sıralamadır int ve String arasında. Bu nedenle TreeSetlerde farklı tipler kullanılamaz. Çünkü String ile int karşılaştıramaz, ama diğer ikisinde ise jenerik ile kısıtlama yapılmadığı sürece kısıtlama yapılabilir. Örnekle söyleyecek olursak

public class TreeSetTest {
    public static void main(String[] args) {
LinkedHashSet<Number> linkedHashSet = new LinkedHashSet <Number>();
           
linkedHashSet.add(2);//normalde aynı elemanı 2 defa bulundurmaz
linkedHashSet.add(2L);//fakat bu değişkenlerin her biri farklı tiptedir
linkedHashSet.add((short)2);
        for(Number aaa: linkedHashSet) System.out.println(" " + aaa);
             
Set treeSet = new TreeSet();
        Set<Number> ts1= new TreeSet<Number>() ;
//treeSet.add((short)10);//türü short olduğundan yine hata
treeSet.add(20);
//treeSet.add("ClassCastException");
        for(Object aa: treeSet) System.out.println(" " + aa);
}
}

      Kısaca Setler böyle , ArrayListle benzerlikleri çok fazla, o yüzden önemli gördüğümüz bir kaç noktayı belirtmiş olduk. Şimdi de maplara geçiyoruz. Map kısmını da 4 başlık altında inceleyeceğiz. Bu üç başlığa geçmeden önce maplerin genel özelliklerinden biraz bahsedelim. 2 kısımdan oluşurlar. 1.si key 2.si value kısmıdır. 1.kısım primer key gibidir. Yani değerleri farklı olmak zorundadır, fakat value değeri birden farklı değerler alabilirler. Eğer key kısmında birden fazla aynı değer varsa en altta olan değer geçerli sayılacaktır. Bunun sebebi override etmesidir. Şimdi de bahsettiğimiz 4 kısmına geçelim. Onlardan da kısaca bahsedip daha sonra da kodla açıklamaya çalışalım.

HashMap: Unordered ve Unsorted. null değerler alabilir. Farklı değişkenler alabilir
Hashtable: null değerler alamaz.
LinkedHashMap:. Null değer alabilir.
TreeMap: Sıralıdır ve ordered. Bu yüzden aynı tip değişken alır

    Burada HashMap ve Hashtable HashSet ile benzerlik özellikler gösterse de LinkedHashMap burada biraz daha farklı , bu yüzden biz de ağırlığımızı LinkedHashMap üzerine vermeyi düşünüyoruz.

    public static void main(String[] args) {
TreeMap<Integer, String> treeMap = new TreeMap<Integer, String>();

treeMap.put(1, "one");
treeMap.put(2, "two");
treeMap.put(30, "thirty");
treeMap.put(40, "forty");
treeMap.put(50, "fifty");
treeMap.put(70, "seventy");
treeMap.put(100, "hundred");

// ceilingEntry(key) 41den büyük en küçük sayı döndürür
        //40 yazsak 40 key/value kısmını seçecekti
Entry<Integer, String> ceilingEntry = treeMap.ceilingEntry(40);
Integer ceilingEntryKey = ceilingEntry.getKey();
String ceilingEntryValue = ceilingEntry.getValue();
System.out.println("ceilingEntryKey: " + ceilingEntryKey);
System.out.println("ceilingEntryValue: " + ceilingEntryValue);

// higherEntry(key)  40den küçük en büyük key/value döndürür
        //40 olsa dahi 40ı almaz, dikkat !!
Entry<Integer, String> higherEntry = treeMap.higherEntry(40);
Integer higherEntryKey = higherEntry.getKey();
String higherEntryValue = higherEntry.getValue();
System.out.println("higherEntryKey: " + higherEntryKey);
System.out.println("higherEntryKey: " + higherEntryValue);

// floorEntry(key)  kendisinden küçük en büyük sayıyı döndürür
        //aynı değer varsa onu seçer
Entry<Integer, String> floorEntry = treeMap.floorEntry(30);
Integer floorEntryKey = floorEntry.getKey();
String floorEntryValue = floorEntry.getValue();
System.out.println("floorEntryKey: " + floorEntryKey);
System.out.println("floorEntryValue: " + floorEntryValue);

        // floorEntry(key)  kendisinden küçük en büyük sayıyı döndürür
        //aynı değer varsa onu seçmez
Entry<Integer, String> lowerEntry = treeMap.lowerEntry(30);
Integer lowerEntryKey = lowerEntry.getKey();
String lowerEntryValue = lowerEntry.getValue();
System.out.println("lowerEntryKey: " + lowerEntryKey);
System.out.println("lowerEntryValue: " + lowerEntryValue);

        //ilk değeri döndürür
        Entry<Integer, String> firstEntry = treeMap.firstEntry();
Integer firstKey = treeMap.firstKey();
        System.out.println("ilk Deger:" + firstKey);
             
        //son değeri döndürrü
Entry<Integer, String> lastEntry = treeMap.lastEntry();
Integer lastKey = treeMap.lastKey();
        System.out.println("Son Deger:" + lastKey);
             
        //ilk değeri döndürür ve siler
        Entry<Integer, String> pollFirstEntry = treeMap.pollFirstEntry();
        //son değeri döndürür ve siler
        Entry<Integer, String> pollLastEntry = treeMap.pollLastEntry();
             
        //Mapin son hali. ilk ve son elemanları silinmiş!!
        for(Object key: treeMap.keySet()) System.out.println(key);
       }

    Burada TreeMapin bazı metodlarına baktık , unutmayın bu metodları TreeSet ile de kullanabiliriz. Örnekleri çoğaltıp sizler de kafanıza takılan yerleri cevaplandırabilirsiniz. İyi çalışmalar Kolay gelsin

Comparable & Comparator ile Sıralama

       S.a. Arkadaşlar,
       Bugünkü konumuz ArrayListelerde sıralama olacak, fakat bu sıralamalarımız basit manada String veya int sıralamak değil de , bir önceki yazımızda bahsettiğimiz objeler arasında sıralama olacaktır. Ne demek istiyoruz peki , elimizde bir tip değişken var. Örneğin int[] dizi={1,4,2,3}; gibi bir dizi olsun elimizde bunu nasıl sıralıyorduk Arrays.sort(dizi) yazıyorduk ve sıralama yapıyorduk. ArrayListlerde de buna benzer bir olay var. Orda Collection.sort() diye sıralama yapıyoruz, fakat bazen karşımıza bir sınıf geldiğini ve bunun birden fazla değişkeni olduğunu düşünelim hangisine göre sıralama yapacağı ise muallakta kalacağı için işte tam bu noktada comporable ve comparator devreye girer. Şimdi kodumuz üzerinden gidelim. Umarım bu sayede daha iyi pekişecektir söylemeye çalıştıklarımız.

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

class Car implements Comparable <Car>{
        //<Car> enerjik ile sınırlama getiriyor
        //Sınırlama koymak istemezsek comporTo metodunda 
        //değişiklik yapmak zorundayız.Car yerine Object tanımlanmalı
public Car(String marka, Integer fiyat) {
super();
this.marka = marka;
this.fiyat = fiyat;
}

String marka;
Integer fiyat;

@Override
public int compareTo(Car car) {
return fiyat.compareTo(car.fiyat);
                //eğer ters sıralama yapmak istersek
                //car.fiyat.compareTo(fiyat);
                //markaya göre sıralama yapmak içinse
                //return marka.compareTo(car.marka);
}
               //burada compareTo ile neye göre sıralama
               //yapmak istediğimizi override etmezsek hata alırız

@Override
public String toString() {
return "Car [ marka=" + marka + ", fiyat=" + fiyat + "]";
}

}

public class ComparableTest {

public static void main(String[] args) {
Car ford = new Car("ford", 100);
Car fiat = new Car( "fiat", 50);
Car subaru = new Car("subaru", 5000);
Car bmw = new Car("bmw", 1000);


List <Car> carList = new ArrayList <Car>();
carList.add(ford);
carList.add(fiat);
carList.add(subaru);
carList.add(bmw);
                carList.add(new Car("mercedes",250));//böyle de yapılabilir


for (Car c : carList) {
System.out.println(c);
}
System.out.println();

Collections.sort(carList);

System.out.println("Comparable Sorting");
for (Car c : carList) {
System.out.println(c);
}

}
}
       
    Yukarıda Comparable yapısını anlatmaya çalıştık Gerekli yerlerde yorum satırlarıyla kodlarımızı destekledik. Umarız anlamanıza yardımcı olmuştur. Şimdi de Comparator yapısına geçelim. Bunun için yine kodumuzu yazıp içerisini yorum satırlarıyla desteklemeye çalışacağız.


import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

class Car {

public Car() {
            //hatırlarsanız eğer herhangi bir constructor
            //tanımlamazsak otomatik oluşuyordu .
}

public Car(String marka, Integer fiyat) {
            super();
            this.marka = marka;
            this.fiyat = fiyat;
}

String marka;
Integer fiyat;

@Override
public String toString() {
            return "Car ["+ " marka=" + marka + ", fiyat=" + fiyat + "]";
}
}

public class ComparatorTest implements Comparator<Car> {
// Doğal sıralama için  Comparable , bundan farklı
        //bir sıralama içinse comparator kullanılır
public static void main(String[] args) {
            Car ford = new Car("ford", 100);
            Car fiat = new Car( "fiat", 50);
            Car subaru = new Car("subaru", 5000);
            Car bmw = new Car("bmw", 1000);

            List<Car> carList = new ArrayList <Car>();
            carList.add(ford);
            carList.add(fiat);
            carList.add(subaru);
            carList.add(bmw);

            for (Car c : carList) {
System.out.println(c);
            }
            System.out.println();

            ComparatorTest comparatorTest = new ComparatorTest();
            // overloaded sort metodunu kullanabiliriz.
            // burada 1.arguman siralamak istedigimiz List
            // 2.arguman ise Comparator arabirimini uygulayan sinifimiz olacaktir.
            Collections.sort(carList, comparatorTest);
            //Arrays.sort metodu da gerekli kodlamalarla kullanılabilir

            System.out.println("Comparator Sorting");
            for (Car c : carList) {
System.out.println(c);
            }
}

// Comparator -> compare metodunu override etmemiz gerekir
// Comparable -> compareTo metoduydu.
@Override
public int compare(Car car1, Car car2) {
            return car2.fiyat.compareTo(car1.fiyat);
           //tersten sıralamak için car1 ile car2 yer değiştirilmeli
}

}

ArrayList

       S.a. Arkadaşlar,
       Bugünkü konumuz ArrayList olacak. Dizileri hepimiz biliyoruzdur. Dizilerde ne yapıyorduk eleman tutuyorduk,siliyorduk vs fakat burada bir diziye tek bir tip değişken atayabiliyorduk. Mesela int[] a= new int[size]; diyorduk ve sadece intenger tanımlayabiliyorduk. Fakat arraylistlerde farklı tipleri tanımlama olanağı sağlar fakat siz bunu istemezseniz jenerikler ile de kısıtlama yapabiliyorsunuz. Jenerik konusunu ileri ki konularda anlatacağız inşallah, fakat bir nevi tip kısıtlaması dersek şuan için bize yeterli olacağını düşünüyorum. Ayrıca arraylistler dinamik yapılardır. Eleman ekledikçe genişleyen sildikçe küçülen yapılardır. Dizilerde sabit bir boyut veriyorduk bildiğiniz gibi ve bundan fazla eleman ekleme şansımız olmuyordu. Daha az eleman eklediğimizde ise boşuna bellekte yer tutmuş oluyoruz. ArrayListlerin böyle bir avantajı da var. Son olarak eleman silme gibi işlemler veya araya eleman ekleme gibi konularında diziler için ekstra kod yazmanız gerekirken ArrayListler bunu kendisi hallediyor ve size bir zorluk çıkarmıyor. Sayılar ve String için sıralama yapabiliyor, fakat farklı objeler için sıralama yapamıyor. Mesela bir Car sınıfımız var , onun için farklı yöntemler var onları da ileride nasip olursa anlatırız. Şimdilik teknik olarak söyleyeceklerimiz bunlar. Kodlar içerisinde eksik gördüğümüz yerleri yine anlatmaya çalışacağız. Şimdi yavaştan kod kısmına geçelim.

public static void main(String[] args) {
ArrayList myArrayList = new ArrayList();
// ArrayList'e elemani add metodu ile ekleyebiliriz.
myArrayList.add(10);
myArrayList.add((short)20);
myArrayList.add("test");
        myArrayList.add(true);
        myArrayList.add(new Test());//paketismi+sıfınismi+@id
myArrayList.set(2, "new set text");//set ile indexteki elemani override
myArrayList.add(1, '#');//overload ile yeni eleman ekleyebiliriz
       //set ile farkı elemanı üzerine yazılmaz, elemanı aşağı kaydırır.
for (Object obje: myArrayList) {
System.out.println(obje);
}
             
        boolean isEmpty = myArrayList.isEmpty();//ArrayList Boş mu,boşsa true
int size = myArrayList.size(); // kaç elemanlı
        System.out.println(isEmpty + " Eleman Sayısı: " + size);
             
        boolean b= myArrayList.contains(20);//burada int olduğu için false
        boolean b2= myArrayList.contains((short)20); //short olduğundan true
        boolean b3= myArrayList.contains("10"); //yukarıda int burada String!
        System.out.println(b+ " " + b2+ " " + b3);
             
       int indexOf = myArrayList.indexOf(10); //indexini atar
       int indexOf2 = myArrayList.indexOf(20); //int olduğundan -1 döndürür
       int indexOf3 = myArrayList.indexOf((short)20);
       System.out.println(indexOf + " " + indexOf2 + " " + indexOf3);
             
      myArrayList.remove(0); //index siler
      System.out.println("0.eleman Silindikten Sonra:" + myArrayList.size());
      myArrayList.clear(); //tüm arraylisti siler
     System.out.println("Dizi tamamen silinince" + myArrayList.size());
     //şimdi diziyi tekrar yazdıralım,görüldüğü üzere birşey yazmaz
     for (Object obje: myArrayList) {
     System.out.println(obje);
      }
}

      Peki biz array ile arrayList arasında herhangi bir dönüşüm yapabilir miyiz diye bir soru sorarsak onun da cevabı evet olacak. Her iki dönüşüme de izin veriyor. Bunun için birden fazla yol olabilir fakat biz kendiliğinden gelen toArray ve asListleri kullanacağız. Bu iki yöntem arasında farklar vardır. Bunları burada söylemektense kod içerisinde uygularken yorum satırlarıyla desteklemeyi tercih edelim.

public static void main(String[] args) {
     String[] namesArray = { "names1", "names2", "names3", "names4" };
      List namesList = Arrays.asList(namesArray);
      // Arrays -> List dönüşümü yapıyoruz

for (String str : namesArray) {
System.out.print(str + " ");
}
             
// List'teki elemani guncellersek otomatik olarak
                //dizi arraydeki eleman da guncellenecektir.
                //fakat toArray ile güncellenme olmayacaktır
namesList.set(0, "set new names1");
             
                System.out.println("");
for (String str : namesArray) {
System.out.print(str + " ");
}
// namesList.add("java.lang.UnsupportedOperationException");
                //bu şekilde eleman eklemeyiz fakat to Array bu böyle değildir
             
}

NOT: adList ile toArray görev olarak aynı olsa dahi özellik olarak birbirlerinin tersi gibidirler. Kodun içinde gerekli açıklamaları yapmaya özen gösterdik. Yazımızı burada son veriyor , iyi çalışmalar diliyoruz.

Enum

        S.a. Arkadaşlar,
        Bugünkü yazımız enumlar olacak , belki daha önce anlatmam gereken veya yer yer bahsettiğim bir konu olduğu halde , tekrardan hem bir başlık altında toplamak hem de atladığım, gözden kaçırdığım yer olursa onları da almak adına enumlar adında bir yazı yazalım dedik. Peki nedir enumlar ? Sabitlerin değerleri temsil ederler. Fakat bunu yaparken daha derli toplu, anlaşılır bir halde yaparlar. Bu nedenle bu yapıyı kullanırız. Java'ya da 1.5 sürümüyle eklenmiştir, daha öncesinde dediğimiz gibi sabitler (constant) kullanılırdı. Kısaca bir örnek yapacak olursak;
public class TrafikLambasi {
  public static final int GREEN = 1;
  public static final int YELLOW = 0;
  public static final int RED = -1;
}

yerine kısaca

 enum TrafficLight {
  GREEN(1),YELLOW(0), RED(-1);
   TrafficLight(int value) { //int yerine farklı değişkenler tanımlanabilir. 
                                       //GREEN(değişken türüne değer atanır)
    }
yazabiliriz. Şuan durum o kadar da karışık değil çünkü sadece 3 değişkenimiz var. Mesela bu aylar gibi 12 değişken veya farklı yapıda belki yüzlerce değişken kullanacağımız bir proje olsa, ne demek istediğimiz daha iyi anlaşılırdı. Böylece enumla bu karışıklığın önüne geçiyoruz. Şimdi de aşağıda yazdığımız kodda enumlarla ilgili temel şeyler yazmaya çalıştık. Kafanıza takılan şeyleri siz de kodun  üzerinde farklı işlemler yaparak aklınızdaki soruları gidermeye çalışın , böylece daha iyi oturtacağınıza inanıyoruz.

enum Outer { //enum dışarıda tanımladığında sadece default ve public alabilir
     //implements alabilir interfacelerden fakat extends ile kalıtım yapamaz
SHORT, NORMAL, TALL;
         Outer(){
          //class ve abstract sınıflar gibi constructor tanımlanailir
          // ama hatırlarsanız interfacelerde constuctor tanımlayamıyorduk  
        }
}; //noktalı virgül zorunlu değil

class JavaCoffee {
    protected enum Inner{ //içeride tanımlanırsa private ve protected de alabilir
        SHORT1,NORMAL1,TALL1;
            static enum InnerEnumClass{
                //iç içe enum tanımlanailir, static de olabilir
            }
        Inner() {
          //constructora public gelemez. Nedeni enum protected olmasıdır.
          //ya aynısı ya da daha gizlisi olmalıdır !! bunu da tekrar hatırlattık  
        }
         
}; // noktalı virgül zorunlu değil
Outer size;
        Inner size1;
 
    static void metod(){
       //enum InMetod{} , metodlar içinde tanımlanamazlar
     
    }

}

public class JavaCoffeeTest {
public static void main(String[] args) {
JavaCoffee coffee = new JavaCoffee();
             
                //Outer outer = new Outer(); yeni obje oluşturulmaz
             
                //enum sınıf dışında tanımlanırken
coffee.size = Outer.NORMAL;
System.out.println(coffee.size);
                //senum sınıf içinde tanımlanırken
                coffee.size1 = JavaCoffee.Inner.TALL1;
                System.out.println(coffee.size1);
             
}
}

Tokenizing & Formating

      Bugünkü konumuzda tokenizing ve formating konusunu işleyeceğiz. Bir önceki konuda regex konusu ile birbirinden yakındır fakat mantık regex bulma işlemi yaparken burada büyük parçalardan küçük parçalara veya başka bir ifadeyle istenilen formata çevirme yöntemi vardır. Şimdi örneğimize geçersek ne demek istediğimizi daha iyi anlarız

public class StringSplitTest {
    public static void main(String[] args) {
        String content = "name1,name2,name3,name4";

        String[] names = content.split(",");
        for (String s : names) {
            System.out.println(s);
        }
        //burada virgüle göre parçalama yapıyoruz

        content = "name1,name2:name3:name4.name5@name6";
        System.out.println("virgul - iki nokta-nokta- @");
        names = content.split(",|:|\\.|@");
        // onceki yazida isledigimiz gibi ,birden fazla bölme parametresi de kullanabiliriz
        // benzer sekilde noktayi kullanmak icin kacis karakteriyle kullanılmalıdır. \\.
        for (String s : names) {
            System.out.println(s);
            }
         }
      }

     Gördüğünüz gibi buradaki bir bütün olan metni kelimeler ayırdık. Bu ayırma işlemi boşluklara göre de
olabilirdi. Her boşlukta kelimeyi hafızaya alıp yazdırabilirdik veya satır satır alma işlemi de olaiblirdi.
Satır sonuna gelindiğinde satırı hafızaya da alabilirdi. Bu tip örnekler çoğaltılabilir tabii ki de ..

      Aşağıdaki kodda ise tokenizin işlemi ile searching işleminin arasındaki farkı daha iyi anlaycağınızı umuyorum.

 public static void main(String[] args) { Pattern p = Pattern.compile("\\s");//boşluk String content = "merhaba java!"; System.out.println("Searching Test"); Matcher m = p.matcher(content); while (m.find()) { System.out.print(m.start() + " "); // Searching islemi ilgili regexi bulma islemidir. } System.out.println(); String[] tokens = content.split("\\s"); System.out.println("Tokenizing Test"); for (String token : tokens) { System.out.println(token); // Split/tokenizing ise regexe göre parçalama işlemidir } } }

Şimdi de formating konusunda bakalım. Formating C'den yabancı olmadığımız bir konu. Aynı şey java için de 
geçerlidir. b boolean , c char, d integer, f floating point, s string kullanılır. Birazdan örneklerde göreceğimiz 
şekilde bu tanımlamalar böyle yapılır. Şimdi örnek kodumuza geçelim.

public static void main(String[] args) {

System.out.printf("%d", 10);
System.out.println();
  System.out.format("%d", 10);//format metonu da kullanabiliriz
  System.out.println();

//System.out.printf("%f",10);
// java.util.IllegalFormatConversionException hatasi verecektir.
// %f kayan noktali sayilar/kusuratli sayilar icindir.


System.out.printf("%2$d %1$d  %3$f", 123, 456, 10.4);
// index$ ifadesi ile arguman olarak verilen ddeğerleri düzenleyebiliriz.
System.out.println();//456 123 10.4

System.out.printf("%05d", 123);
// 0 , metoda sayimizin hanesini belirtir
                // sayımız 5 haneden büyükse her hangi bir değişiklik yapmaz
System.out.println();

System.out.printf("%+d %+d", 123, -123);
// Varsayilan olarak pozitif sayilarda + isareti eklenmez. + karakterini
// ekleyip formatlayabiliriz.
System.out.println();

System.out.printf("%(d %(d", 123, -123);
// ( parantez isareti negatif sayilari parantez icerisine alir.
// negatif sayiyiyi pozitif olarak formatlar , mutlak degerini alir.
System.out.println();

System.out.printf(">%d< \n", 123);
System.out.printf(">%7d< \n", 123);
System.out.printf(">%-7d< \n", 123);
// - karakteri formatlamayi sola dayali yapar.
}