Spring Framework

S.a. Arkadaşlar,
Son zamanlarda belki de en çok duyduğunuz framework'lardan biri olan Spring'e giriş niteliğinde, onu tanıma adına bir yazı olacak.  Spring ile kurumsal projeleri rahatlıkla yapabileceğimiz bir framework'tur. Peki nedir diye frameworklardan farkı ki bu kadar ön plana çıktı.

Ant ile Css ve Js'leri Birleştirip Küçültmek

S.a. Arkadaşlar,

Uzun süredir yazamıyordum, klasik olacak ama iş-güç-yoğunluk. Bugün anlatmaya çalışacağım konu back-end değil front-end ile ilgili olacak. Yani arka tarafa yönelik değil de ön tarafı ilgilendiren bir konu olacak. Elimizde bulunan .js ve .css dosyalarını birleştirip onları sıkıştıracağız. Tabi öncelikle bunun için Ant'a ihtiyacımız olacak. Ant'ın kurulumunu buradan izleyebilirsiniz. Biz ant kurulu olarak yolumuza devam edeceğiz ve bununla birlikte YUI Compressor'a ihtiyacımız olacak.

Java Unit ile Test Yapma

      S.a. Arkadaşlar,
      Klasik bir cümle gibi olacak belki ama işlerin yoğunluğundan ve sonraki yorgunluktan bazen bırakın yazmayı, bilgisayarı açmaya bile üşeniyor insan. Hafta sonu girince araya biraz fırsat bulup dinlenebiliyor insan gerçekten. Bugünkü konumuz Junit ile test yapma olacak. Uzun süredir araştırdığım ve yazmak istediğim bir konuydu ama bugünlere kaldı. Nasip bugüneymiş diyelim ve başlayalım.

NoSql Veritabanlarının Karşılaştırılması

     S.a. Arkadaşlar,
     Aslında bu yazıyı diğer iki yazımdan önce yazmak gerekirdi bu. Fakat heyecanımızı yenemedik. Öncesinde bu ve bu yazılarını yayımladık. Neyse konuyu uzatmaya gerek yok. Bu konuyla ilk yazımızda NoSql üzerinde biraz durmuştuk. Sql ile arasındaki farkı incelemeye çalışmıştık ve daha sonra veritabanı olarak MongoDB'yi kullanmıştık. Fakat şimdi NoSql veri tabanları arasında nasıl farklar var diye bir araştırma yaptık. Şimdi gelin bunlara bir göz atalım. Bu yazının çoğunu Buğra Çakır Bey'in sunumda anlattığı konular üzerinden gidilmiştir, fakat tabii ki değişiklik eklemeler çıkarmalar oldu. Kendimiz düzenleyip, kendi anladıklarımızı paylaşmaya çalıştık.

Java ile MongoDB CRUD

      S.a. arkadaşlar,
      Java ile mongodb'ye bağlanma ile ilgili ilk yazımızda bilgilere yer vermiştik. NoSql nedir,  mongodb'ye nasıl bağlanılır ? Hangi arayüz programları kullanılabilir gibi soruların cevaplarını aramıştık. En son ise veritabana bir ekleme işlemi yapıp yazımıza son vermiştik. Bu sefer eklemeyle birlikte silme güncelleme listeleme gibi işlemleri de gözden geçirmeye çalışacağız. Bağlantıyla ilgili problemi olan arkadaşlar dediğimiz gibi ilk yazımıza göz atabilirler.

Java ile MongoDB Bağlantısı

     S.a. Arkadaşlar,
     Bugün konumuz biraz farklı bir konu olacak. Bildiğiniz üzere projelerimizde veri tabanı olarak Mysql kullanıyorduk, fakat uzun süre araştırıyor olduğum veri tabanı vardı: Mongo DB.

     Mongodb'yi açıklamadan önce NoSql nedir onu açıklamak lazım. Çünkü bildiğimiz sql komutlarının dışına çıkıyor. Yani sadece sql değil manasına NoSql kullanılmaya başlandı. Bunun çok büyük avantajları var. Özellikle çok büyük veriler barındırıyorsa projeniz o zaman farkını göreceksiniz.Resim-1'i inceleyebilirsiniz. Orta ve küçük projeler farkını o kadar da ortaya koymayabilir. Son dönemlerde adından sık sık söz ettirmeye başladı. Ben de bu konuyla ilgili araştırmalar yapıyordum. Bununla ilgili bir sürü veri tabanı kullanılabilir tabii ki, fakat biz mongodb kullanacağız.

Görüntü İşleme (Image Processing)

      S.a. Arkadaşlar,
      Bu gün farklı bir konuda bir şeyler yazacağız. Konumuz görüntü işleme olacak. Giriş mayetinde bir yazı olacak. O nedenle daha çok görüntü işleme nedir , ne değildirden konuşacağız. Daha sonra bir kaç basit örnek ile yazımıza son vermeyi düşünüyoruz. Bu konuyla ilgili yaptığım bir kaç araştırmadan sonra matlab veya java konusunda yazılara rastladım. Ama  bizim üzerinde duracağımız konu tabii ki java olacaktır. Peki nedir görüntü işlemi ? Kısaca bir görüntünün başka bir görüntüye dönüştürülmesi işlemidir. Peki o zaman arada ne gibi farklar olacak diye bir soracak olursanız; şöyle bir cevap verebiliriz. Örneğin görüntüdeki gürültüleri silebiliriz. Kişinin yüzündeki sivilceleri de silebiliriz :). Bir resim içinden harfleri çekebiliriz. Görüntüyü siyah beyaz veya farklı formatlarda işleyebiliriz. Ayrıca görüntüyü sıkıştırma, onarma gibi işlemlerde de kullanabiliriz. Bunu gibi örnekleri çoğaltabiliriz. Peki nerelerde kullanılır diye sorarsak; Tıp , astronomi,coğrafya, biyoloji gibi alanlarda kullanabiliriz. Tabi bu örnekleri çoğaltmak tabii ki mümkün. Bu işlemleri yaparken kütüphaneler mevcut. OpenCV ve OpenGL bunlardan ikisi. Bunla ilgili yazımızın sonunda bu konular üzerinde güzel web siteleri mevcut. Kaynaklar İngilizce de olsa gayet anlaşılır. Örneklerimizi de zaten bu sitelerin bazılarından aldık. Daha ayrıntılı öğrenmek için tabii ki çok daha emek sarf etmek gerekecektir. Bizimki sadece giriş niteliğinde bir yazı. Şimdi örneklerimizi inceleyelim.

Mvc Spring + Sıralama - Refactoring (Düzenleme)

       S.a. Arkadaşlar,
       Son yazımızda farklı alanlarda sıralama işlemleri yapmıştık. Fakat bunu uzun uzun if else ile yapmıştık, fakat aynı yazımızda bunun da başka bir yönteme göre kısalttığımızı söylemiş, ilerleyen yazılarda yine düzenlemeler yapabileceğimizi söylemiştik. Bugün yine küçük bir değişiklik ile kodu daha da kısalttık. Şimdi kod kısmında ne demek istediğimizi daha iyi anlatacağız.

Spring Mvc + Farklı Türlerde Sıralama Çift Sıralama

     S.a. Arkadaşlar,
     Bugünkü yazımız yine sıralama ile ilgili olacaktır. Belki diyeceksiniz ne kadar da uzadı bu sıralama yazıları, fakat ben de projeyi geliştirdikçe yazıyorum. Doğal olarak aklıma farklı şeyler geldikçe hem geliştiriyorum. Geliştirmem bittikten sonra tekrar yazıyorum, daha sonra neler yapabilirim diye düşünüyorum. Her neyse lafı fazla uzatmaya gerek yok. Dün ve bir önceki yazımızda yine sıralamadan bahsetmiştik, fakat ilk sıralama yazımızda sadece isime göre sıralama yapıyordu. İkinci yazımızda ise isme göre küçükten büyüğe ve büyükten küçüğe doğru sıralama yapıyordu. Biz bunu, kodu "copy-past" ile genişletip soy isim ve telefon için de yapabilirdik, fakat bu temiz kod ilkesine ters düşerdi. Biz bunu acaba kodumuzu nasıl daha güzel yazabiliriz diye düşündük ve en son aşağıda anlatacağımız kodu yazmaya karar verdik. Muhakkak bu kodun geliştirilebilir yanı vardır. Fakat daha sonra bu kodları tekrar gözden geçirip eksikliklerimizi (refactoring) tamamlamaya çalışacağız. Şimdi kod kısmına geçelim artık.

Spring Mvc + Çift Yönlü Sıralama

     S.a. Arkadaşlar,
     Spring projemizde en son kaldığımız yerden yine devam ediyoruz. Bir önceki yazımızda sıralama yapmıştık ve yazımızı ilerleyen zamanlarda geliştirebileceğimizi söylemiştik. Bugün yaptığımız sıralamaya ek olarak ters de olarak da sıralayabileceğiz. Alış veriş sitelerinde sıkça gördüğümüz ucuzdan pahalıya veya tarihe göre veya farklı kriterlerde sıralamalar yapılabiliyor. Biz de bunun basit halini yapmaya çalıştık. Şimdi kodumuz üzerinde devam edecek olursak;

Spring Mvc + Sıralama

      S.a. Arkadaşlar,
      Bir kaç farklı konudan sonra yine Spring mvc'ye döndük. Zaten önceki yazılarımızda bu projemiz üzerinden gelişmeler yapabileceğimizi belirtmiştik. Şimdi de onu yapıyoruz. Hatırlarsanız önceki yazılarımızda en son güncelleme işlemini yapmıştık. Şimdi ise bu işlemlere artı olarak sıralama işlemi yapacağız. Farklı yerlerde görmüş olduğumuz sıralama işlemini biz de uygulamamıza ekleyeceğiz. Fakat yapacağımız ekle tabi ki geliştirilebilir olacak. İleri ki günlerde belki daha da geliştireceğiz. Sizin de eklemek istediğiniz şeyler olursa projeyi paylaşıyorum, fikrinizi beyan edebilirsiniz. Şimdi yavaş yavaş kodlamamıza geçelim.

FTP

       S.a. Arkadaşlar,
       Bugünkü konumuz ftp ile ilgili işlemler olacak. Ftp ile ilgili internetten küçük bir araştırmadan sonra 2 jarla karşılaştım. Apache edtFTPj . Kaynaklar daha ağırlıklı apache kütüphanesi ile ilgiliydi. Ben de öyle bir başlangıç yapmıştım, daha sonra arkadaşımın apache'de karşılaşmış olduğu bir hata dolayısıyla tavsiyesi üzerine yolumuza edtFTPj ile devam ettik. Bunla ilgili da yeterince kaynak mevcur tabii ki yabancı sitelerde. Enterprise sürümünü kullanmak isterseniz ücret vermek zorundasınız, fakat bize ücretsiz sürümü yetti. Sizlere de yeteceğini düşünüyorum.

Jar Hatası

       S.a. Arkadaşlar,
       Bugünkü yazacağız yazımız diğerlerinden bir yönü ile farklı olacak. Daha önce hep bir konuyu anlatmaya çalıştık ve konuyla ilgili irili ufaklı kodlar paylaşmaya çalıştık, fakat bu yazımız karşılaştığım bir hatayla ilgili. Yazıp yazmamak konusunda kararsız kalsam da en sonunda yazmaya karar verdim. En kötü ihtimalle daha sonra dönüp bakabileceğim bir kaynak olur düşüncesiyle. İyi ihtimalle başka insanlar da faydalanır düşüncesiyle. Şimdi gelelim hatamıza. Daha önceki yazılardan birinde yazmıştık. Cmd komutu ile seri numarası ve bilgisayar ile diğer bilgiler alınabileceğini söylemiştik, daha sonra da jar dosyasına çevirmiştik. .Jar dosyası ben de çalışıyor fakat arkadaşlarımda denediğimde çalışmadığını gördüm. Küçük bir araştırma yaptım ama genelde insanlar javadaki sürümlerin aynı olması üzerinde durmuşlar. Şimdi burada kodu paylaşayım daha sonra üzerinde konuşmaya devam edelim.

Pdf to Excel

      S.a. rkadaşlar,
      Bugün elimizde bulunan pdf dosyalarını excele çevirmeye çalışacağız. İnternetten bir çok program bulmamıza rağmen istediğimiz işi tam olarak yapan bir program bulamadık. Daha önce de benzer işlemler yaptığımız için kendi kendimize çevirelim dedik ve daha sonra bunu sizlerle de paylaşalım dedik. İnternette çok farklı yöntemler, çok farklı kütüphaneler mevcut. Biz de buna ek olarak kendi projemizi yazdık, dediğimiz gibi kendi pdf formatımızı göz önünde bulundurarak yazdık. Sizler de bunu kendi isteğinize göre kolaylıkla çevirebilirsiniz diye düşünüyoruz. Şimdi kodumuzu yazmaya başlıyoruz.

Envanter + Kasa ve Monitör Seri Numaralarını Maille Gönderme

       S.a. arkadaşlar,
       Bir kaç günlük bir aradan sonra yine birlikteyiz. Uğraşmış olduğum küçük bir uygulamadan sonra öğrendiklerimizi dilimiz döndüğünce anlatmaya çalışacağız. Peki nedir yaptığımız program ? Envanter programı. Bilgisayarın gerekli bilgilerini almamızı sağlıyor. Mesela kasamızın seri numarasını, hangi işletim sistemi kurulu , kurulu olan programlar vs gibi bir çok bilgi öğrenebilirsiniz. Ben bu bilgilere ek olarak ekranın seri numarasını da bulmasını istedim fakat birazdan vereceğim cmd kodunda bir türlü bulamadım. İyi bir araştırma yaptığıma inanıyorum, fakat yine de bulamadım. Bilen varsa bana geri dönüş yaparsa çok sevinirim. Ben de maalesef yolu uzatan bir çözüm buldum. Ekranın envanterini bulan bir .exe bulup onu çalıştırıp, ekran çıktısını aldıktan sonra tekrar kapatıyorum. Tabi bu çözüm kulağı tersten tutmaya benzer, ama hiç yoktan daha iyidir diye düşündüm belki de, fakat bu herşeye rağmen bir çözümdür. Daha sonra ekran çıktımızı ve bilgilerimizi belirlediğimiz adrese gönderiyoruz. Şimdi giriş yaptıktan sonra yazımıza kodlarımıza başla vakti geldiğini düşünüyoruz. Her zamanki gibi yine kodlarımızın içinde yorum satırlarıyla beslemeye çalıştık.

Dosya Silme İşlemi (Recursive) + Jar Yapma

         S.a. arkadaşlar,
         Bir kaç gündür yazdığımız Spring Mvc konusuna şimdilik ara veriyoruz. Küçük bir proje yapmıştık daha sonra üzerine eklemeler yapabiliriz. Ama bugün dosya silme işlemleri altında bir kaç şey incelemeyi düşünüyoruz, daha sonra bunu Jar olarak kaydedip, windows başlangıcında çalışmasını işleyeceğiz. Yazdığımız küçük kodu da isteyenler için paylaşacağız, fakat bunda çok da gerekli değil vereceğimiz kodlar hemen çalıştırabilir vazieyette olacak. Şimdi artık konumuza geçme vakti geldi. Elimizde bir klasör ve bu klasördeki dosyaları silmeyi istiyoruz. Bunu nasıl yapabilirizin cevabını arayacağız. Kodu verip gerekli yerlerde yorum satırları ile içine kodu anlatmaya çalıştık.

Spring Mvc + Güncelleme (Uptade) İşlemleri

       S.a. arkadaşlar,
       Bugün yine bir spring yazımız olacak inşaAllah. Dün projeyi düzenleyip çalışır hale getirdikten sonra saat geç olduğu için yazıyı bugün sabah dinç kafayla yazmaya karar verdim. Hep çalışmak isteyen arkadaşlar için de rahat kafayla çalışmak galiba daha iyi olacak. Bu yazımız belki de şuan için spring konumuzun son yazısı olabilir. Çünkü kafamızdaki işlemlerin hepsini şuan projede yaptık. Tabi bu yeterli değil, fakat en azından başlangıç yapacak arkadaşlar için küçük ama verimli bir seri olduğu kanaatindeyim. Umarım sizler de bu düşüncedesinizdir.

Spring Mvc + Listeleme ve Silme İşlemi

         S.a. Arkadalar,
       Bugün kaldığımız yerden devam edeceğiz yine. Dün sağlıkla ilgili problemlerden dolayı yazacak vakit bulamadım. Akşam da güzel bir Akın Kaldiroğlu semineri vardı Java EE ile ilgili. İnternette yayımlayacaktı. İzlemenizi tavsiye ederim.

        En son validation işlermleri yapmıştık. Bugün ise kayıt ettiğimiz bilgileri ekrana getireceğiz ve daha sonra da kayıtlar üzerinden silme işlemini gerçekleştireceğiz. Projenin düzgün çalışması için terlediğimi ifade etmek zorundayım. Ben de yeni yeni öğreniyorum sonuçta bu yüzden sizlerin de bir görüşünüz fikriniz olduğu zaman paylaşabilirsiniz. Eski projemiz üzerinden devam etme şansımız olmasıyla birlikte, projenin son halini yazının sonunda paylaşacağım. Oradan indirip üzerinde çalışabilirsiniz. Yorumları yine kodlar arasında yapmaya çalıştım.

Spring Mvc + Validation (Doğrulama)

        S.a. arkadaşlar,
        Bugün yine Spring Mvc ile ilerlemeye devam edeceğiz Dünkü yazımızda kullanıcı giriş ve oradan başka bir sayfaya yönlendirme yapılıyordu. Fakat farkettiyseniz orada her hangi bir doğrulama yoktu. Yani kullanıcı ismini soyismini veya telefonunu kafasına göre birşeyler girdiğinde herhangi bir hatayla karışlaşmıyor, her şekilde sayfa geliyordu. Bugün ise buna engel olacak bazı değişiklikler yapacağız projemizde. Projemizi yine yazımızın sonunda paylaşacağız. Daha önce indirenler olduysa da onun üzerinden rahatlıkla devam edebileceklerdir. Şimdi bunları açıkladığımıza göre yavaş yavaş kod kısmına geçelim.

Spring Mvc + Üye Kayıt

      S.a. Arkadaşlar,
      Bir önceki Spring MVC'ye giriş yazımızdan sonra şimdi de küçük çapta bir üye kayıt programı yazdık. Burada belki çoğu yerde gördüğünüz küçük bir program fakat burada inşaAllah elimizden geldiğince konuya devam edip süreklilik sağlamak niyetindeyiz. Çünkü yine belirttiğim gibi Türkçe döküman yok denecek azınlıkta. Çorbada bizim de bir tuzumuz olsun düşüncesiyle yazıyoruz. Umarım herkes için faydalı olur. Şimdi başlayalım. İlk giriş projemiz biraz da üzerinden devam edelim. O nedenle her sayfayi değil de yeni eklediğimiz şeyler üzerinden daha çok gideceğiz. Giriş sayfasına buradan ulaşabilirsiniz.

Spring MVC + Maven

       S.a. arkadaşlar,
Uzun süredir yazamıyordum, sadece arada bir keyword yazısı yapmıştık. Onun dışında bir ara vermiştik. Biraz işlerin yoğunluğun biraz da farklı konularla uğraşmaktan. O konulardan biri de Spring'di. Araştırma yaparken sürekli ingilizce siteler haşır neşir oluyoruz. Javacı olmayı göze alıyorsak bu da onun doğal sonucu, bu nedenle ben de giriş nezdinde bir spring mvc projesi oluşturmaya çalışacağım. Proje bağımlılığı olarak da maven kullanacağız. Bir giriş projesi oluşturacağız öncelikle daha sonra yavaş yavaş projemizi ilerletip daha farklı işlemler yapmaya çalışacağız. Şimdilik projeye başlayalım. Bu arada projemizi eclipse ile geliştiriyoruz. Resimlerin üzerinden ilerleyelim. Altına da kısa kısa notlarla anlatmaya çalışacağız.

Keywords in Java

       S.a. Arkadaşlar,

   Uzun zamandır yazamıyorduk. Bugünkü konumuz java'da olan tüm keywordleri elimizden geldiğince az ve öz bir şekilde yazmak. Hem tüm keywordleri ayno başlıkta altında toplayabilmek

Abstract: Belli bir sınıfın üyelerinin kullanıdığı temel arayüzler bulunmaktadır java dilinde bu kavram interface ile yürütülmektedir. C++ da bu işlem abstract class ile yürütülebilir.

Assert: Java 5 ile gelen bir hata belirtme işlemidir.

Boolean: Primative değer olup , false ve true değerini alır.

Break: Bir döngü içinde bu komuta rastlanıldığında, döngüyü kırar.

Byte: primative değer alıp -128 ile 127 arasında değerler alır.

Case: switch yapısı ile birlikte kullanılır. Belirlenen hangi case (seçenek ) uygunsa o çalıştırılır.

Catch : try catch bloğu içinde try içinde hata olduğunda çalışacak bloğu belirtir.

Char: tek karekterlik işlemlerde kullanılan primative tiptir.

Class: hepimizin duyduğu sınıf tanımlaması yapar. Başlı başlına bir denizdir diyebiliriz.

Const: değişmeyen değişken ve alanlara atanır. Bir kere tanımlanır. Ama java’da kullanılmıyor

Continue: Döngü içine kullanılır, break gibi. Farkı ise sadece o değer için döngüyü atlar, döngüyü tamamen kırmaz.

default: aynı paketteki erişebilir ama yazılmaz. Switch case yapısında  ise kullanılır ve diğer tüm koşullar sağlanmadığında bu koşul çalıştırılır.

Do: while ile birlikte çalışır ve döngüyü en az 1kez çalıştıran komuttur.

Double: küsüratlı değer alan sayıları göstermek için kullanılır. Floattan geniştir

Else : if else yapısında , if koşulu sağlanmadığı zaman bu yapı çalışmaya başlar.

Enum: Sabit değerleri ayrı ayrı tanımlamak yerine kullanılan sınıf tanımlamasıdır.

extends: bir sınıfa ait özelliklere başka bir sınava miras almak için kullanılır.

final: Bir kere değer tanımlaması yapılır ve daha sonra aynı sınıfa erişildiğinde sınıf atama yapmaz, konstrüktör ile okunur. Metodları ise alt sınıflarca override(ezme) edilemezler, sınıfları ise alt sınıflarca genişletilemezler.

Finally: try catch ile birlikte kullanılabilir, fakat her koşulda çalışması gereken kodları içerir

Float: küsüratlı sayıları göstermek için kullanılır

For: Hepimizin yakından bildiği döngü ifadesidir.

Goto: Pek kullanılması uygun olmasa da istenen yere götüren komut diyebiliriz.

İf: bir koşul ifadesir. Tek başına kullanıldığı gibi else ile de kullanılabilir.

İmplements: interfaceleri class ile kullanmak istediğimizde kullanırız.

İmport: Paketleri eklemek için kullanulır

insance of: Javada bir nesnenin bir sınıftan türemiş olup olmadığını anlamamızı sağlayan “instanceof” anahtar kelimesidir.  Varsa true yoksa false döndürür.

Long: int gibi değerleri alır, fakat int’ten daha büyük değerleri tutabilir.

Native: C++ extern komutu ile benzer mantıkta çalışır. Harici programlama dili desteği sağlar

New: obje tanımlama işlemi yapar.

package: Sınıflardan vb yapıları içinde bulunduran yapıdır.

private: Sadece içinde bulunduğu sınıf çağırabilir.

Protected:  Alt sınıf ve aynı pakettekiler erişebilir

public: Bütün sınıflardan erişilebilir

return: metotların geri dönüş değerlerini döndürür.

short: int gibi değerleri kullanmak için vardır. Short’tan büyük int’ten küçük değer aralığı vardır.

static : Java programlama dilinde bir metod ya da değişkenin belli bir objeye degil de bir sınıfın tamamına ait olduğunu belirten bir kelimedir. Metodu statik yapar ve dışarıdan çağrılırken sınıftan bir instance yaratılmaz. Aynı sınıf içinde statik olmayan bir metod tarafından çağırılamaz.

Strictfp: Flaot ile çalışırken farklı sebeplerden dolay değerler değişkenlik gösterebilir. Bunun önüne geçmek için bu komut kullanılır.

super: Tüm default yapılandırıcılar kalıtım ağacında yukarıdan aşağı doğru  java tarafından gizli olarak ve otomatik aktarılır. Bu yapılandırıcıları kullanmak için super() deyimini kullanırız.

Synchronized: Bir threat bir sınıfta herhangibir metoda erişirken diğer sınıfın erişiminin sırada beklemesini istersiniz. Bunun için bu ifadeyi kullanırız

This: Nesnelerin kendilerine ulaşmalarında kullanılır. Nesnelere bağlı data alanlarına erişim imkanı sağlar.

Throw: açıkça exception fırlatma işlemini yapar

throws: Eğer bir metot yönetemediği bir istisnaya neden olursa, metot çağırıcılarının kendilerini bu istisnaya karşı koruyabilmeleri için, metodun bu davranışı belirtmesi gerekir.

transient: Serileştirilmesi istenmeyen sınıf özellikleri/değişkenleri için kullanılan java anahtar terimidir

try: hata fırlatma olasılığı olan kodun yazıldığı kısımdır.

Void: Geri dönüş tipinin olmadığını belirtir. Return döndürülmez. Hata verir.

Volatile: Program dışında onu etkileyecek unsurların var olabileceğini hatırlatıyor

while: Bir çeşit döngüdür. Tek başına veya do ile kullanılabilir.

Thread

        S.a. Arkadaşlar,
        Bugünkü konumuz threadlar olacak. Elimizden geliğince sade bir şekilde anlatmaya gayret edeceğiz. Muhakkak hepimizin en azından bir kaç defa duyduğunu düşündüm bir kavram , fakat tam olarak nedir nasıl çalışır onu irdelemeye çalışacağız. Peki nedir thread ? Threadler kısaca çalışan iş parçacıklarıdır. Java'nın çoklu thread özelliği ile işlemci yönetimi sağlayabiliriz. Peki bu işlemci yönetiminin bize ne gibi faydaları olur derseniz işlemcinin performansından en iyi şekilde yararlanmak da diyebiliriz, fakat bunu yaparken sistemin çalışmasına etki edebileceğimizi de unutmamak gerekir. İyi uygulanmadığında başımızı ağrıtacağı da kesindir. Şimdi gelelim threadlerin kullanım şekline. Threadler 2 şekilde kullanılabilirler. Bunlardan biri kalıtım diğeri ise interface ile implement etmektir. Fakat hangisi daha uygun diye sorarsanız , bildiğimiz gibi java çoklu kalıtım izin vermediği için eğer biz class Sinif extends Thread yaparsak, kalıtım hakkımızı böyle  doldurmuş olacağız. Fakat eğer biz class Sinif implements Thread yaparsak , burada herhangi bir kısıtlama yoktu hatırlarsınız. birden fazla interface de implement edilebiliyordu. Şimdi yavaş yavaş kodlamamıza başlayıp eksik gördüğümüz yerleri tamamlamaya çalışalım

public class CoolThread extends Thread {

@Override
public void run() {
System.out.println("The job is starting!");
}

public static void main(String[] args) {
CoolThread t = new CoolThread();
Thread t2 = new Thread(new CoolThread());
                t2.run();
                //çalışan threadm canlı değildir. Canlanması için
                //start edilmeye ihtiyacı vardır
}
}

//bu 2 kod arasında çalışma mantığı olarak hiç bir fark yoktur
//fakat üstteki kod kalıtım yardımıyla çalışmaktadır
//aşağıdaki kod ise interface uygulayarak çalışmak
//yukarıda da belirttiğimiz gibi tercihimiz alttaki koddan yanadır.
//aşağıdaki koddan devam edeceğimiz için o kodu geliştirdik

class MyRunnableMoreThread implements Runnable {

@Override
public void run() {
System.out.println("run method()");
for (int i = 0; i < 10; i++) {
String name = Thread.currentThread().getName();
long id = Thread.currentThread().getId();
System.out.println("index:" + i + " " + name + " " + id);
}
}

}

public class RunnableMoreThreadTest {

public static void main(String[] args) {

MyRunnableMoreThread myRunnable = new MyRunnableMoreThread();
Thread t1 = new Thread(myRunnable);
Thread t2 = new Thread(myRunnable);
Thread t3 = new Thread(myRunnable);

t1.setName("First");
t2.setName("Second");
t3.setName("Third");
             
                //start threadi başlatır.
                t1.start();
t2.start();
t3.start();
                //t1.run();
                //fakat run start olmadan da çalışır ama thread hala pasiftir
                //çünkü run da bir metod olduğundan referans ile çağırabiliriz
}
}

     Burada çaktığımız değişkenlik gösterir. Bunun sebebi hangi threadin hangi anda çalışacağının belli olmamasıdır. Yani thread1 çalışıyorken bir anda thread 2 onu keser , tekrar thread 1/3 thread2'yi keser ve bu şekilde devam edebilir, fakat burada önemli olan her threadin görevinin tamamlayıp sonlanacağıdır. Threadlerle ilgili bir kavramları göreceğiz. Bu sayede threadleri yönlendirebiliriz. Bu yönlendirmeleri yapabileceğimiz bir kaç kavram ve metod üzerinde duralım.

New: Threadin oluşturulduğu fakat henüz çalışmaya başlamadığı durumdur
Runnable: Threadin çalışmaya başladığı andır. Thread artık aktiftir.
Waiting: Threadin beklemede olduğu kısımdır. Aktiftir fakat çalışmaz.
Blocked: Senkronize edilmiş bir metodda çalışan thread dışındaki threadler askıya alınır.
Terminatted: Threadin faaliyetinin son bulduğu durumdur.

     Kavramlara kısaca baktık, şimdi de bazı metodlara bakıp yazımızı sonlandıralım.

Sleep: Belirtilen süreye kadar metodu bekletir. Süre bittiğinde tekrar çalışacağının garantisi yoktur. Overload metodları vardır. Parametre almayan metodu Exception fırlatır. O nedenle bu hatayı yakalamamız gerekir yoksa program hata verecektir. Statictir.

Yield: Threadlere öncelik verir. Fakat bu öncelik sıralamasının yine de bir garanti durumu yoktur. Statictir. Genelde pek kullanılmaz. Debug ve tet amaçlı kullanılabilir.

Join: Diğer 2 mtedoun aksine static değildir. Overload metodları vardır. Parametre almayan metodu exception fırlatır. Burada ise 1 metod çalışırken diğer metodlar bloklanır. Bir tür senkronize vardır.

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

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