Collections – Sorted Map Interface

Hi all! Today i’m going to tell about Sorted Map Interface. We talked about Map Interface before this article. This interface extends Map interface. For example class that implements this interface is TreeMap.
Sorted Map doesn’t allow null keys and null values and it stores elements by sorting with keys.

Let’s take a look Sorted Map methods in shortly

subMap(K fromKey, K toKey) : It returns part of Map with keys range.
headMap(K toKey) : It returns part of Map whose keys are strictly less than toKey
tailMap(K fromKey) : It returns part of Map whose keys are greater than or equal fromKey
firstKey() : It returns fırst key currently in this Map.
lasKey() : It returns last key currently in this Map.
comparator() : It returns the Comparator used to order the keys in this Map.

Let’s check the example code.

import java.util.*;

public class Main {

    public static void main(String... args) {
        SortedMap<Integer, String> ageNameMap = new TreeMap<>();
        ageNameMap.put(26, "Ufuk");
        ageNameMap.put(24, "Halis");
        ageNameMap.put(28, "Alice");

        write(ageNameMap);
        System.out.println("---------------------------------------");
        System.out.println(ageNameMap.subMap(24,26));
        System.out.println(ageNameMap.headMap(27));
        System.out.println(ageNameMap.tailMap(25));
        System.out.println(ageNameMap.firstKey());
        System.out.println(ageNameMap.lastKey());
    }

    private static void write(Map map) {
        Set<Map.Entry> entries = map.entrySet();
        for (Map.Entry entry : entries) {
            System.out.println("Key : " + entry.getKey());
            System.out.println("Value : " + entry.getValue());
        }
    }
}

Collections – Map Interface

Hi everyone! Today i’m going to explain about Map Interface in Java. We started the these article series with Collections and Map Interface is a valuable part of that Collection Framework. But Map interface is not a subtype Collection Interface. It behaves little bit different.
Map stores elements key-value pairs. You can access to values with key. It can not contains duplicate keys. Each key has only one value. Some of Map implementations can allow null value(key or value) but some of not. Example, HashMap and LinkedHashMap allow that but TreeMap doesn’t allow.

Lets take a look Map interface methods in shortly.

public Object put(Object key, Object value) : This method is used to insert an entry in this map
public void putAll(Map map) : This method is used to insert a map in this map.
public Object remove(Object key) : This method is used to remove an entry for key
public Object get(Object key)  : This method is used to get value for key
public boolean containsKey(Object key) : This method is used to check key is exists.
public Set keySet() : This method returns containing all keys
public Set entrySet() : This method returns containing all keys and values.

Here is the example of code about Map Interface.

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Main {

    public static void main(String... args) {
        Map<String, Integer> nameAgeMap = new HashMap<>();
        // Adding elements to map
        nameAgeMap.put("Ufuk", 26);
        nameAgeMap.put("Halis", 26);
        nameAgeMap.put("Alice", 30);

        write(nameAgeMap);
        System.out.println("------------------------------------");
        //Removing element from map
        nameAgeMap.remove("Ufuk");
        write(nameAgeMap);
        System.out.println("Map contains key Ufuk : " + nameAgeMap.containsKey("Ufuk"));
    }

    private static void write(Map map) {
        Set<Map.Entry> entries = map.entrySet();
        for (Map.Entry entry : entries) {
            System.out.println("Key : " + entry.getKey());
            System.out.println("Value : " + entry.getValue());
        }
    }
}

Collections – Giriş

Merhabalar, bu yazımda Java‘da Collections‘a giriş yapacağım ve sonraki yazı serilerinde bu framework içinde bulunan class‘ları ve interface‘leri anlatmaya devam edeceğim.

Collections, Java içerisinde büyük bir öneme sahiptir ve bu yüzden Java‘da öğrenilmesi gereken en önemli alanlarından biridir. Sonuçta kodlama yaparken kullandığımız List, Map, nedir, nasıl çalışır, avantajları vs gibi durumlarınların bilinmesi bizi daha efektif kod yazmaya iter.

Java‘da Collections‘dan önce, array, vector ve hashtable bulunmaktaydı. Bu 3 farklı collection‘nın ortak bir interface‘i yoktu. Yani her biri için farklı metotlar, farklı member‘lar anlamına geliyordu. Bu da programcı için bir dezavantaja dönüşmekteydi. Bu daha da ileride işkenceye dönüşmemesi için Java‘yı geliştirenler, ortak bir interface‘e sahip ve önceki Collection‘ların problemlerini çözecek bir framework tasarladılar ve böylece Collection Framework‘ü doğmuş oldu.

Collection Framework‘ünün avantajlarından şöyle bahsedebiliriz.

  • Tutarlı(Consistent) bir API.
  • Programlama efortunu kısaltma.
  • Programlama hızını ve kalitesini arttırma.

Core olarak yer alan interface‘leri incelersek;

             Collection                Map
         /     /    \      \            |
        /      /      \     \           |
     Set    List    Queue  Dequeue   SortedMap
     /
    /
 SortedSet

Collection : En tepedeki interface’dir. add(), remove(), contains(), isEmpty(), addAll() gibi metotları bulunmaktadır.

Set : Duplicate eleman yer almaz. Örnek olarak HashSet ve TreeSet(SortedSet sınıfını implements eder) verilebilir.

List : Duplicate eleman içerebilir. Elemanlar sıralıdır. Örnek olarak LinkedList ve ArrayList verilebilir.

Queue : FIFO prensibine göre hareket eder.

Dequeue : LIFO ve FIFO prensiplerini destekler.

Map : Elemanları keyvalue şeklinde saklar. Duplicate elemanlara izin vermez. Örnek olarak HashMap ve TreeMap(SortedMap interface’i implement eder.) verilebilir.

Collections giriş olarak şimdilik bu kadar, sonraki yazılarda yer alan interface‘leri örnekler ile incelemeye başlayacağız.

Reflection API

Merhabalar, bu yazımda Java’daki Reflection API‘ye kısaca değineceğim. Reflection API, çalışma zamanı anında, metotların, sınıfların ve interface’lerin davranışlarını incelemek veya değiştirmek için kullanılır.

Reflection, bir nesnenin hangi sınıfa ait olduğu ve nesneye ait hangi metotların koşturulabileceği hakkında bilgiler verir ve bunu runtime anında yapar.

getClass() metoduyla nesnenin ait olduğu sınıfın ismine erişilebilir.
getConstructors() metoduyla nesnenin ait olduğu sınıfın public constructor‘larına erişilebilir.
getMethods() metoduyla nesnenin ait olduğu sınıfın public metodlarına erişilebilir.

Eğer bir sınıfın sahip olduğu private field‘lara veya metotlara erişmek istersek şu şekilde ilerleyebiliriz.
Class.getDeclaredField(FieldName) ile Field nesnesini aldıktan sonra Field.setAccessible(true) yaparak, access modifier‘ından bağımsız olarak metot veya field‘a erişim sağlanabilir.

Reflection‘lar sahip oldukları bu özellikleriyle bize genişletilebilirlik(Extensibility) anlamında avantajlar sağlamaktadır. Ancak bir nesnenin hangi sınıfa ait olduğu bilip Reflection API kullanmadan yapmak performans açısından daha iyidir. Bu nedenle sıklıkla kullanılan kodlarda Reflection API kullanılmasından kaçınılmalıdır. Ayrıca Reflection abstraction kavramını da yok etmeye meyillidir.

Yukarıda bahsettiklerimi basit olarak kodda aşağıdaki gibi uygulayabiliriz.

ReflectionTest.java

public class ReflectionTest {
    private String str;

    public ReflectionTest() {

    }

    public void method1() {
        System.out.println("Method 1 worked");
    }

    public void method2() {
        System.out.println("Method 2 worked");
    }

    public String getStr() {
        return str;
    }
}

Main.java

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Main {
    public static void main(String... args) throws
            NoSuchMethodException, InvocationTargetException, IllegalAccessException, NoSuchFieldException {
        ReflectionTest test = new ReflectionTest();
        Class clazz = test.getClass();
        System.out.println("test object class name : " + clazz.getName());
        System.out.println("test object class constructor name : "
                + clazz.getConstructor().getName());
        for (Method method: clazz.getMethods()) {
            System.out.println("Method Name : " + method.getName());
        }
        Method method1 = clazz.getMethod("method1");
        //calling method1
        method1.invoke(test);

        //private field accessing and set new value
        Field field = clazz.getDeclaredField("str");
        field.setAccessible(true);
        field.set(test, "TEST");
        System.out.println("str value : " + test.getStr());
    }
}

Java – Static Blocks

Merhabalar, bu yazımda Java‘da yer alan static blocks‘tan kısaca bahsedeceğim. Bu bloklar bir sınıfın static initializations‘ı olarak kullanılır. Static bloktaki kod yalnızca bir kere çalıştırılır ve bu bloklar construct‘lardan önce çalışır. Aşağıda bu static blok olayını anlatan kod yer almaktadır.

class Example {
    static int i;
    static {
        i = 10;
        System.out.println("Static block");
    }
    Test(){
        System.out.println("Constructor");
    }
}
class Main {
    public static void main(String args[]) {
        Example e1 = new Example();
        Example e2 = new Example();
    }
}
Programı çalıştırdığımızda aşağıdaki gibi bir çıktı olacaktır ve görüldüğü Example sınıfından nesne oluştururken static blok bir kez ve constructer’dan önce çalıştı.
Static block
Constructor
Consturctor

JVM Mimarisi

Merhabalar, bu yazımda Java Virtual Machine‘nin(JVM) hakkında bildiklerimi aktarmaya çalışacağım. Öncelikle google’a jvm yazdığınızda çıkan wikipedia sayfasında yer alan, JVM’in genel yapısını gösteren bir resimle başlıyorum.

1024px-jvmspec7

Resimden de görülebileceği gibi 3 temel bölüm var diyebiliriz. Class Loader, JVM Memory ve Execution Engines..

Temel olarak JVM‘in görevi Java uygulamalarını çalıştırmaktır diyebiliriz. Bir Java kodundaki ana metodu(main method) çağırır. JVM, JRE‘nin(Java Run Enviroment) bir parçasıdır.

Java uygulamaları WORA(Write Once Run Everywhere) prensibine sahiptirler. Geliştirici yazdığı Java kodunu, herhangi bir JVM yüklü platformda çalıştırabileceği anlamına gelir. Şimdi yukarıdaki resimde bahsettiğimiz 3 temel bölümü inceleyelim.

1. Class Loader Subsystem(Sınıf Yükleyici Alt Sistemi)

Bu bölümde ana 3 aktivite bulunur. Loading, Linking  ve Initialization..

1.1 Loading

Java‘da *.java uzantılı dosyalar derlendiğinde *.class uzantılı hale gelir. Class Loader. *.class uzantılı dosyaları okuyarak ikili verileri üretip metot bölgesine kaydeder. Her *.class dosyası için JVM, aşağıdaki bilgileri saklar.

  • Yüklenen sınıfın tam adı ve üst sınıfını.
  • .class dosyasının Class veya Interface veya Enum ile alakalı olup olmadığını.
  • Değişkenler ve metot bilgilerini.

*.class yükleme işleminden sonra, JVM bu .*class‘ı temsil etmek için heap memory‘de Class tipinde bir nesne oluşturur. Bu Class tipi java.lang paketinde tanımlanmıştır ve bu Class, programcı için nesne hakkında bilgi almalarda kullanılabilir.(Sınıfın adı, Parent adı, değişkenleri, metotları vs.)

Her yüklenen *.class dosyası için yalnızca bir Class nesnesi oluşturulur.

1.2 Linking (Bağlama)

Bu aşamada da verification, preparation ve opsiyonel olarak da resolution işlemleri uygulanır.

Verification(Doğrulama) : *.class dosyalarının doğruluğunun yapılması aşamasıdır. Doğrulamadan geçilemezse run-time java.lang.VerifyError hatası verir.

Preparation(Hazırlık) : JVM gerekli sınıf değişkenkerini memory’de yer ayırır ve varsayılan değelerini atar.

1.3 Initialization (Başlatma)

Bu aşamada, tüm statik değişkenler ve varsa statik blokta tanımlanan değerleriyle atanırlar. Genel olarak üç tane sınıf yükleyici vardır.

Bootstrap Class Loader(Önyükleme Sınıfı Yükleyicisi) : Her JVM uygulamasında güvenilen sınıfları yükleyebilen bir önyükleme sınıfı yükleyicisi olmalıdır. Bu loader, JAVA_HOME/jre/lib dizininde bulunan çekirdek java API sınıflarını yükler. Bu yol yaygın olarak önyükleme yolu olarak bilinir. Buradaki API’ler C, C ++ gibi yerel dillerde yazılmışlardır.

Extension Class Loader(Uzantı sınıfı yükleyicisi) : Önyükleme sınıfı yükleyicisinin child’dıdır. JAVA_HOME/jre/lib/ext (Uzantı yolu) uzantı dizinlerinde bulunan sınıfları veya java.ext.dirs sistem özelliği tarafından belirtilen başka bir dizini yükler. Java’da sun.misc.Launcher $ ExtClassLoader sınıfı tarafından uygulanmaktadır.

System/Application class loader(Sistem / Uygulama sınıfı yükleyici) : Uzantı sınıfı yükleyicinin child’dıdır.. Sınıfları uygulama sınıfı yolundan yüklemekle sorumludur. İçinde java.class.path ile eşlenen Environment Variable‘i kullanır. Ayrıca, Java’da sun.misc.Launcher $ ExtClassLoader sınıfı tarafından da uygulanır.

2. JVM Memory

JVM mimarisini 2. bölümüdür. Şekilde de görüldüğü gibi 5 alandan oluşmaktadır.

Method Area : Metod alanında, sınıf adı, ana sınıf adı, değişkenleri, metotları vs. gibi bilgiler saklanmaktadır. JVM başına yalnızca bir yöntem alanı vardır ve paylaşılan bir kaynaktır.

Heap Area : Tüm nesnelerin bilgilerini saklar.JVM başına bir heap alanı vardır ve paylaşılan bir kaynaktır.

Stack Area : Her iş parçacığı için, JVM burada saklanan bir çalışma zamanı yığını oluşturur. Bu yığının her bloğu, yöntem çağrılarını saklayan etkinleştirme kaydı / yığın çerçevesi olarak adlandırılır. Bu yöntemin tüm yerel değişkenleri, karşılık gelen çerçevede saklanır. Bir iş parçacığı sonlandıktan sonra çalışma zamanı yığını JVM tarafından yok edilir. Paylaşılan bir kaynak değildir.

PC Registers : Bir iş parçacığının geçerli yürütme talimatının adresini saklar.

Native Method Stacks : Her bir iş parçacığı için ayrı yerli yığın oluşturulur. Yerel metod bilgilerini depolar.

3. Execution Engine

Bu aşama da her *.class dosyalarını satır satır okur ve çalıştırır.3 aşaması vardır.

Interpreter : Bayt kodu satır satır olarak yorumlar ve yürütür. Buradaki dezavantaj, bir yöntem birden çok kez çağrıldığında, her yorumlama gerekliliğidir.

Just In Time Compiler : Interpreter verimliliğini artırmak için kullanılır.Tüm bayt kodunu derleyip yerel koda çevirir, böylece Interpreter tekrarlanan metod çağrılarını gördüğünde, JIT bu bölüm için doğrudan yerel kod sağlar, böylece yeniden yorumlama gerekli değildir, ve verimlilik artmış olur.

Garbage Collector : Referans edilmemiş nesneleri yok eder.

Object Pool – Tasarım Kalıpları

Merhabalar, bu yazımda Object Pool (Nesne Havuzu) tasarım kalıbından bahsedeceğim. Evet, Java’da nasıl nesne yaratılır biliyoruz, hatta bi önceki yazımda eğer nesneyi oluşturmak çok maliyetli ise Prototype tasarım kalıbını kullanmıştık. Object Pool tasarım kalıbı da isminden de anlaşıldığı gibi, havuzdan nesne alacağız. Yani biz sistemden birden fazla nesneler yaratıp, daha sonra ihtiyaç duyduğumuz zaman eğer istediğimiz tipte nesne havuzda var ise var olanı dönecek yok ise yaratıp havuza atılacak. Örneğin DAO sınıfları. İleride DAO tasarım kalıbına da ayrıca geleceğim. Veritabanı işleriyle uğraşırken DAO tasarım kalıbını kullanırız ve bir DAO sınıfından bir nesne yarattığımız zaman direkt sınıftan oluşturmaktan ziyade bir havuz içerisinden isteriz ki, eğer zaten varolan bir nesne var ise onu dönsün. Böylelikle performans ve zaman kaybı yaşamayalım. Nesne havuzuna attığımız nesneler sistemin herhangi bir yerinden çağrılabilecek olan nesnelerdir. Şimdi örnek üzerinden gidelim.

Base bir Basket nesnemiz olacak.

Basket.java

public abstract class Basket {
    public String type() {
        return "Base Basket";
    }
}

İçinde type adında bir metodu var ve türünü bize söylüyor. Şimdi bu Basket sınıfını extend eden IronBasket olsun. Sisteme bir sürü sepet ekleyebiliriz.

IronBasket.java

public class IronBasket extends Basket {

    @Override
    public String type() {
        return "Iron Basket";
    }
}

Son olarak BasketSource isimli sınıfımızı yaratalım.

BasketSource.java

public class BasketSource {
    private static BasketSource source = new BasketSource();
    private Map<Class<? extends Basket> , Basket> poolMap = new HashMap<Class<? extends Basket>, Basket>();

    private BasketSource() {
    }


    public static Basket getBasket(Class<? extends Basket> clazz) throws IllegalAccessException, InstantiationException {
        Basket b = source.poolMap.get(clazz);
        if (b == null) {
            b = clazz.newInstance();
            source.poolMap.put(b.getClass(), b);
        }
        return b;
    }
}

Görüldüğü gibi BasketSource sınıfımızdan getBasket diyerek istediğimiz türde sepet alabiliriz. Sistemde eğer o sepet yoksa yaratılacak varsa da bize yaratılmış olan sepeti verecek.

Main.java

public class Main {

    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        Basket basket = BasketSource.getBasket(IronBasket.class);
        System.out.println(basket.type() + " " + basket.toString());
        Basket basket2 = BasketSource.getBasket(IronBasket.class);
        System.out.println(basket.type() + " " + basket.toString());
    }
}

Kodun çıktısına bakınca aynı nesneyi bize verdiğini görüyoruz. Object Pool tasarım kalıbı, kontrollü nesneler oluşturulmak istendiğinde, nesne sürecini hızlandırmak istendiğinde veya kullanılacak nesne sayısına sınırlama getirmek istendiğinde tercih edilebilir.

Bir yazının daha sonuna gelmiş olduk. 🙂

Prototype – Tasarım Kalıpları

Merhabalar, bu yazımda Prototype Tasarım kalıbını anlatmaya çalışacağım. Bir sistemde, bir yazılımda nesne oluşturma süreçleri çok önemlidir. Zaten tasarım kalıplarının kendi içinde neden 3’e ayrıldığını ve Oluşturucu Tasarım kalıplarıyla giriş yapıldığından anlayabilirsiniz. Neyse, hele ki bu oluşacak nesneler çeşitli sebeplerden dolayı, oluşturulması uzun sürüyorsa. Bu gibi durumlarda sürekli bu nesneye ihtiyaç duyduğumuzda yeniden oluşturmak yerine, mevcut nesnenin bir klonunu alıp, set metodları ile istenilen şekilde yapılandırılabilir. İşte bu klon bir prototip’dir. Kavram olarak son derece anlaşılır ve basit:)

Bir örnek üzerinden ilerleyelim. Bilgisayar yaratmanın uzun bir işlem olduğunu düşünelim ve Cloneable arayüzünü implemente eden bir ComputerPrototype sınıfımız olsun.

ComputerPrototype.java

public abstract class ComputerPrototype implements Cloneable{
    private int ramSize;
    private int graphicCardSize;
    private double cpu;

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    public void showComputer() {
        System.out.println("Ram : " + getRamSize());
        System.out.println("Graphic Card : " + getGraphicCardSize());
        System.out.println("CPU : " + getCpu());
    }

    public int getRamSize() {
        return ramSize;
    }

    public void setRamSize(int ramSize) {
        this.ramSize = ramSize;
    }

    public int getGraphicCardSize() {
        return graphicCardSize;
    }

    public void setGraphicCardSize(int graphicCardSize) {
        this.graphicCardSize = graphicCardSize;
    }

    public double getCpu() {
        return cpu;
    }

    public void setCpu(double cpu) {
        this.cpu = cpu;
    }
}

Evet, basit olarak bu sınıfımızda ram, gpu ve cpu ile ilgili bilgiler set ediliyor. Burada önemli olan nokta clone metodur. Ardından Computer sınıfımızı oluşturalım. Bu sınıf ComputerPrototype’ı extend edecek.

Computer.java

public class Computer extends ComputerPrototype {

    public Computer(int ramSize, int gpuSize, double cpu) {
        setCpu(cpu);
        setGraphicCardSize(gpuSize);
        setRamSize(ramSize);
    }
}

Görüldüğü gibi parent’ının set metodları çağrılarak Computer oluşturuluyor. İstersek ComputerPrototype ‘ı extend eden farklı özelliklere sahip olan sınıflarda yaratabiliriz. Şimdi gelelim Main sınıfımıza.

Main.java

public class Main {

    public static void main(String[] args) throws CloneNotSupportedException {
        Computer computer = new Computer(8,2,2.2);
        computer.showComputer();

        Computer computer2 = (Computer) computer.clone();
        computer2.setGraphicCardSize(4);
        computer2.setCpu(3.0);
        computer2.showComputer();
    }
}

İlk olarak computer nesnesini yarattık ve özelliklerini gösterdik, ardından clone metodunu kullanarak computer2 nesnemize atadık, set metodlarıyla computer2 nesnemizi şekillendirdik ve özelliklerini showComputer metoduyla ekrana yazdırmış olduk. Basit anlamda Prototype Tasarım kalıbının kullanımı bu şekildedir.

Gerçek ve büyük sistemlerde bir nesnenin yaratma maliyeti çok yüksekse Prototype tercih edilebilir.

Bir yazının daha sonuna geldik böylece 🙂

 

Builder – Tasarım Kalıpları

Merhabalar, bu yazımda Oluşturucu Tasarım Kalıplarından Builder Tasarım Kalıbına değineceğim. Builder, nesne üretim sürecinde değişik parçalar birleştirilip istenilen tipte nesne oluşumunu amaçlamaktadır. Klasik olarak Java’da bir nesne oluşturmak istediğimizde aşağıdaki kod bloklarına benzer şekilde nesnemizi oluştururuz.

Person person = new Person();
Person person2 = new Person("Ufuk", "Halis", 25);

Görüldüğü gibi Person sınıfı 2 tane constructer’a sahip ve nesne oluşturmak istendiği zaman bu ikisinden birini tercih etmek zorundayız. Peki ya bu sınıfta sadece Ad ve Soyad geçecek biçimde nesne oluşturmak istersek, evet yolu basit gidip bu iki parametreli yeni constructer’ı Person sınfında yaratmak. Ancak gereksinimler iyice değiştiği zaman ne olacak, Ad-Yaş, Soyad-Yaş gibi. Person sınıfı constructer’dan geçilmeyecek 🙂 İşte builder bu durumda yardımımıza giriyor. Nesnemizi oluştururken sadece set etmek istediğimiz alanları ayarlıyoruz ve nesnemizi yaratıyoruz. Hem kodun okunuşu bakımından hem de esnekliği bakımından daha iyi bir hale gelmiş oluyor. Person sınıfımızı Builder pattern’e uygun olacak şekilde tasarlayalım.

Person.java

public class Person {
    private String firstName;
    private String lastName;
    private int age;
    private String address;
    private String telephone;

    public static class Builder {
        private Person person;

        public Builder() {
            person = new Person();
        }

        public Builder setAddress(String address) {
            person.address = address;
            return this;
        }

        public Builder setAge(int age) {
            person.age = age;
            return this;
        }

        public Builder setFirstName(String firstName) {
            person.firstName = firstName;
            return this;
        }

        public Builder setLastName(String lastName) {
            person.lastName = lastName;
            return this;
        }

        public Builder setTelephone(String telephone) {
            person.telephone = telephone;
            return this;
        }

        public Person build() {
            return person;
        }
    }

}

Main.java

public class Main {

    public static void main(String[] args) {
        Person person = new Person.Builder().
                        setFirstName("Ufuk").
                        setLastName("Halis").
                        setAge(25).build();
        Person person2 = new Person.Builder().build();
    }
}

Görüldüğü gibi Person sınıfında bir Builder sınıfı yarattık ve Person sınıfının sahip olduğu değerleri bu Builder sınıfı içerisinde set lemiş olduk. Person sınıfındaki tüm değerlerimiz optional bir bakıma, bazı durumlarda Builder ile bir nesne yaratmak istiyoruz ancak olmazsa olmaz başlangıç değerleri istiyorsak, bunuda Builder’ın constructer’ında yapabiliriz. Böylece o alanlar required hale gelir.

Builder Tasarım kalıbı, karmaşık nesne oluşturma süreçlerinden kurtararak değişik parametreler ile nesne oluşturmak istenildiğinde kullanılması tercih edilir.

Bir yazının daha sonuna gelmiş bulunuyoruz böylelikle 🙂

Batsy Restful Services Framework – PreRelease Yayında v0.0.1

Merhabalar, son bir haftadır uğraştığım bir Restful Service framework’nün ilk halini yayınlamış bulunuyorum. 🙂 İlerisi için de aklımda güzel planlar var(Eclipse ve Intellij plugin vb.). Şu aralar biraz dökümantasyon ve refactoring olarak geçiyor. Şuan single jar şeklinde projenize ekleyebilirsiniz. Tabi ki Maven Repo’da da yerini alacaktır. Detaylı bilgileri vs. projenin sitesinden öğrenebilirsiniz.

https://ufukhalis.github.io/batsy/

BatsyLogo