Serialization/Serileştirme

                Bugünkü konumuz serizilation yani serileştirme olacak. Peki nedir serileştirme diye kısaca söyleyecek olursak bir andaki durumu kaydetme , daha sonra da kayıtlı olan durumu çekme işlemine diyoruz. Serileştirme özellikle network ve persistance işlemlerinde sıkça kullanılır. Serileştirmeyi kullanabilmemiz için implements Serializable . yazmamız gerek. Buradan anlayacağımıza göre serileştirme interface/ara birimdir. Şimdi konuyu daha iyi anlayabilmek için kod üzerinden devam edelim.

class Dog implements Serializable {

                String name = "Karabas";

}

public class SerializeDog {

public static void main(String[] args)

 throws IOException, ClassNotFoundException {

    Dog dog = new Dog();//dog objesi oluşturuyoruz

    FileOutputStream fos = new FileOutputStream("dog.serial");

    //dog.serial diye kaydediyoruz,farklı bir şey de olabilir

    ObjectOutputStream oos = new ObjectOutputStream(fos);

    oos.writeObject(dog);//oluşturduğumuz objeyi kaydediyoruz

    oos.flush();//bufferden bağımsız kaydeder

    oos.close();//açık olanı kapatmak zorundayız

                              

    FileInputStream fis = new FileInputStream("dog.serial");

    //şimdi okuma işlemini yapıyoruz

    ObjectInputStream ois = new ObjectInputStream(fis);                         

    Dog deserializedDog = (Dog)ois.readObject();

    //veri kaybı olmaması için cast yapıyoruz

    System.out.println(deserializedDog.name);//ekrana yaz

    ois.close();//açılan dosyayı kapat

                              

                }

}

Peki tüm değişkenleri serileştirmek zorunda mıyız diye bir soru akla gelebilir. Tam da bu nokta transient keywordu karşımıza çıkar. Serileştirmek istemediğimiz değişkenin başına yazıyoruz. Mesela yukarıdaki örneğimizde eğer transient String … yapsaydık çıktımız null olacaktı. Şimdi de son bir örnek verip , o örnekler üzerinde farklı işlemler yaparak nasıl farklı çıktıları aldığımızı incelemeye çalışacağız. Bu açıdan konunun daha iyi pekişeceğini inanıyorum. Çünkü neden bu böyle olmuş , böyle olursa ne olur gibi sorularının cevabını da bulmuş olacağımıza inanıyorum. Şimdi kodumuzu yazalım

class Animal { //serileştirme işlemi yapılsa çıktı değişir

int height = 30;

        //String name="akbas";*

}

public class Dog extends Animal implements Serializable {

String name;//* bu kodu silmezsek yukarıdaki name değişkeni pasif kalır

public Dog(int height, String name) {

this.height = height;// bu satırları silerken 

this.name = name; // çıktımız 30 akbas olur !!

}

public static void main(String[] args) throws IOException, ClassNotFoundException {

    FileOutputStream fos = new FileOutputStream("dog.ser");

    ObjectOutputStream oos = new ObjectOutputStream(fos);

    Dog dog = new Dog(50, "karabas");

    System.out.println(dog.height + " " + dog.name);

    oos.writeObject(dog);

    oos.close();

    FileInputStream fis = new FileInputStream("dog.ser");

    ObjectInputStream ois = new ObjectInputStream(fis);

    Dog deserializedDog = (Dog) ois.readObject();

    System.out.println(deserializedDog.height + " " + deserializedDog.name);

    ois.close();

}

}

  Çıktı:

50 karabas

30 karabas

    Burada çıktımız yukarıdaki gibi oldu. Fakat niye böyle oldusunu irdeleyelim isterseniz. Çünkü deserializetion işlemi sırasında yapılandırıcılar ve değişkenlere değer atanamıyor. Bu nedenle çıktımız böyle oldu. Dikkat edin Animal sınıfımıza serileştirme işlemi yapılmamış , eğer ona da serileştirme işlemi yaparsak bu sefer çıktımız değişecektir. Farklı satırlara bazı bilgiler ekledik. Sizler de aklınıza takılan soruları kodu değiştirerek daha iyi anlayabilirsiniz. Kolay gelsin

Kaynak

http://www.injavawetrust.com/pure-java-60-file-and-io-05-serialization/

Dosyalarda Giriş Çıkış İşlemleri

      Bugünkü konumuzda I/O işlemlerini anlatmaya çalışacağız. Bunun için farklı sınıflar metodlar kullanılmaktadır. Biz de bunlardan bir kaç tanesini ele almaya düşünüyoruz. Şimdi yavaştan başlayalım. Öncelikle dosya işlemini ele alalım. Burada dosya içeriği oluşturulmaz sadece dosya yoksa oluşturulur varsa herhangi bir işlem yapılmaz. Şimdi örneklersek daha iyi anlayacağımızı düşünüyorum

public class FileTest {

public static void main(String[] args) throws IOException {
File file = new File("test.txt");// burada sadece obje oluşturulur
System.out.println(file.exists()); // dosya var mi ?
System.out.println(file.createNewFile()); // doya yoksa oluşturulur
System.out.println(file.exists()); // tekrar kontrol et !

}
}

   Bu kodu ilk çalıştırdığımızda kodumuz
false
true
true
   2.defa çalıştırığımızda ise
true
false
true

döndürecektir. Bunun nedeni ise ilk çalıştırdığımızda test diye bir dosya yoktur. file.createNewFile ile oluşturulur. Daha sonra tekrar kontrol ettiğimzide artık böyle bir dosya mevcut elimizde ve true dönüyor. 2.sefer çalıştırıdığımızda ise bu sefer dosya olduğu için true döndürür ve yeni dosya oluşturulmadığı için creanteNewFile false değer döndürür.

      Şimdi de File ile ilgili daha farklı özelliklere göz atalım. Şimdi de dizin oluşturma ve oluşturduğumuz dizi içerisine dosya oluşturma işlemine göz atalım.

public static void main(String[] args) throws IOException {
File mydir = new File("mydirectory");
mydir.mkdir();  // dizin olusturma islemi atlandi.
        //eğer yukarıdaki dizi oluşturmadan txt oluşturmaya kalkışırsak hata verir
File file = new File(mydir, "test.txt");//oluşan dizi içine txt oluşur
file.createNewFile();

}

Şimdi de silme işlemine göz atalım. Ama unutmamız gereken bir şey var ki o da  dizin altında herhangi bir klasör varsa dosya silme işlemini gerçekleştirmez. Onun için öncelikle dosyaları daha sonra boş olan klasörleri silebiliriz. Buraya dikkat etmemiz gerekir. Şimdi de yukarıdaki koda ek olarak aşağıdaki kodu veriyoruz.

// dizin bos olmadiginda silme islemi yapilamaz.
// false deger donecektir
System.out.println(mydir.delete());

// dosya silinir , true deger donecektir
System.out.println(file.delete());

// dizin icerisindeki dosyayi sildikten sonra tekrar deneyelim.
System.out.println(mydir.delete()); //ve artık silme işlemi tamamlanır

Bunun gibi daha farklı işlemler bulunmaktadır. İsim değiştirme listeleme gibi işlemler bulunur. Bunlara da göz atılabilir. Biz şimdilik bunlara girmiyoruz. Son olarak da dosyaya yazma ve okuma ile yazıyı bitiriyoruz

public static void main(String[] args) throws IOException {

    File file = new File("file.txt");

    FileWriter fw = new FileWriter(file);
    fw.write("java");
    fw.write(" 6");
    // write metodu ile String veya char array yazabiliriz. 
    // int alan   yapilandiricisi ilgili sayinin unicode degeridir.
    fw.flush(); // Verinin bufferdan bağımsız diske hemen yazılmasını sağlar
    fw.close(); // IO islemlerinde , DB baglanma islemlerinde close metodu
    // cagrilmalidir. Bu baglantinin kapatilmasi anlamina gelmektedir.
    // Acik baglanti birakmamak icin close metodunu cagirmayi unutmayalim !

    char[] input = new char[50];
    int size = 0;
    FileReader fr = new FileReader(file); // FileReader objesi olusturduk
    size = fr.read(input); // dosya icerigini oku
    System.out.println("size:" + size); // kac byte okundu ?

    for (char c : input) {
    System.out.print(c);
         }
    fr.close();
    }
}

String , StringBuffer&Builder

Bugünkü konumuzda Stringleri anlatmaya çalışacağız. Stringler nedir ? Kullanımları nasıldır ? Ne gibi özelliklere sahiptir ? gibi soruların cevabını arayacağız. Öncelikle immutable /değişmezlik nedir ona bakalım. Stringlerde obje değişmez , onun yerine yeni bir obje oluştururu. Örn String x="a"; olsun. x üzerinde herhangi bir değişiklik yaptığımız zaman x.metod(); burada x değişmez , yeni bir nesne daha oluşur. İşte bu özelliğe immutable diyoruz. Belki kodla daha iyi anlayabilir.

public static void main(String[] args) {

String s1 = "spring ";
// 1)"spring" degerine sahip bir String objesi olusur.

String s2 = s1 + "summer "; //spring summer
// 2)"summer" objesi olusur
// 3)"spring summer" objesi olusur
// s2 referansına "spring summer" objesine referansta bulunur

s1.concat("fall "); //spring full , fakat s1 hala spring !!
//4) "fall" degerine sahip String objesi olusur.
//5) "spring fall" degerine sahip String objesi olusur.
               // s1 in referans gosterdigi obje degismez !

s2.concat(s1); //spring summer spring (s1 hala spring demiştik)
                                //aynı nedenle s2 de hala spring summer
//6) "spring summer spring" objesi olusur.

s1 += "winter "; //şimdi artık spring winter oldu
//7) "winter" degerine sahip obje olusur.
//8)"spring winter" degerine sahip obje olusur.

System.out.println(s1 + " " + s2);
                //spring winter spring summer 

}
Şimdi de sık kullandığımız bazı metodlara bakalım.

length(): bildiğimiz üzere uzuluğu hesaplayan fonksiyondur. int döndürür.
public static void main(String[] args) {
String name = "xyz";
int len = name.length();
System.out.println("karakter sayisi:" + len);
}

isEmpty():stringin boyutu 0 ise true , değilse false değer döndürür.
public static void main(String[] args) {
String str = "";//str="xyz" olsa false değer döndürecekti
                                     //null olsa hata fırlatır
boolean isEmptyString = str.isEmpty();
System.out.println(isEmptyString);
}

charAt():Stringdeki karekteri almamızı sağlıyor
public static void main(String[] args) {
String name = "xyz";
char c = name.charAt(2);
System.out.println(c); //y
                // tanımlanmayan değişken olduğunda exception fırlatır
}

getChars(int baslangic, int end, char dst[], int hedefBaslangic):Stringdeki belirli bir yer almayı sağlar. parametrelerde isimlerini belirttik şimdi bir örnekle daha iyi pekiştirelim. Bu arada dizilerin ilk indexinin sıfır olduğunu unutmayalım.

public static void main(String args[]) {

String str = new String("abcdefgh");
char[] charArray = new char[4];
str.getChars(2, 6, charArray,0);
System.out.println(charArray);//cdef

}

compareTo&compareToIgnoreCase: Karşılaştırma yapar. Aradaki fark kadar int değer döndürür. CompareTo küçük büyük harf hassasiyeti varken , comporeToIgnoreCase ise bu yoktur. Örneklerde ne demek istediğimizi daha iyi anlayacaksınız

public static void main(String[] args) {
 
    System.out.println("a".compareTo("d"));
    System.out.println("b".compareTo("d"));
    System.out.println("e".compareTo("a"));
    System.out.println("ABa".compareTo("ABc"));
    //AB aynı olduğu için a ile c karşılaştırır
    System.out.println("a".compareToIgnoreCase("A"));
     //küçük büyük harf hassasiyeti yoktur.//0
    System.out.println("a".compareTo("A"));
 
    }

Şimdi de StringBuffer ve StringBuilder yapılarını inceleyelim. Nedir peki bu iki yapı. Yukarıda belirttiğimiz gibi String imuutable'di yani değişmez. Bir obje değiştiğinde bir asıl obje bir de referans obje oluşuyordu. Bu memory yoruyor. Bu nedenle bu yapılar ortaya çıkmıştır. Ne dediğimizi kod üzerinde daha iyi anlayacağınızı umuyorum

public static void main(String[] args) {
 
    StringBuffer sb = new StringBuffer("abc");
    sb.append("def");
    System.out.println("sb = " + sb);  //abcdef
    //eğer yapımız sb değil de String olsaydı çıktımız abc olacaktı
    }

Şimdi de her iki tarafta kullanılan bazı metodlara bakalım.
append():ekleme işini yapar. Aşağıdaki örnekte

public static void main(String[] args) {
StringBuffer sb = new StringBuffer("yaşamak");
sb.append(" güzel ");
sb.append(2015);
                //sb="bu atanma tipi yanlış.DİKKAT!!"

System.out.println(sb);
}
delete():belirtilen indexler arası silme işlemi yapar.
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("0123456789");
sb.delete(4, 6);
// index 0 dan baslayacaktir!
// [start-end)
System.out.println(sb);
}

insert(); append'den farklı olarak istenilen yere ekleme yapar.
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("0123456789");
sb.insert(4, "----"); // 4.indexten sonra ekleme yapar
System.out.println(sb);

}

toString(): String Buffer ve String Builder objelerini objeye çevirir.
public static void main(String[] args) {
StringBuffer sb = new StringBuffer("test string");
                String deneme=sb.toString();
                deneme+="boyle ekleyebiliriz artk";
                System.out.println(deneme);
                 
}

Kaynakça
http://www.injavawetrust.com/pure-java-53-string-01/
http://www.injavawetrust.com/pure-java-54-string-methods/
http://www.injavawetrust.com/pure-java-55-stringbuffer-and-stringbuilder/

Try Catch

     Bugün de try-catch kullanımını ve bazı ince noktalarını ele almaya çalışacağız. Öncelikle try catch nedir onu inceleyelim. Beklenmeyen anlarda ortaya çıkan hataları yakalayan ve hataların yerine neyin çalıştırılmasını sağlar. Şimdi yavaş yavaş kodlamaya başlayalım. Hem kodlarken söylediklerimizi daha iyi ifade edebiliriz.

public static void main(String[] args) {

try {
System.out.println("try 1");
throw new NullPointerException();//hata fırlatıyoruz
} catch (NullPointerException e) {
System.out.println("catch 1"); //hata olduğundan girer
} finally {
System.out.println("finally 1"); //her koşulda girer
}

try {
System.out.println("try 2");
} catch (NullPointerException e) {
System.out.println("catch 2"); // hata olmadığından çalışmaz
} finally {
System.out.println("finally 2"); // catchden bağımsız çalışır
}


try {
System.out.println("try 3");
System.out.println(10 / 0); //
} catch (NullPointerException e) {
                        System.out.println("catch 3");
                    //nullPointerException değil aritmetikException olmalıydı
                        //bu yüzden bu catch yakalanmaz
} finally {
System.out.println("finally 3"); // her şartta çalışır
}
}
Gerekli yorumları kod üzerinden vermeye çalıştık. Şimdi de dicked exception diye nitelendirilen tabire göz atalım. Dicked exception nedir, kısaca ona bir göz atalım daha sonra kod kısmında ne istediğimi daha iyi anlatmış olacağımızı umuyorum. Alt alta sıralanan metodlar olsun ve bu metotların belirli bir hiyerarşisi olsun. Bu hiyerarşi içerisinde yukarıdan aşağı hata fırlatmaya başlasın ve bu hata bir alta devreder. Eğer hatayı yakalayacak bir try catch yoksa bir diğerine devreder, en sonunda bu işlem tüm programı etkiler. Fakat aradaki metodlardan birini bunu engellerse hata tüm programı etkilemeyecektir. Ne demek istediğimi şimdi kod ile anlamaya çalışalım.

public class DuckedException {
public static void main(String[] args) {
doStuff();
System.out.println("Hata yakalandi, uygulama calismaya devam eder.");
               //try cath hiç kullanılmasaydı doğal olarak bu satır da gelmeyecekti
}

static void doStuff() {
try{ // eğer burada da try catch kullanılmamış olsaydık
                      //hatayı main içerisinde yakalamamız lazımdı
                      //main içerisinde yakalanmadığında programımız çökecekti
doMoreStuff();
}catch(Exception e) {
              //e.printStackTrace(); ile de hatanın türünü saptayabiliriz
}
}

static void doMoreStuff()   {
int x = 5 / 0; //burada herhangi bir try catch kullanılmadığından
                 //hata doStuff metoduna intikal eder.
  // ArithmeticException hatasi firlatilacaktir.
}
}

Biz bu yazıda genelde try catch ile hata yakalamayı gördük, fakat throws keywordi ile de hata fırlatabiliriz. try-catch ile hata fırlatmaya handle , throws ile hata ayıklamaya da declare denir. Bununla ilgili de bir örnek verecek olursak;

void throwMeAgain() throws IOException {
try {
throw new IOException();
} catch (IOException e) {
throw e;
}
}

                                                      Resim-1[1] Exceptionlar

Kaynakça
[1]https://gelecegiyazanlar.turkcell.com.tr/konu/android/egitim/android-101/trycatchfinally-yapisi
http://www.injavawetrust.com/pure-java-47-handling-exception-01/
http://www.injavawetrust.com/pure-java-48-handling-exception-02/

Döngüler

      Bugünkü anlatacağımız konu döngüler. Hepimizin bildiği bir konu  fakat biz burada gözden kaçan veya ince ayarları üzerinde durmaya çalışacağız daha çok. Bu nedenle fazla uzatmadan koda geçelim.

public static void main(String[] args) {
int x = 1;
if (x == 3) { //bu değeri sağlamaz , sağlasa diğer else/else if gitmez
}
else if (x < 4) { //bu koşul sağlar bu nedenle else/else if gitmez
System.out.println("<4");
}
else if (x < 2) { //koşul doğru ilk else if girdiği için çıktı vermez
System.out.println("<2");
}
   if (x < 5) { //if i her koşulda kontrol eder, doğru olduğu için girer
System.out.println("<5");
}
 else {      //hiç bir koşul sağlanmazsa gelir
                        System.out.println("x tüm bunlar dışında");
                }
  /*else if(x<6) {      elseden sonra else if gelmez,fakat if gelebilir
                        System.out.println("<6");
                }*/
}

 Kodu yorum satırlarıyla elimizden geldiğince açıklamaya çalıştık. Şimdi de switch case yapısına bakalım

public static void main(String[] args) {
int x = 1;
final int a=3;
                int b=2;
                long y=2;

switch (x) {
                        //x byte,int,short,byte ve Wrapperları olabilir !!
                        //x yerine y yazarsak hata verir. Long double float olmaz
case 1:
System.out.println("1 secenek aktif");
//break olmadığı için break görünceye akdar devam eder.
                 
case 2: //2 yerine b yazamayız, final tanımlanması olmalı
System.out.println("2 secenek aktif");
break;//break olmasa seçenek 3 de aktif olacaktı
                 
                default: // 1,2,3 dışındaki seçeneklerde aktif olur
                         //default en sonda olmak zorunda değildir
System.out.println(" default aktif");
                 
case a:
System.out.println("3 secenek aktif");
break;

}
}
Kodu yine yorum satırlarıyla açıklamaya çalıştık. Bir kaç ince noktaya da değinmeye çalıştık. Şimdi do while ile while döngülerine kısaca bakalım.

public static void main(String[] args) {
int x = 5;
do{
                    System.out.println("dongu icerisi");
                    //while döngüsü olsa buraya girmezdi
                    //fakat do while hatalı bile olsa bir kere çalışır
                    }
                while (x > 5) ;
System.out.println("dongu disi");

}
Şimdi ise eski ve yeni for döngüsüne bakalım ..

int a[] = { 1, 2, 3, 4 };
for (int x = 0; x < a.length; x++) {
    System.out.println(a[x]);
}

//yeni diye tabir ettiğim for döngüsü
for(int n:a){
    System.out.println(n);
}

2 for arasındaki farka bakalım biraz isterseniz. 1.döngü sayısını kesin olarak bildiğimiz yerlerde kullanabiliriz, 2.döngüyü ise daha çok array,koleksiyon işlemlerinde kullanıyoruz. İkisi de birbrinin işi yaptığı halde geliştirilmiş for bazen daha rahat olabilir fakat eski forun kendine göre önemli avantajları elbet vardır. Şimdi eski forun kullanımı ile ilgili bir kaç for döngüsü yazalım..

for(;;); bu kullanım doğrudur , for sonsuza kadar devam eder.
for(int i=0;i<3;System.out.print("aa"),i++);//çıktısı aa aa aa olur
int y,x;for(x=1,y=5; x>5; x++,y-- );
// 2seçenek hariç 1 ve 3 virgül ile farklı değişkenler kullanılabilir
for(int x=1,y=5; x>5,y<2; x++,y-- ); 
//burada hem int x hem y<2'den dolayı hata verir.

Son olarak geliştirilmiş for ile ilgili bir örnek verelim
class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}

public class TestAnimal {
public static void main(String[] args) {
Animal[] animalArray = { new Dog(), new Cat(), new Cat() };
Dog[] dogArray = { new Dog(), new Dog(), new Dog() };

for (Animal d : animalArray);
// for (Dog d2 : animalArray) ; ISA'ya uygun değil. ERROR
                for (Animal d1 : dogArray);
for (Dog d3 : dogArray) ;
}
}
Şimdi de break ve continue keywordlerine bakıp konuyu bitirelim

public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
                            continue;//çift sayıları atlıyor
                            //continue olmasa çıktı 123456 olacaktı
}

if (i == 7) {
break;//7yi bulduğu an döngü sonlanıyor
                                //continue olsa break olmasa 13579 olacaktı
}
System.out.println("i:" + i);
}
}
// 1 3 5

Kaynakça
http://www.injavawetrust.com/pure-java-43-flow-control-01/
http://www.injavawetrust.com/pure-java-44-flow-control-02/
http://www.injavawetrust.com/pure-java-45-loops/
http://www.injavawetrust.com/pure-java-46-break-continue/

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.