# Methode mit beliebigen Parametern in abstrakter Klasse definieren



## mrbela (5. Nov 2012)

Hey Leute!

Ich kenn die Schreibweise


```
public void foo(Object... objects) {...}
```

einer Methode. Nun möchte ich allerdings in einer abstrakten Klasse eine solche Methode definieren, was auch klappt:


```
public abstract String toPrologString(Object... objects);
```

und nun möchte ich in einer konkreten Unterklasse diese abstrakte Methode konkret implementieren:


```
@Override
	public String toPrologString(Invoice i) {
		
		return "foo";
	}
```

Was der Compiler aber nicht durchgehen lässt... 

Ich möchte die Methode "toPrologString" aber so variable wie möglich gestalten, dass die eine Klasse diese mit zwei Argumenten, die andere mit drei usw. benutzen kann.

Habt ihr da irgendwelche ideen?

Danke für die Hilfe!

Edit: Die Fehlermeldung des Compilers sieht wie folgt aus:

```
Multiple markers at this line
	- The method toPrologString() of type InvoiceAdapter must override or implement a supertype method
	- The method toPrologString(Invoice) of type InvoiceAdapter must override or implement a supertype 
	 method
```


----------



## KrokoDiehl (5. Nov 2012)

Hier helfen dir Templates weiter:


```
public abstract class Base<T> {

    public abstract void toPrologString(T... params);
}

public class Child extends Base<Invoice> {

    @Override
    public void toPrologString(Invoice... params) {
        ...
    }
}
```


----------



## mrbela (5. Nov 2012)

Vielen Dank! Super Tip!

Noch eine Frage:
Ich will die Argumente meiner Methode so allgemein halten wie möglich, sprich: Es ist nicht immer gewährleistet, dass ich nur Objekte vom Typ Invoice habe. Leider ist es auch so ungewiss, dass ich bspw. nicht (String s, T... params) schreiben könnte.

Bleibt mir noch was anderes übrig, außer meine Klasse Child (bei Dir im Beispiel) mit dem Typ Object auszuprägen und dann mit instanceof's zu arbeiten? Ich befürchte wohl nicht, oder?! :/


----------



## annonymos (5. Nov 2012)

Hallo,

das lässt dich mit Java Generics lösen, wobei T immer zum Zeitpunkt der 
Instanziierung festgelegt wird:

Beispielsweise so:


```
public abstract class Converter <T> {    
    public abstract String toPrologString(T... objects);   
}
```
;



```
public static void main(String[] args) {
        Converter<String> myStringConverter = new Converter<String>() {

            @Override
            public String toPrologString(String... objects) {
                throw new UnsupportedOperationException("Not supported yet.");
            }
        };
        
        Converter<Integer> myIntegerConverter = new Converter<Integer>() {

            @Override
            public String toPrologString(Integer... objects) {
                throw new UnsupportedOperationException("Not supported yet.");
            }
        };
    }
```

Ist das was du suchst?


----------



## mrbela (5. Nov 2012)

Wie kann ich es denn gestalten, damit ich bspw.


```
toPrologString(Integer i, String s, Integer i2)
```

aufrufen kann?

Da bleibt mir doch nichts anderes übrig als


```
Converter<Object> myObjectConverter = new Converter<String>() {
 
            @Override
            public String toPrologString(Object... objects) {
                // TODO
            }
        };
```

zu machen und in der Methode selbst mit 
	
	
	
	





```
instanceof
```
 arbeiten??

Danke für Eure Hilfe!


----------



## faetzminator (5. Nov 2012)

Ja. Du kannst ansonsten nur einen gemeinsamen Supertypen nehmen, was in diesem Fall wohl [c]Object[/c] sein würde.


----------



## trööhööt (5. Nov 2012)

annonymos hat gesagt.:


> das lässt dich mit Java Generics lösen, wobei T immer zum Zeitpunkt der
> Instanziierung festgelegt wird



FALSCH

die instanzierung ist ein ablauf während der RUNTIME ... generics werden aber durch Type-Erasure bereits zur COMPILETIME aufgelöst ...

siehe hier : Type Erasure (The Java™ Tutorials > Learning the Java Language > Generics (Updated))


----------



## mrbela (19. Nov 2012)

Hey Leute,

ich stehe mit dem oben erarbeiteten immer noch vor einem Problem..

Erstmal der Stand der Dinge:

Ich habe meine abstrakte Klasse der Form


```
public abstract class Base<T> {
	public abstract String toPrologString(T... objects);
}
```

und kann diese jetzt ausprägen, z.B. mit 


```
public class InvoiceAdapter extends PrologBase<Invoice> {

	public String toPrologString(Invoice... invoices) {

		String returnString = "";
		// ....
		return returnString;
	}
```

oder auch:


```
public class Outgoing extends PrologBase<Object> {
	
	@Override
	public String toPrologString(Object... objects) {
		
		String returnString = "[";
		// ....		
		return returnString;
	}
```

Möchte ein fremder Programmierer nun diese Klassen benutzen, so weiß es durch die Methodendefinition nicht mit welchen Parametern er die Methode toPrologString bestücken soll... Auch weiß er bei der Klasse InvoiceAdapter nicht, wie viel Adapter er da mitgeben soll.. Einen oder mehrere..

Mein Problem ist: Ich will eine abstrakte Klasse haben, die quasi vorschreibt, wie diese toPrologString auszusehen hat.. Die muss aber in der abstrakten Klasse so allg. wie möglich gehalten werden, daher das T... Da es das ganze ein Framework werden soll, kann ich keinerlei Vorraussagen machen, wie die Klassen aussehen werden, die meine Base extenden... Möchte ich jetzt die toPrologString für Integer und String benutzen, muss ich meine Klasse mit Object ausprägen...

Aber: Woher weiß der Programmierer dann, wenn er nur "Object..." liest, dass die Methode eigtl ein Integer und ein String haben will?? Außer das mit Kommentaren zu lösen, fällt mir leider nichts ein.. Kommentare sind hier aber nicht wirklich schön, finde ich!

Ich hoffe, ihr versteht mein Problem!

Vielen Dank für die Hilfe!


----------



## mrbela (20. Nov 2012)

? keiner ne Idee?? :/


----------

