Hilfe bei Programmstrukturierung

[Gayson]

Hallo

Ich habe drei Datenstrukturen (Employee, Shift, FreeDay), die alle das gemeinsame Interface Data haben:

interface Data{
	String getName();
	int getID();}

Für jede Struktur habe ich habe ich eine Klasse geschrieben, die eine Liste von einer Struktur abspeichern und wieder einlesen kann (als XML-Datei auf die Platte):

class ShiftAccessor{
	public void write (Shift[])
	public Shift[] read()
	private load()
	private save()}

class EmployeeAccessor{
	public void write (Employee[])
	public Employee[] read()
	private load()
	private save()}

class FreeDayAccessor{
	public void write (FreeDay[])
	public FreeDay[] read()
	private load()
	private save()}

alle read und write-Methoden haben unterschiedliche Implentierungen, load und save ist überall gleich

Nun möchte ich einen "allgemeinen" Container schreiben, der mit Hilfe von Generics genauer Spezifiziert werden kann.

class DataContainer<Type extends Data> {
	void add(Type)
	void remove(Type)
	void save(Type)
	void read()
	int getUnusedID
}

Meine Frage ist:
abhängig davon, was Type ist, muss in save bzw. read ShiftAccessor, EmployeeAccessor oder FreeDayAccessor instanziert werden - doch wie bekomm ich das hin?
Danke!!

 

[Beni]

Kannst du nicht den Teil des Codes, der den Unterschied ausmacht, in die "Data"-Implementierungen reinschreiben? Dann wären die Accessor's überflüssig.

Ansonsten, wenn du überall Generics verwendest, müsste doch bereits beim Code schreiben klar sein, welcher Accessor erwartet wird? ???:L Nenn mir mal ein Beispiel, wo das nicht der Fall ist (und das auch Sinn macht :wink: ).

Da die Generics zur Laufzeit unbekannt sind, müsstest du sonst irgendwo zusätzliche Informationen in deinen Code schreiben. Aber mir fällt kein Beispiel ein, wo das auftritt. :bahnhof:

 

[Gayson]

Mh, scheint ja wirklich so einfach zu sein und einfach die Methoden in den Accessors in die Datenstrukturen selber zu schreiben. Gute Idee. Dann müsste es wahrhscheinlich auch mit dem Container klappen...

Danke!

 

[Gayson]

Ich habe jetzt die read() und write()-Methode in das Data-Interface mit rein genommen:

import java.util.LinkedList;

public interface Data<Type>{
	public String getName();
	public int getID();
	public void write(LinkedList<Type> list);
	public LinkedList<Type> read();
}

Gibt es eine Möglichkeit, write und read static zu setzen?
Ich würde gerne die Methoden z.B. per Employee.read() nutzen...

 

[Gayson]

Tschuldigung, aber ich muss nochmal was wissen, habe es mit dem static noch nicht hinbekommen.
Wollte es mal probieren, die Klasse Data abstract zu schreiben:

import java.util.LinkedList;

public abstract class Data<Type> {
	protected String name;
	protected int id;
	
	public String getName(){
		return name;
	}
	
	public int getID(){
		return id;
	}
	
	// must be overwritten
	public static void write(LinkedList<Type> list){}
	public static LinkedList<Type> read(){return null;}
}

Jetzt müssen halt nur Employee, Shift und FreeDay von Data erben und write bzw read überschreiben.
Ich erhalte jedoch eine Fehlermeldung bei Type bei jeder LinkedList:
Cannot make a static reference from a non-static context.
Ich könnte das Ganze natürlich nicht generisch machen, doch dann müsste ich ja jedesmal casten...
Wie mach ich das?

 

[Beni]

Da man static-Methoden nicht überschreiben kann, funktioniert das nicht.

Wie wäre es mit einer Factory "interface DataFactory<Type>", die die Elemente liest? Ich meine, irgendwann musst du ja sowieso bestimmen, obs jetzt Employee, Shift oder FreeDay ist. Da könntest du die Factory hinsetzen.

 

[Gayson]

Habe mir mal kurz was zum Konzept einer Factory durchgelesen, habe aber noch nicht ganz verstanden, was das mir helfen soll.
Was für Methoden sollen denn deiner Meinung in dem Factory-Interface stehen? Müsste davon denn nicht eine static sein, was ja nicht geht? Und soll das Interface für Employee, Shift und FreeDay sein?

 

[Beni]

Hmpf, nachdem ich nochmal das ganze durchgelesen habe... dann wären wir wieder bei deinem ersten Vorschlag. Hab ich mich im Kreis gedreht...

[Edit: wieso eigentlich static? Beim Schreiben musst du für jede Liste dasselbe machen, und die Datenspeziefischen Elemente passen schon in ein Data hinein. Beim Lesen geht es nur darum, den richtigen Typ zu finden. Aber das ist ein anderes Thema, weil dieser Schritt auf jeden Fall gemacht werden muss.]

 

[Gayson]

Äh, was war mein erster Vorschlag?

 

[Beni]

Die Accessoren, die sind eigentlich auch nur Factories.

Wieso eigentlich static? Beim Schreiben musst du für jede Liste dasselbe machen, und die Teile die unterschiedlich sind, passen in Employee etc. rein. Beim Lesen geht es nur darum, den richtigen Typ zu finden. Aber das ist ein anderes Thema, weil dieser Schritt auf jeden Fall gemacht werden muss.

Ich hatte bei den Factories in die Richtung gedacht:

write( List<Data> list ){
  for( Data data : list ){
    write( "bla bla element x, sowieso und dort" );
    write( data.getTyp() );  // "employee" für Employee, etc...
    data.write();
  }
}

interface Factory<T>{
  public T create();
}

Map<String, Factory<Data>> factories = new Hashtable...

factories.put( "employee", 
  new Factory<Employee>(){
    Employee create(){ return new Employee(); }
  });

factories.put( "freeDay", 
  new Factory<FreeDay>(){
    FreeDay create(){ return new FreeDay(); }
  });

List<Data> read(){
  List<Data> list = new LinkedList<Data>();

  for( .. ){
    String typ = read();
    Data data = factories.get( typ ).create();
    data.read();
    list.add( data );
  }
}

 

[Bleiglanz]

nur mal zur Klarstellung

du kannst von generischen Typen keine neuen Instanzen erstellen (mit new T()), das geht prinzipiell nicht

Lösung A) factories, die für jede Konkrete Klasse das entsprechende neue Objekt zurückliefern [muss man natürlich für jede eigens implementieren]

Lösung B) per Reflection, dann musst du aber der entsprechenden Methode noch x.getClass() als Parameter übergeben, damit du zur laufzeit überhaupt weisst, was du instanzieren willst

 

[Gayson]

Hallo, ich bins nochmal.

Bin grad dabei, Beni's Idee zu verstehen. Komm an enigen Stellen nicht weiter, hier das, soweit ich bin:

Ziel: für FreeDay, Employee und Shift (Interface Data) soll es einen generischen Container geben.

Im Container soll ich factories verwenden:

public class Container<Type extends Data> {
	Map<String, Factory<Type>> factories = new Hashtable<String, Factory<Type>>(3);

	public Container(){
		factories.put( "employee",
		  new Factory<Employee>(){
		    Employee create(){ return new Employee(); }
		  });

		factories.put( "freeDay",
		  new Factory<FreeDay>(){
		    FreeDay create(){ return new FreeDay(); }
		  }); 
		  
		factories.put( "Shift",
		  new Factory<Shift>(){
		    Shift create(){ return new Shift(); }
		  }); 
	}

	public List<Type> read(){
		List<Type> list = new LinkedList<Type>();

		for( .. ){
			String typ = read();
			Type data = factories.get( typ ).create();
			data.read();
			list.add( data );
		}
	}
	
	public write( List<Type> list ){
		  for( Type data : list ){
		    write( "bla bla element x, sowieso und dort" );
		    write( data.getTyp() );  // "employee" für Employee, etc...
		    data.write();
		  }
	}
}

Folgendes verstehe ich nicht:
1. String typ = read(), wo/wie soll diese read() implementiert sein? Und das write in der write()-Methode?
2. for( Data data : list ), was soll das machen?

Hatte mir überlegt, falls ich nicht verstehe, wie du dass machen willst, einfach den Typ per Konstruktur zu übergeben, also dass ein Aufruf z.B. per
Container<Employee> c = new Container<Employee>("employee")
nur möglich ist...

 

[Beni]

Zu 2: ist eine Kurzform, für alle Elemente durchgehen. Gibts ab Java 1.5.

Zu 1: k.A, ich weiss ja nicht, woraus du liest. Wo auch immer du rausliest, lies einen früher reingeschriebenen String raus.

Der Trick später ist einfach: mit dem String schaut man in einer Tabelle nach, welche Factory zu ihm gehört, und ruft die "create" Methode dieser Factory auf.
Eigentlich steht in dieser Tabelle für jeden String-Typ, welcher Konstruktor von welcher Klasse verwendet werden soll.

 

[Gayson]

Okay, dann bleibt mir wohl es nicht anderes übrig, entweder ganz auf einen generischen Container zu verzichten und einen für alle drei Typen anzulegen oder halt für einen Container so immer einen Aufruf zu machen:
Container<Employee> c = new Container<Employee>("employee")

Kannst du mir sagen, warum ich bei

      factories.put( "employee",
        new Factory<Employee>(){
          Employee create(){ return new Employee(); }
        });

folgende Fehlermeldung erhalte:

The method put(String, Factory<Type>) in the type Map<String,Factory<Type>> is not applicable for the arguments (String, new Factory<Employee>(){})

 

[Beni]

Nein, weiss nicht wieso. Aber das hier sollte gehen:

class Container {
    Map<String, Factory<Data>> factories = new Hashtable<String, Factory<Data>>(3);

    public Container(){
       factories.put( "employee",
         new Factory<Data>(){
           public Employee create(){ return new Employee(); }
         });

Halt Employee durch Data ersetzt. Ist ja auch egal, man weiss sowieso bald nichtmehr, was es ist.

 

[Gayson]

Ja. das funktionerte.

Denke, dass ich jedoch folgende Implementation verwenden werden, auch wenn die nicht ganz schön ist...

public class Container<Type extends Data>{
   Data data;

   public Container(String type){
		if(type.equals("employee"))
			data=new Employee();
		else if(type.equals("shift"))
			data=new Shift();
		else if(type.equals("employee"))
			data=new FreeDay();
   }

   public LinkedList<Type> read(){
	   return (LinkedList<Type>)data.read();
   }
   
   public void write( LinkedList<Type> list ){
        data.write(list);
   }
}