# Klasse als Parameter übergeben



## MaxJava (20. Jun 2014)

Hallo zusammen,
ich habe folgendes Problem und frage mich ob es dazu eine Lösung gibt:

-In meinem Programm befindet sich eine Superklasse mit einer static Metode "speichern".
-Mehrere Unterklassen mit static Methoden "erzeugeDatensatz" (Datensatz ist abhängig von der Klasse).

Wenn ich nun "speichern" aufrufe, muss ich in der "speichern" Methode angeben welche "erzeugeDatensatz" Methode ich aufrufen will, ich muss also die Klasse angeben. Diese weiß ich allerdings nicht, ich müsste sie also per Parameter übergeben. Ein Late Binding findet bei static Methoden leider nicht statt. 

Gibt es eine Möglichkeit wie ich die Klasse der Unterklasse per Parameter übergeben kann und dann in der Oberklasse in der "speichern" Methoden per unterklasse.erzeugeDatensatz() die jeweils gewünschte Methode aufrufen kann?

Danke schon mal, ich hoffe ihr versteht das Problem :toll:


----------



## mrbela (20. Jun 2014)

Du sagst es eigentlich schon selbst. Für mich schreit das ganz klar nach "später Bindung" und OOP-Ansatz! Warum muss die Methode denn static sein?

Ein Ansatz für Deinen Lösungsweg wäre das class-Objekt und Java Reflections. Aber das ist doch sehr unschön.. Würde eher meinen bisherigen Entwurf noch einmal überarbeiten.


----------



## MaxJava (20. Jun 2014)

Also ich habe mich für static entschieden, da alle Objekte gespeichert werden sollen und ich eigentlich nicht zuerst ein Objekt erstellen wollte, bevor ich alle speichern bzw. laden kann.

Sonst hätte ich ja: 

```
Objekt o = new Objekt();
o.speichern();

//anstatt

Superklasse.speichern();
```


----------



## mrbela (20. Jun 2014)

Ok. Hast Du kein Programm am laufen, aus dem aus Du speichern willst? Da hätteste ja dann n Objekt, mit dem Du die andern speichern könntest.

Andere Idee (mit dem static Design). Wie wär sowas?

Aufruf:


```
Superklasse.speichern()
```


```
class Superklasse {

....

public static void speichern(Supertyp typ) {
   // ...
   typ.speichern();
   // ...
}

...
}
```

Könntest ja alle Objekte, die Du speichern willst ein Interface (=Supertyp) implementieren lassen, das die Methode speichern enthält. Das könnteste dann so aufrufen.

edit: Interfaces unterliegen in Java auch Namenskonventionen.. Die hab ich jetzt mal nicht beachtet. :smoke:


----------



## MaxJava (20. Jun 2014)

Ja den Ansatz hatte ich auch schon, allerdings funktioniert es nicht.
In der Superklasse wird immer die Methode aus der Superklasse aufgerufen. Das liegt wohl daran, dass die Methode static ist. Auch wenn ich den Typ der Unterklasse übergebe, wird mit

```
public static void speichern(Supertyp typ) {
   // ...
   typ.erzeugeDatensatz();
   // ...
}
```
 immer die Funktion "erzeugeDatensatz" aus der Superklasse aufgerufen. Und diese muss vorhanden sein, da sonst der Compiler sich beschwert.


----------



## mrbela (20. Jun 2014)

Mh, verstehe.. Und wenn Du die zu speichernden Klassen von der Superklasse löst, ihnen ein eigenes Interface gibst und dieses Interface in der Superklasse.speichern(InterfaceTyp it) benutzt?


----------



## MaxJava (20. Jun 2014)

Also jetzt wirds ganz schön undurchsichtig :applaus:
Ich glaub ich mach das static einfach weg und erstelle vorher eben ein Objekt


```
Testklasse objekteLaden = new Testklasse();
objekteLaden.laden();
```

Danke für deine Hilfe, jetzt weiß ich, dass es nicht so einfach geht ;(


----------



## kaoZ (20. Jun 2014)

Ich hab es jetzt nur überflogen, 

kurze frage , persistent speichern ?

oder nur in z.B einer Liste der Superklasse ?

Naja egal , hier mal fix ein Ansatz mit einer Statischen Collection

Superklase.java


```
import java.util.HashMap;
import java.util.Map.Entry;

public class Superklasse {
	
	static HashMap<String, Saveable> container = new HashMap<>();

	public Superklasse() {}
	
	
	public static void inhaltAusgeben(){
		for (Entry<String, Saveable> element : container.entrySet()) {
	        System.out.println(element.getKey());
        }
	}
}
```

Subklasse. java


```
public class Subklasse extends Superklasse implements Saveable{

	private String name;
	
	public Subklasse(String name) {
		this.name = name;
    }
	
	public String getName() 			{return this.name;}
	
	@Override
    public void speichern() {
	    Superklasse.container.put(getName(), this);
    }

}
```

und das dazu gehörende Interface Saveable.java


```
public interface Saveable {
	
	public void speichern();

}
```

Hier dann mal ein Test des ganzen :


```
public class Foo {

	
	public static void main(String[] args) {
	    Subklasse sub = new Subklasse("Example");
	    
	    //oder auch einfach 
	    
	    new Subklasse("Example2").speichern();
	    
	    sub.speichern();
	    
	    Superklasse.inhaltAusgeben();
    }
}
```

Und die Ausgabe dazu 


```
Example
Example2
```

Hier implementiert die Subklasse das Interface Saveable, und ist somit speicherbar, wie gespeichert wird legst du dann in der jeweiligen klasse selber fest, hier ist es so realisiert das du das Objekt der statischen liste der Superklasse hinzufügst, und nach belieben 

über einen aufruf von 


```
Superklasse.inhaltAusgeben
```

den inhalt ausgeben kannst, man könnte noch viel mehr machen aber ich hab es wie gesagt nur überflogen.

Superklasse wäre hier eine Art Utility Klasse ( nicht OO ) da diese dann meist statische hilfsmethoden anbieten würde, auch ein laden von Datensätzen wäre denk und machbar.

*Mann könnte auch die Funktionalität in der Superklasse bereitstellen und das Interface nicht Funktional nutzen sondern nur als Marker-Interface, welches dann einfach Speicherbare Objekte kennzeichnet, ähnlich dem Serializable Interface. (Viele Wege führen nach Rom ^^)*

[TIPP]
Nochmal kleiner Hinweis zum Thread Title, es werden Grundsätzlich keine Klassen übergeben,
sondern Kopien der Referenzen / Werte. ( pass by Value )
[/TIPP]

[EDIT]Wenn du Fragen oder änderungswünsche hast , hau einfach raus [/EDIT]


----------

