modelowanie AST w Javie

DrzewoNaJawie.java

public class DrzewoNaJawie {
    public static void main(String[] args){
        Drzewo d = new WęzełC(new WęzełA(0, 1), new WęzełB("xd"));
        System.out.println("Wynik: " + drzewoDoNapisu(d));
    }

    private static final Odwiedzacz<String> odwiedzaczNapisowy =
        new Odwiedzacz<String>(
                               a -> "[" + a.weźX() + ", " + a.weźY() + "]",
                               b -> "\"" + b.weźNapis() + "\"",
                               c -> "(" + drzewoDoNapisu(c.weźA()) + ", " + drzewoDoNapisu(c.weźB()) + ")");
    
    private static String drzewoDoNapisu(Drzewo d) {
        return d.odwiedź(odwiedzaczNapisowy);
    }
}

interface Drzewo {
    <T> T odwiedź(Odwiedzacz<T> odwiedzacz);
}

final class WęzełA implements Drzewo {
    private final int x;
    private final int y;

    public WęzełA(int x, int y) {
        this.x=x;
        this.y=y;
    }

    @Override
    public <T> T odwiedź(Odwiedzacz<T> odwiedzacz) {
        return odwiedzacz.weżA().wywołaj(this);
    }

    public int weźX() {
        return x;
    }

    public int weźY() {
        return y;
    }
}

final class WęzełB implements Drzewo {
    private final String napis;

    public WęzełB(String napis) {
        this.napis = napis;
    }

    @Override
    public <T> T odwiedź(Odwiedzacz<T> odwiedzacz) {
        return odwiedzacz.weźB().wywołaj(this);
    }

    public String weźNapis() {
        return napis;
    }
}

final class WęzełC implements Drzewo {
    private final Drzewo a;
    private final Drzewo b;
    
    public WęzełC(Drzewo a, Drzewo b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public <T> T odwiedź(Odwiedzacz<T> odwiedzacz) {
        return odwiedzacz.weźC().wywołaj(this);
    }    

    public Drzewo weźA() {
        return a;
    }

    public Drzewo weźB() {
        return b;
    }
}


class Odwiedzacz<T> {
    private final Fn<WęzełA, T> wA;
    private final Fn<WęzełB, T> wB;
    private final Fn<WęzełC, T> wC;
    
    public Odwiedzacz(Fn<WęzełA, T> wA,
                      Fn<WęzełB, T> wB,
                      Fn<WęzełC, T> wC) {
        this.wA = wA;
        this.wB = wB;
        this.wC = wC;
    }

    public Fn<WęzełA, T> weżA() {
        return wA;
    }

    public Fn<WęzełB, T> weźB() {
        return wB;
    }

    public Fn<WęzełC, T> weźC() {
        return wC;
    }
}

interface Fn<A, B> {
    B wywołaj(A a);
}