物件與lambda

物件其實就是使用前需要new的lambda

但

  1. 物件可以有一個以上的function
  2. 可以用繼承來傳function給父類別

Factorys

就是把物件生成抽象化

simple factory

把物件生成的code抽成物件(lambda)

用參數傳function

method factory

把物件生成的code抽成要實作的方法

用override傳function

abstract factory

把所有物件生成的code

  1. 放到物件中
  2. 讓子類別實作

就simple factory+method factory 但實作method從caller本身被抽到另一個物件去

簡介

接著來介紹pattern的替代方案

替代方案: lambda

Strategy

拉一個interface來產生一個給lambda的洞(attribute)

Template Method

拉好幾個abstract method給子類別實做需要用到的method

Bridge

把許多function放在一起

dict with lots of lambda

Observer

存callback函數，再把資料透過callback推送出去

Command

真的就是lambda

替代方案: Rrcursive data type

Decorator

data List = Base | Node A List

就是List的type，但是可能會有許多base

interface layer {
    int eval();
}

class Base implements layer {
    int eval() { return 0;}
}

class add10 implements layer {
    layer next;
    public add10(layer l) {
	next = l;
    }

    int eval() { return 10+next.eval(); }
}

Chain of Responsibility

linked list

abstract class Handler {
    protected Handler next;
    Handler(Handler next) {
        this.next = next;
    }    
    void doNext(char c) {
        if(next != null) {
           next.handle(c);
        }
    }
    abstract void handle(char c);
}

class SymbolHandler extends Handler {
    SymbolHandler(Handler next) {
        super(next);
    }
    void handle(char c) {
        System.out.println("Symbol has been handled");
        doNext(c);
    }
}

public class Main {
    public static void main(String[] args) {
        Handler handler = new SymbolHandler(
                            new CharacterHandler(
                              new DigitHandler(null)));
        handler.handle('A');
        handler.handle('1');
    }
}

(不過看著看著感覺有點monad的味道)

Composite

data Tree = Leaf | Node List<A> List<Tree>

就是Tree的type，但是可能會有許多leaf

Builder

Q: 回傳的都是同一個type，那狀態如何變化? A: 放在attribute

每次set完attribute就回傳Builder，最後再產生物件

State

把State Machine的State變成物件，之後每個State就依據呼叫的method來執行動作，與轉換狀態。

換言之，用linked list的方式實作graph

替代方案: Type constructor

Adapter

就是吃一個type，透過method使用 那就是Type constructor阿

Type + Adapter => another Type

Proxy

與Adapter很像，但轉出來的不是只有一般的type 連帶還有存取的方法 有點像python的decorator

Type + Proxy => methods for Type

想法

Singleton

就是只能有一個物件 那做的方法就有很多了

Prototype

deepCopy

Flyweight

記憶法

Facade

打包成一個函數(或是公開介面)

Iterator

把hasNext與getNext明確出來，可以變成method調用

實做起來很有趣，Tree的Iterator一定要試試看

Interpreter

就是Interpreter，看操作語意可以給你許多啟發

Memento

可以當成物件的序列化與反序列化

保存能代表物件的狀態，之後只要使用這些狀態就能還原出物件

Mediator

很像 Facade, Template Method 都是打包

但 Facade, Template Method 打包的是method Mediator 打包的是 物件

替代方案: pattern matching

Visitor

物件本身的attribute就是函數的參數

size [] = 0
size a:x = 1+size x

interface ListVisitor {// Lambda
    int apply(Base l);
    int apply(Node l);
}

interface List {
    List getNext();
}

class size implements ListVisitor {
    // 其實也可以把ret寫在attribute
    // 這樣就不用回傳type了
    int apply(Base l) { return 0; }
    int apply(Node l) { return 1+l.apply(this); }
}

class Base implements List {
    List getNext() { return null; }

    int apply(ListVisitor f) { return f.accept(this); }
}

class Node implements List {
    List next;
    public Node(List l) {
	next = l;
    }

    List getNext() { return next; }
    int apply(ListVisitor f) { return f.accept(this); }
}