Implementazione del modello Composite e Observer

Sto imparando i pattern di progettazione Composite e Observer e ho creato una classe FileSystem in cui definisco Nodo, Cartella e File come una relazione composita. Ora voglio implementare il pattern Observer così quando c'è un osservatore FileBrowser / Finder / File Explorer possono essere aggiornati quando aggiungo un file a una cartella. Questa è la mia relazione e il mio codice:

Imcheimplemental'InterfacciaOggettoperNodo(Componente)enellastessaDirectoryhoimplementatoimetodiOggetto:attach,dettachenotifyObservers.Èunbuondesign?Cosafaresedesideroriceverenotificheperlacartellaelesottocartelle?devopassareognidirectoryalmioosservatorediFileBrowser?Sesimodificaunfile,potrebbeesserenecessarioduplicareilcodicechesignificaaggiungereattach,dettachenotifyObserversallamiaclasseFile?.

publicclassSolutionMain{publicstaticStringBufferg_indent=newStringBuffer();publicstaticvoidmain(String[]args){Noderoot=FileSystem.getFileSystem();Nodeone=newDirectory("dir1");
        Node two = new Directory("dir2");
        Node thr = new Directory("dir3");
        Node a = new File("a", 100);
        Node b = new File("b", 200); 
        Node c = new File("c", 200); 
        Node d = new File("d", 400);
        Node e = new File("e", 10);

        new FileBrowser(root);
        root.add(one);
        root.add(two);
        one.add(a);
        one.add(two);
        one.add(b);
        two.add(c);
        two.add(d);
        two.add(thr);
        thr.add(e);
    }

}

FileBrowser

public class FileBrowser extends Observer {

    private static int observerIDTracker = 0;
    private int observerID;
    private Subject subject;

    public FileBrowser (Subject subject) {
        this.subject = subject;
        this.observerID = ++observerIDTracker;
        System.out.println("New observer "  + this.observerID);
        // Attach observer in this case FileBrowser
        this.subject.attach(this);
    }

    public void update() {
        Node d = (Directory) subject;
        d.display();
    }


}

Directory

public class Directory extends Node{

    private String _name;
    private ArrayList<Node> _children = new ArrayList<Node>();
    private ArrayList<Observer> _observers = new ArrayList<Observer>();

    public Directory(String name) { _name = name; }

    public void name(String name) { _name = name; }

    public String name() { return _name; }

    public void add(Node obj) { 
        _children.add(obj); 
        notifyAllObservers();
    }


    public void display() { System.out.println("Directory: " + _name + " changed"); }

    public void attach(Observer observer){
          _observers.add(observer);     
    }

    public void detattach(Observer observer){
          _observers.remove(observer);      
    }

    public void notifyAllObservers(){
          for (Observer observer : _observers) {
             observer.update();
          }
    } 
}

La notifica funziona, ma ci si chiede se questa sia una buona implementazione dell'osservatore.

Ho trovato un esempio online in cui è presente un modello di Mediator e c'è un'implementazione di questa classe , ma non sei sicuro di quali sono i vantaggi?