Welcome to My Blog 👋

• Figma rakibi olan Sketch'e göre tüm platformlarda çalışabilir. Yani isterseniz bir tarayıcıda açabilirsiniz, mac bilgisayarınıza indirip kurabilirsiniz veya windows makinenizde de rahatlıkla kullanabilirsiniz. Sketch ise sadece mac'lerde kullanılabilen bir arayüz tasarım aracıdır.
• Figma neredeyse tamamen ücretsiz bir araçtır. Eğer profesyonel bir ekip ile sekronize bir şekilde bir proje üzerinde çalışmak istiyorsanız ücret ödemeniz gerekiyor. Bunun dışında tüm özellikleri ücretsizdir. Sketch'i ise yıllık olarak 99 dolar gibi bir ücret ödeyerek kullanabiliyorsunuz.
• Figma bir proje üzerinde ekibinizle sekronize bir şekilde çalışabilmenize imkan sağlıyorken Sketch ile bunu şimdilik yapamıyorsunuz.
• Figma ile yaptığınız tasarımları kolaylıkla arkadaşlarınız ile paylaşabiliyorsunuz ve arkadaşlarınız Figma üzerinden bu tasarımı görüntüleyebiliyor.
• Sketch ile oluşturduğunuz tasarımları Figma destekliyor. Yani daha önceden Sketch ile yaptığınız tasarıma Figma ile devam edebilirsiniz.
• Figma ile yaptığınız tasarımların farklı ekran boyutlarında nasıl görüneceğini kolaylıkla test edebilirsiniz.
• Bileşen kütüphanesi oluşturabilirsiniz. Örneğin bir kaç buton tasarımı yaptınız ve projenizde bu butonların kullanılması gerekiyor. Bu tasarımı kütüphane haline getirerek arkadaşlarınız ile paylaşabilir ve onlarında aynı butonları kullanmasını sağlayabilirsiniz.

• Drawable : Görseller için kullanılır.
• Raw : Medya dosyaları (ses, video) için kullanılır. 
• Values : Genel değerler için kullanılır. Stringler, boyutlar, stiller, renkler vs.
• Menu : Menü dosyaları için kullanılır.
• Layout : Ekranlarımızın tasarım dosyaları için kullanılır.
• Anim : Animasyon dosyaları için kullanılır.

• Bağımlılıkların somut bir şekilde belirlenmesi yerine dışarıdan soyut bir şekilde belirlenmesi
• Kaynak kodda değişikliğe ve yeniden derlemeye ihtiyaç duyulmaması
• Bakımın ve güncellemelerin daha kolay yapılabilmesi
• Bağımlılıkların tek bir noktada tasarlanması ve yönetilmesi
• Bağımlılıklardan dolayı oluşan hataların en aza indirilmesi

interface IYazdir {
    
    public void yazdir();
}

class Excel implements IYazdir {
    
    public void yazdir() {
        System.out.println("Excel ile yazdırıldı!");
    }
}

class PDF implements IYazdir {
    
    public void yazdir() {
        System.out.println("PDF ile yazdırıldı!");
    }
}

class AySonuRaporu{
    
    IYazdir yazdirma;
    
    public AySonuRaporu(IYazdir yazdirma) {
        this.yazdirma = yazdirma;
    }
    
    public void aySonuRaporuCiktiAl() {
        yazdirma.yazdir();
    }
}

public class Test{

     public static void main(String []args) throws Exception{
         
        //Configurasyon dosyasından belirlediğimiz tür dışarıdan alınır
        //Alınan tür nesneye enjekte edilir
        //Burada configurasyon dosyasından okuma işlemleri yapılabilir
        //Ancak bu işin kalıplaşmış frameworkleri vardır. Örn spring
        //Spring burada bizim için configurasyonda belirttiğimiz türü enjekte eder
        //Konfigurasyon dosyasında türü pdf veya excel olarak değiştirerek kodda herhangi bir değişiklik yapmadan güncelleme yapabiliriz.
        //Örneğin bir word tipi eklendiğinde Word sınıfı yazılır ve konfigurasyon dosyasında tip word seçilir
        //Hiç bir kod değişikliği yapılmadığı için çok az test ihtiyacı doğar
        AySonuRaporu aySonuRaporu = new AySonuRaporu(new PDF());
        aySonuRaporu.aySonuRaporuCiktiAl();
     }
}

PDF ile yazdırıldı!

• Component arayüzü iç içe bulunacak varlıklar için bir arayüz oluşturur ve operation metodu ortak işlemler için kullanılacak metotları temsilen yazılmıştır. Örneğimizde genel ön yüz elemanlarının arayüzüdür.
• Composite sınıfı içerisine alt varlıklar alabilecek sınıfları temsil eder. Örneğimizde window sınıfıdır.
• Leaf sınıfı içerisine bir alt varlık eklenemeyecek olan sınıfları temsil eder. Örneğimizde image sınıfıdır.

import java.util.ArrayList;

abstract class Component {
    protected String name;
    protected Boolean isParent;
    protected Component parent;
    protected ArrayList children;
    
    protected Component(String name, Boolean isParent) {
        this.name = name;
        this.isParent = isParent;
        if(isParent) {
            children = new ArrayList<>();
        }
    }
    
    public void add(Component component) throws Exception {
        if(isParent) {
            children.add(component);
        } else {
            throw new Exception("Bu işlem desteklenmiyor");
        }
    }
    
    public void remove(Component component) throws Exception {
        if(isParent) {
            children.remove(component);
        } else {
            throw new Exception("Bu işlem desteklenmiyor");
        }
    }
    
    public abstract void resize();
}

class Panel extends Component {
    
    public Panel(String name) {
        super(name, Boolean.TRUE);
    }
    
    public void resize() {
        System.out.println(name + " panelinin boyutu değişti!");
        if(!children.isEmpty()) {
            for(Component component : children) {
                component.resize();
            }
        }
    }
}

class ImageView extends Component {
    
    public ImageView(String name) {
        super(name, Boolean.FALSE);
    }
    
    public void resize() {
        System.out.println(name + " resminin boyutu değişti!");
    }
}

public class HelloWorld{

     public static void main(String []args) throws Exception{
        Panel panel = new Panel("Panel1");
        ImageView image1 = new ImageView("Image1");
        ImageView image2 = new ImageView("Image2");
        panel.add(image1);
        panel.add(image2);
        panel.resize();
     }
}

Panel1 panelinin boyutu değişti!
Image1 resminin boyutu değişti!
Image2 resminin boyutu değişti!

• Facade sınıfı kullanacağı alt birimleri kendi içerisinde barındırır.
• Facade sınıfı genellikle singleton pattern'ı ile tanımlanır.
• Facade sınıfının alt birimleri factory metotlar ile dışarıya açılabilir.

class Facade {
    
    private AltSistem1 altSistem1;
    private AltSistem2 altSistem2;
    private static Facade facade;
    
    private Facade() {
        altSistem1 = new AltSistem1();
        altSistem2 = new AltSistem2();
    }
    
    public static Facade getFacade() {
        if(facade == null) {
            facade = new Facade();
        }
        return facade;
    }
    
    public void altSistem1IslemleriYap() {
        altSistem1.islem1();
        altSistem1.islem2();
    }
    
    public void altSistem2Islem1Yap() {
        altSistem2.islem1();
    }
}

class AltSistem1 {
    
    public void islem1() {
        System.out.println("Alt Sistem 1 İslem 1 yapıldı");
    }
    
    public void islem2() {
        System.out.println("Alt Sistem 1 İslem 2 yapıldı");
    }
}

class AltSistem2 {
    
    public void islem1() {
        System.out.println("Alt Sistem 2 İslem 1 yapıldı");
    }
}

public class Test {

     public static void main(String []args){
        Facade facade = Facade.getFacade();
        facade.altSistem1IslemleriYap();
        facade.altSistem2Islem1Yap();
     }
}

Alt Sistem 1 İslem 1 yapıldı
Alt Sistem 1 İslem 2 yapıldı
Alt Sistem 2 İslem 1 yapıldı

• Adapter arayüzü ve bu arayüzü implement eden adapter sınıflarını tanımlarız. Bu adapter sınıfları iki sınıf arasındaki farklılıkları çözen sınıflardır. İhtiyacımız doğrultusunda istediğimiz kadar tanımlarız.
• Adapter sınıfları içinde adapte edecekleri nesneleri barındırırlar.
• Client sınıfları adapter arayüzü ile iki nesneyi adapte edebilirler.

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

class Insan {
    String ad;
    String soyad;
    
    public Insan(String ad, String soyad) {
        this.ad = ad;
        this.soyad = soyad;
    }
    
    public String getAd() {
        return ad;
    }
    
    public String getSoyad() {
        return soyad;
    }
}

class ListView {
    List<ListViewModel> listViewModelList;
    
    public ListView(List<ListViewModel> listViewModelList) {
        this.listViewModelList = listViewModelList;
    }
    
    public void goster() {
        for(ListViewModel model : listViewModelList) {
            System.out.println("Baslik : " + model.getBaslik());
            System.out.println("Aciklama : " + model.getAciklama());
        }
    }
}

class ListViewModel {
    String baslik;
    String aciklama;
    
    public ListViewModel(String baslik, String aciklama) {
        this.baslik = baslik;
        this.aciklama = aciklama;
    }
    
    public String getBaslik() {
        return baslik;
    }
    
    public String getAciklama() {
        return aciklama;
    }
}

interface Adapter {
    public void get();
}

class ListViewInsanAdapter implements Adapter {
    List<Insan> insanList;
    
    public ListViewInsanAdapter(List<Insan> insanList) {
        this.insanList = insanList;
    }
    
    public List<ListViewModel> get() {
        List<ListViewModel> listViewModelList = new ArrayList<>();
        for(Insan insan : insanList) {
            ListViewModel model = new ListViewModel(insan.getAd(), insan.getSoyad());
            listViewModelList.add(model);
        }
        return listViewModelList;
    }
}

public class Test {

     public static void main(String []args){
        Insan insan = new Insan("Berkay","Demirel");
        Insan insan2 = new Insan("Deneme","Insan");
        List<Insan> insanList = new ArrayList<>();
        insanList.add(insan);
        insanList.add(insan2);
        Adapter adapter = new ListViewInsanAdapter(insanList);
        ListView listView = new ListView(adapter.get());
        listView.goster();
     }
}

Baslik : Berkay
Aciklama : Demirel
Baslik : Deneme
Aciklama : Insan

• Component sınıfı ek özellik ekleyeceğimiz sınıfın arayüzü olmalıdır. Örneğimizde bu şekil arayüzüne denk gelmektedir.
• ConcreteComponent sınıfı component arayüzünü implement eden ek özellik ekleyeceğimiz sınıflardır. Örneğimizde kare, daire gibi sınıflara denk gelmektedir.
• Decorator sınıfımız bu patern'daki işlemleri yerine getirecek saf sanal sınıfımızdır. Bu sınıf ek özellik ekleyeceğimiz sınıfların arayüzünü implement etmeli ve ek özellik eklenecek nesneleri içermelidir.
• ConcreteDecorator sınıfımız ek özellik ekleyeceğimiz nesnemize ekleyeceğimiz özellikleri belirttiğimiz sınıfımızdır.

interface Sekil {
    
    public void ciz();
}

class Kare implements Sekil {
    
    public void ciz() {
        System.out.println("Kare çizildi");
    }
}

class Daire implements Sekil {
    
    public void ciz() {
        System.out.println("Daire çizildi");
    }
}

abstract class SekilDecorator implements Sekil {
    protected Sekil decoratedSekil;
    
    public SekilDecorator(Sekil decoratedSekil) {
        super();
        this.decoratedSekil = decoratedSekil;
    }
} 

class BoyaDecorator extends SekilDecorator {
    protected String renk;
    
    public BoyaDecorator(Sekil decoratedSekil, String renk) {
        super(decoratedSekil);
        this.renk = renk;
    }
    
    public void ciz() {
        System.out.println(renk + " boyalı");
        decoratedSekil.ciz();
    }
}

public class Test {

     public static void main(String []args){
        Sekil kare = new Kare();
        kare.ciz();
        Sekil decoratedKare = new BoyaDecorator(new Kare(), "kırmızı");
        decoratedKare.ciz();
     }
}

Kare çizildi
kırmızı boyalı
Kare çizildi

• Bu yöntemi kullanacak client sınıflara bir arayüz görevi görecek Originator sınıfımızı yaratırız. Bu sınıf memento nesnelerinin yani geçmiş durumu tutacak nesneleri yönetmekten sorumludur.
• Nesnemizin geçmiş durumunu saklaması için Memento sınıfını oluştururuz.
• Birden fazla geçmiş saklamak istiyorsak Caretaker sınıfını oluştururuz. Saklayacağımız memento nesnelerini bu sınıf barındırır.

public class Memento {
     public String durum;
}

public class Originator {
     public String durum;
     
     public Memento save() {
         return new Memento(durum);
     }
     
     public String get(Memento memento) {
         return memento.getDurum();
     }
}

public class Caretaker {
    
    final Deque<EmpMemento> mementos = new ArrayDeque<>();
    public Memento getMemento()
    {
        return mementos.pop();
    }
    public void setMemento(Memento memento)
    {
        mementos.push(memento);
    }
}

public class TEST {
    
    public static void main() {
        Originator originator = new Originator("İlk durumum");
        Caretaker caretaker = new Caretaker();
        caretaker.setMemento(originator.save());
        originator.setDurum("İkinci durumum");
        caretaker.setMemento(originator.save());
        String sonDurum = originator.get(caretaker.getMemento);
    }
}

• Context sınıfı bize içeriği yani yorumlanması gereken ifadeyi sağlayan sınıftır.
• Client sınıfı içeriği yorumlayarak işlem yapmak isteyen sınıftır.
• AbstractExpression sınıfı ifadeyi yorumlamak için client sınıflarına sağlanan bir arayüzdür. İfadeyi yorumlayacak sınıflar bu arayüzü implement ederek yöntemlerini uygularlar.
• TerminalExpression ile NonterminalExpression sınıfları arasındaki fark örneğin bir xml elementini yorumlarken bir tag içerisinde bir değer var ise o değeri alıp geriye dönebiliriz. Bu ifade bir terminalExpression'dır. Ancak eğer bir tag içinde bir veya daha fazla tag varsa o tag'in içindeki ifade tekrar yorumlanmak üzere nonterminalExpression sınıfına gönderilmelidir. Bu şekilde içerisindeki değerler döndürülünceye kadar ifade işlenmelidir.

public interface XMLAbstractExpression {

     public String interpret(Context context);
}

public class XmlTerminalExpression implements XMLAbstractExpression {
    
    public String interpret(Context context) {
        //Eğer tag'in içerisinde başka bir tag yoksa ifadeyi döndür
        //Eğer tag'in içerisinde başka bir tag varsa XmlNonterminalExpression'a gönder
    }
}

public class XmlNonterminalExpression implements XMLAbstractExpression {
    
    public String interpret(Context context) {
        //Eğer tag'in içerisinde başka bir tag yoksa ifadeyi XmlTerminalExpression'a gönder
        //Eğer tag'in içerisinde başka bir tag varsa ifadeyi tekrar XmlNonterminalExpression'a gönder
    }
}

public class Context {
    String expression;
}

public class TEST {
    
    public static void main() {
        XMLAbstractExpression xmlExpressionManager = new XmlTerminalExpression();
        Context context = new Context();
        context.setExpression("<note>
                                <to>Tove</to>
                                <from>Jani</from>
                                <heading>Reminder</heading>
                                <body>Don't forget me this weekend!</body>
                                </note>");
        xmlExpressionManager.interpret(context);
    }
}

• Yöntemler için ortak bir arayüz tanımlanır. Bu arayüz saf sanal bir sınıf olur. Bu sınıfın dışarıya açılan bir template metodu olur. Dışarıdan bu yöntemleri kullanacak sınıflar template metot üzerinden erişim sağlarlar. Template metot ile uygun yöntem çalıştırılır.
• Her yöntem için bir sınıf tanımlanır. Bu sınıf ortak arayüz olan saf sanal sınıftan türetme yapılarak oluşturulur. Override edilen metoda uygun yöntem tanımlanır.

public abstract class DokumanYoneticisi {

     public void goruntule() {
         
         //ortak işlemler
         render();
     }
     
     public abstract void render();
}

public class PDF extends DokumanYoneticisi {
    
    public void render() {
        System.out.println("PDF görüntülendi");
    }
}

public class Word extends DokumanYoneticisi {
    
    public void render() {
        System.out.println("Word görüntülendi");
    }
}

public class TEST {
    
    public static void main() {
        DokumanYoneticisi dokumanYoneticisi = new PDF();
        dokumanYoneticisi.goruntule();
    }
}

• Nesnenin her bir durumunda farklı davranış sergileyeceği sınıflar oluşturulur.
• Bu sınıflar ortak bir arayüzü implement ederler.
• İstemci sadece Context sınıfını bilerek yapmak istediği işlemi uygular. Context sınıfı State arayüzünü kullanarak işlemleri uygular.

public interface IKasetCalarState {
    
    public void cal();
    public void durdur();
}

public class KasetCalarContext {
    IKasetCalarState state;
    
    public KasetCalarContext() {
        IKasetCalarState state = new DuruyorState();
    }
    
    public void cal() {
        state.cal();
    }
    
    public void durdur() {
        state.durdur();
    }
}

public class CaliyorState implements IKasetCalarState {
    
    public void cal() {
        System.out.println("Kaset zaten çalınıyor");
    }
    
    public void durdur() {
        System.out.println("Kaset durduruldu");
    }
}

public class DuruyorState implements IKasetCalarState {
    
    public void cal() {
        System.out.println("Kaset çalınmaya başlandı");
    }
    
    public void durdur() {
        System.out.println("Kaset zaten çalınmıyor");
    }
}

public class Test {
    
    public static void main() {
        KasetCalarContext context = new KasetCalarContext();
        context.cal();
        context.durdur();
    }
}

• Yöntemlerimiz için genel bir arayüz sunacak Strategy soyut sınıfı veya arayüzü tanımlanır.
• İşi yaptırmak isteyen nesne sadece bu arayüzü bilir ve kullanır.
• Her bir yöntem için ayrı bir sınıf tanımlanır ve ortak arayüzü implement eder.

public interface Ulasim {
    
    public void git();
}

public class Otobus implements Ulasim {
    
    public void git() {
        System.out.println("Otobüs ile gidildi.");
    }
}

public class Taksi implements Ulasim {
    
    public void git() {
        System.out.println("Taksi ile gidildi.");
    }
}

public class IseGidis {
    private Ulasim ulasim;
    
    public void iseGit() {
        ulasim.git();
    }
}

public class Test {
    
    public static void main() {
        Ulasim otobus = new Otobus();
        Ulasim taksi = new Taksi();
        
        IseGidis iseGidis = new IseGidis();
        iseGidis.iseGit(otobus);
    }
}

• Client nesnesini müşteri nesnelerini kullanacak bir sınıf olarak düşünebiliriz.
• Element arayüzü ise müşteri sınıfı olarak düşünülebilir. Bu arayüzü implement eden nesneler müşteri türlerini oluşturan nesnelerdir.
• Visitor arayüzü ile client nesne kullanmak istediği ek özelliği dinamik olarak element sınıflarına ekleyebilir.

public abstract class Musteri {
    private int id;
    private String ad;
    //...
    public void accept(IVisitor visitor);
}

public class BireyselMusteri extends Musteri {
    public void accept(IVisitor visitor) {
        visitor.visit(this);
    }
}

public class TicariMusteri extends Musteri {
    public void accept(IVisitor visitor) {
        visitor.visit(this);
    }
}

public interface IVisitor {
    public void visit(Musteri musteri);
}

public class KonutKredisi implements IVisitor {
    public void visit (Musteri musteri) {
        if(musteri instanceof BireyselMusteri) {
            //kredi kullandırım işlemleri
        } else if (musteri instanceof TicariMusteri) {
            //kredi kullanılamaz hatası
        }
    }
}

public class Test {
    public static void main() {
        Musteri musteri1 = new BireyselMusteri();
        Musteri musteri2 = new TicariMusteri();
        KonutKredisi konutKredisi = new KonutKredisi();
        musteri1.visit(konutKredisi);
        musteri2.visit(konutKredisi);
    }
}

• Client command arayüzlerini kullanarak işlemlerini yaptırır.
• Receiver nesnesine (ATM) arayüzler tarafından işlemler yaptırılır.
• Invoker nesnesi (Klavye) command arayüzlerini barındırır. Kullanıcıya makineyi kullanması için arayüzler sağlar.

public class ATM{

     public void giris() {
         //işlemler
     }
     
     public void sil() {
         //işlemler
     }
     
     public void onayla() {
         //işlemler
     }
}

public interface Command {
    public void execute();
}

public class GirisCommand implements Command {
    private ATM atm;
    public void execute () {
        atm.giris();
    }
} 

public class SilCommand implements Command {
    private ATM atm;
    public void execute () {
        atm.sil();
    }
}

public class OnaylaCommand implements Command {
    private ATM atm;
    public void execute () {
        atm.onayla();
    }
}

public class Klayve {
    private Command command;
    
    public void setCommand (Command command) {
        this.command = command;
    }
    
    public void tusaBas () {
        command.execute();
    }
}

public class Test {
    public static void main() {
        Klavye klavye = new Klavye();
        Atm atm = new ATM();
        Command girisCommand = new GirisCommand(atm);
        Command silCommand = new SilCommand(atm);
        klavye.setCommand(girisCommand);
        klavye.tusaBas();
        klavye.setCommand(silCommand);
        klavye.tusaBas();
    }
}

• İstekleri karşılayacak ve bir zincir şeklinde işleyecek sınıflar için bir arayüz olan Handler arayüzü tanımlanır. Bu arayüzün istekleri karşılayacak handle metodu yazılır.
• İstekleri yerine getirecek sınıflar Handler arayüzünü implement ederler.
• Client nesne Handler arayüzünü kullanarak istekleri yerine getirecek sınıfları kullanır.

public interface Handler {
    public void handleRequest();
}

public class HandlerConcrete1 implements Handler {
    Handler handler = new HandlerConcrete2();
    public void handleRequest() {
        //işlemler
        handler.handleRequest();
    }
}

public class HandlerConcrete2 implements Handler {
    public void handleRequest() {
        //işlemler
    }
}

public class Client {
    public static void main () {
        Handler handler = new HandlerConcrete1();
        handler.handleRequest();
    }
}

• Birbirleri ile iletişim kuracak nesneler mediator interface'ini barındırırlar ve kullanırlar.
• İletişime özel mediator sınıfları tanımlanır ve mediator interface'i implement edilir.
• Bir nesne diğer nesneler ile iletişim kurmak istediğinde mediator interface'ini kullanarak özel tanımlanan metotlar üzerinden iletişim kurar.

public class IstanbulKule implements Kule{
    public void ucakEkle (Ucak ucak) {
        ucaklar.add(ucak);
    }
    public void ucakCikar (Ucak ucak) {
        ucaklar.remove(ucak);
    }
    public void haberVer (Ucak ucak, String mesaj) {
        ucak.mesajAl(mesaj);
    }
}

public interface Kule {
    ArrayList<Ucak> ucaklar;
    public void ucakEkle(Ucak ucak);
    public void ucakCikar(Ucak ucak);
    public void haberVer(Ucak ucak, String mesaj);
}

public class UcakModel1 {
    public Kule kule = new IstanbulKule();
    public void haberAl (String mesaj) {
        System.out.println("UcakModel1 Haber alındı." + mesaj);
    }
}

public class UcakModel2 {
    public void haberAl (String mesaj) {
        System.out.println("UcakModel2 Haber alındı. " + mesaj);
    }
}

public interface Ucak () {
    public void haberAl(String mesaj);
}

public class Test {
    public static void main () {
        UcakModel1 ucak1 = new UcakModel1();
        UcakModel2 ucak2 = new UcakModel2();
        ucak1.kule.haberVer(ucak2, "Pisti kullanıyorum");
    }
}