Overførsel af objekter via netværk.

du må kunne bruge en ObjectOutputStream og så writeObject( Object obj ). Husk objektet skal være serialiseret og kendt i begge ender.

Hvordan ved klienten hvilke objekter der kommer ?

den skal vel bruge samme socket til anden comm

Client server muligheder:
1)  RMI
2)  ObjectXxxxxxStream og sockets
3)  CORBA
4)  EJB
5)  manuelt serialiseret over HTTP
6)  SOAP over HTTP (web service)

Jeg tror at #2 passer bedst til dine krav.

Java (fra 1.4) indeholde både DOM og SAX parsere som sagtens kan parse
XML, men hvorfor ikke en simpel serialisering ?

Et serialiseret objekt indeholder ikke kun klassens data felter men
også oplysninger om hvilken klasse det er, så du skriver et objekt i
den ene ende og så kan du læse det i den anden ende.

Det er dog praktisk at vide havd det er fordi så kan du typecaste det
Objec readObjec returnerer til noget så du kan kalde metoder direkte.
Reflection er ludt bøvlet.

Kan ikke se hvordan klienten ved hvad der kommer.

Serveren skal kunne lave callbacks til klienterne, med opdateringer.
men klienten skal også kunne udføre kommandoer på serveren.

Kunne evt. lave RMI til client->server og Objectstream til callbacks.
men klienten skal vel stadig vide hvad der kommer for at kunne classcaste det ?

Hvis du vil lave en manuel serialisering til en streng, så kan du bruge følgende teknik:

import java.util.*;
import java.io.*;
import java.net.*;

public class SerializeToString {
    public static void main(String[] args) throws Exception {
        Vector v = new Vector();
        v.add(0,new Integer(123));
        v.add(1,new String("abc"));
        String s = encode(v);
        Vector v2 = (Vector)decode(s);
        System.out.println((Integer)v2.get(0));
        System.out.println((String)v2.get(1));
    }
    private static String encode(Object o) throws Exception {
        ByteArrayOutputStream ba = new ByteArrayOutputStream(1000);
        ObjectOutputStream oba = new ObjectOutputStream(ba);
        oba.writeObject(o);
        return hexify(ba.toByteArray());
    }
    private static Object decode(String s) throws Exception {
        ByteArrayInputStream ba = new ByteArrayInputStream(dehexify(s));
        ObjectInputStream oba = new ObjectInputStream(ba);
        return oba.readObject();
    }
    private final static String hexValue[] = { "0", "1", "2", "3",
        "4", "5", "6", "7",
        "8", "9", "A", "B",
        "C", "D", "E", "F"};
    private static String hexify(byte[] ba) {
        StringBuffer sb = new StringBuffer();
        for(int i = 0; i < ba.length; i++) {
          sb.append(hexValue[(ba[i] >> 4) & 0x0F]);
          sb.append(hexValue[ba[i] & 0x0F]);
        }
        return sb.toString();
    }
    private static byte[] dehexify(String s) {
        int l = s.length() / 2;
        byte[] res = new byte[l];
        for(int i = 0; i < l; i++) {
          res[i] = (byte)Integer.parseInt(s.substring(2*i, 2*i+2), 16);
        }
        return res;
    }
}

Så kan jeg lave det i Corba ved at dens metoder sender en string og modtageren ved hvad type det er ?

Man kan altid bruge reflection til at operere på ukendte objekter.

men det lyder i mine ører som om du har brug for det GoF pattern
der hedder Command Pattern.

Du laver en abstrakt basis klasse med en metode execute. Så for hver
kommando serveren skal kunde sende til client extender din basis
klasse og override execute med noget. De sende så til client. Client
typecaster til basis klassen og udfører execute metoden.

Ovenstående kode kan serialisere ethvert Java objekt til en
printbar streng.

Typecast problematikken er præcis den samme som med writeObject/readObject.