Problema di design della classe

Una risposta parziale, che affronta i punti chiave della tua domanda:

• Each class will know (have defined by default) the classes that are directly contained within them

Una classe dovrebbe conoscere le altre classi solo nella misura necessaria per fare il suo lavoro. Se tutto ciò di cui hai bisogno è generare un documento XML che potrebbe essere piccolo come un costruttore, un metodo loadFromDatabase() per compilare i campi e un metodo toXML() per creare i frammenti XML di cui avrai bisogno. Tutto il resto è meglio conservarlo privato, incluso tutto ciò che è necessario per far funzionare il costruttore e i metodi pubblici.

• Each class will have a process() function that will add itself and its childeren to the XML document we are creating

Un approccio migliore sarebbe una classe Person (che corrisponderebbe al livello superiore dell'XML desiderato) con un metodo toXML() che restituisce il documento XML completo, facendo così chiamando i metodi toXML() del bambini e componendo i frammenti come appropriato.

Alcuni suggerimenti per costruire il grafico dell'oggetto:

Come hai detto, per popolare gli oggetti dovresti passare una struttura dati attraverso la gerarchia degli oggetti. Ma questo è vero solo se costruisci il grafico dall'alto verso il basso.

Un approccio migliore sarebbe quello di costruirlo dal basso verso l'alto usando, ad es. una fabbrica (l'esempio è scritto in Java):

public class Person {
    private String name;
    private int age;
    private Address address;
    private List<Relatives> relatives;        

    public Person(String name, int age, Address address, List<Relatives> relatives) {
        this.name = name;
        this.age = age;
        this.address = address;
        this.relatives = relatives;        
    }
}

public class Address {
    String street;
    String city;
    String state;

    public Address(String street, String city, String state) {
        this.street;
        this.city;
        this.state;
    } 
}

public interface Relative {
}

public interface Parent extends Relative {
}

public class Mother implements Parent {
    private String name;

    public Parent(String name) {
        this.name = name;
    }
}

// and some more classes; this is left as an exercise to the reader ;)

public class PersonFactory {
    public static Person newPerson() {
        // create the address       
        Address addr = new Address("100 Main St.", "Sylvania", "OH");
        // create the list of parents
        List<Parent> parents = new List<Parent>();
        parents.add(new Mother("Jane Doe"));
        parents.add(new Father("Jane Doe"));
        List<Sibling> siblings = new List<Siblings>();
        // analogue to parents

        List<Relatives> relatives = new List<Relatives>();
        relatives.add(parents);
        relatives.add(siblings);
        // now create the person and return him

        return new Person("John Doe", 21, addr, relatives);
    }
}

Il passaggio delle dipendenze dirette tramite il costruttore viene chiamato dependecy injection. Questo può essere ottenuto manualmente (ad esempio usando le fabbriche) o usando le librerie come Spring o Juice (in Java).

(L'unica responsabilità di PersonFactory è la costruzione del grafico dell'oggetto).