Klassen Cast auf Argumentenklasse via Reflection?

[geqoo]

Hallo,

ich habe hier mal eine Frage zum Thema Reflection.

Ich habe hier einen Konstruktor:

public DatenExport (String name, 
  DatenObj jahr,

  DatenObj halbjahr1,
  DatenObj halbjahr2,

  DatenObj q1,
  DatenObj q2,
  DatenObj q3,
  DatenObj q4) {
    // ...
}

Jetzt kann man ja mittels Reflection die Argumente aus dem Konstruktor holen:

// Konstruktoren holen
Constructor[] constructors = this.getClass().getDeclaredConstructors();
// Argumente holen
Class[] parameterTypes = constructors[0].getParameterTypes();

for (Class param : parameterTypes) {
	// ...
}

Von Seiten der Programmierung ist bekannt, dass alle Objekte nach dem Namen (String) vom Typ "DatenObj" sind. Außerdem sind es recht viele DatenObj-Argumente (ca. 30).

Das Problem was ich jetzt habe ist, dass param immer vom Typ "Class" ist. Ich kann zwar jetzt mit param arbeiten, allerdings keine Methoden der Klasse "DatenObj" aufrufen.

Meine Frage nun: Ist das irgendwie möglich, dass ich das Class-Object von Reflection wieder in den Typ "DatenObj" gecastet bekomme, damit ich wieder Methoden von "DatenObj" aufrufen kann?

Wäre für jede Hilfe dankbar!

 

[Sehales]

Schau die mal Class (Java Platform SE 7 ) an.
yourClassObject.cast(objectToCast) dürfte das sein, was du suchst.

 

[geqoo]

Das habe ich schon probiert.

for (Class clazz : c[0].getParameterTypes()) {
  if (clazz.getName().endsWith("DatenObj")) {
    DatenObj.class.cast(clazz);
  }
}

Allerdings erhalte ich dann immer diese Fehlermeldung: java.lang.ClassCastException(Unknown source).

Übrigens: Um den Fehler im Design an diesem Konstruktor wollen wir hier mal nicht diskutieren.
Ich weiß, dass es blöd gemacht ist, aber ich muss mich an die Vorgabe halten.

 

[anti-held]

Was willst du eigentlich bewirken?
Per Reflection auf die Membervariablen eines vorhandenen DatenExport - Objekts zugreifen oder
per Reflection ein neues Object vom Typ DatenExport mit vorhandenen DatenObj - Objekten erzeugen.

 

[geqoo]

Ich möchte auf die Membervariablen vom DatenExport-Objekt zugreifen, so wie sie dem Konstruktor übergeben werden.

 

[anti-held]

Hier habe ich dir ein kleines Beispiel gemacht für die Reflection

DatenObj Klasse:

public class DatenObj {
	private String name;

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

	public String getName() {
		return name;
	}
	
	@Override
	public String toString() {
		return name;
	}
}

DatenExport Klasse

import java.lang.reflect.Constructor;

public class DatenExport {

	private String name;
	private DatenObj jahr;
	private DatenObj halbjahr;
	private DatenObj halbjahr1;
	private DatenObj p1;
	private DatenObj p2;
	
	public DatenExport(String name,DatenObj jahr, DatenObj halbjahr, DatenObj halbjahr1, DatenObj p1, DatenObj p2) {
		this.name = name;
		this.jahr = jahr;
		this.halbjahr = halbjahr;
		this.halbjahr1 = halbjahr1;
		this.p1 = p1;
		this.p2 = p2;
	}

	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder(name);
		sb.append("\njahr: " + jahr.getName());
		sb.append("\nhalbjahr: " + halbjahr.getName());
		sb.append("\nhalbjahr1: " + halbjahr1.getName());
		sb.append("\np1: " + p1.getName());
		sb.append("\np2: " + p2.getName());
		return sb.toString();
	}
	
}

hier das Reflection zeugs:

public class Main {

	// bestehende DatenObj daten:
	private static DatenObj[] daten = new DatenObj[] { new DatenObj("obj1"), new DatenObj("obj2"), new DatenObj("obj3"), new DatenObj("obj4"),
			new DatenObj("obj5") };

	public static void main(String... args) throws Exception {

		Constructor[] constructors = DatenExport.class.getDeclaredConstructors();
		Class[] parameterTypes = constructors[0].getParameterTypes();

		// Beispiel für die erstellung eines neuen Objekts
		Object[] params = new Object[6];
		params[0] = "nameDesDatenExportObjects";
		for (int i = 0; i < daten.length; i++) {
			params[i + 1] = daten[i];
		}
		DatenExport datenExportObj = (DatenExport) constructors[0].newInstance(params);
		System.out.println(datenExportObj.toString());

		// Beispiel auf Zugriff auf Membervariablen eines vorhanden Objekts
		for (Field field : datenExportObj.getClass().getDeclaredFields()) {
			field.setAccessible(true);
			System.out.println("Variable " + field.getName() + ": " + field.get(datenExportObj).toString() + "(" + field.getType() + ")");

			Object object = field.get(datenExportObj);

			if(object instanceof DatenObj){
			// Auf Methode von Membervariable zugreifen:
				DatenObj obj = (DatenObj) object;
				System.out.println(obj.getName());
			}
		}
	}
}

Hoffe das beantwortet deine Fragen

 

[geqoo]

Dein Reflection Code ist soweit logisch, aber leider beantwortet der nicht meine Frage.

Ich will die Felder ja gar nicht zuweisen (so wie es in deinem Code der Fall ist), sondern ich möchte mit den übergebenen Argumenten (den DatenObjekten) direkt arbeiten.

 

[anti-held]

Das ist der 2. Teil der main-Methode.
Ab // Beispiel auf Zugriff auf Membervariablen eines vorhanden Objekts.
Am besten schaust du dir die Ausgabe des Codes an, um es zu verstehen.

datenExportObj ist das bereits erstellte Objekt, dessen DatenObj du lesen willst!
mit [c]datenExportObj.class.getDeclaredFields()[/c] erhältst du eine Liste von allen Membervariablen.
In der Schleife iterierst du über alle Felder (Membervariablen).
Da sie private sind, erfolgt erst der Aufruf [c]field.setAccessible()[/c] um darauf zugreifen zu können.
Dann initialisieren wir das aktuelle Objekt der Membervariable von dem datenExportObj mit [c]Object object = field.get(datenExportObj);[/c]
Dann überprüfen wir, ob es sich wirklich um ein DatenObj handelt mit [c]object instanceof DatenObj[/c],
denn die name-Membervariable würde hier false liefern, weil sie ja ein java.lang.String ist.
Mit [c]DatenObj obj = (DatenObj) object;[/c] casten wir es auf ein DatenObj und können dann dessen Methoden aufrufen.
Hier dargestellt durch die Methode [c]obj.getName()[/c] welche ich in der Klasse DatenObj implementiert habe.

Verständlich?

 

[geqoo]

Ich verstehe schon, was du meinst.

Heißt also, dass es nicht möglich ist, direkt auf die Werte aus dem Aufruf zuzugreifen, sondern man nur über den Zwischenschritt gehen kann, sich die Werte in der Klasse zwischenzuspeichern.

Dann schiebe ich das lieber alles beim Aufruf in eine Liste, dann habe ich das gewünschte Format zum Weiterarbeiten.

Danke erstmal.

 

[anti-held]

Ah jetzt verstehe ich was du meinst.
Sry!

Du könntest den Konstrutkor so aussehen lassen:

public DatenExport(String name, DatenObj... params){
   ...
}

dann kannst du so viele DatenObj übergeben, wie du willst
und mit einer for-schleife auf alle DatenObj zugreifen:

for(DatenObj obj:params){
   obj.tuEtwas();
}

 

[geqoo]

!!!
Sowas wie varargs ist genau der Gedankenblitz, den ich die ganze Zeit gesucht habe!
Die Lösung ist perfekt. Danke.