Warum return type Object ?

[bananenkasper]

Hallo,

ich wundere mich, warum die Methode "getParam(I_Params.Type)" ein Objekt vom Typ "Object" returned.
Eigentlich hätte ich gern ein File-Object...

public static void main(String[] args) {
		
		I_Param<File> fileParam = new FileParam();
		I_Params params = new Params();
		params.addParam(I_Params.Type.FILE, fileParam);
		
		File file = params.getParam(I_Params.Type.FILE).getValue();    // Hier hängt es...
	}

public interface I_Param<T> {	
	T getValue();	
	void setValue(T value);
}
public interface I_Params {
	enum Type {
		FILE
	}
	<T> void addParam(I_Params.Type type, I_Param<T> param);
	<T> I_Param<T> getParam(I_Params.Type type);
}

 

[thE_29]

Was ist wenn du castest?

Weil du gibst bei I_Params keinen generic Typen an! Von daher nimmt er als Default Object

 

[bananenkasper]

Casten wollte ich eigentlich nicht...
Finde ich zu unsauber

Wie kann ich den fehlenden generic typ angeben?

 

[SlaterB]

Sinn scheint das nicht zu machen, denn wenn man das ganz in zwei Schritten abarbeitet, funktioniert es..

public class Test
{
    public static void main(String[] args)
    {

        I_Param<File> fileParam = null;
        I_Params params = null;

        I_Param<File> x = params.getParam();
        File file = x.getValue(); // Hier hängt es nicht
        File file2 = params.getParam().getValue(); // Hier hängt es...


        String a = getList().get(4).get(4);
    }

    public static List<List<String>> getList()
    {
        return null;
    }

}


interface I_Param<T>
{
    T getValue();

}


interface I_Params
{

    <T>I_Param<T> getParam();
}

edit: ok, jetzt habe ich so viel gekürzt, das bei file2 gar nirgendwo mehr 'File' auftaucht, dann wirds langsam deutlich

das T müsste in getParam() als Parameter auftauchen, dann wäre es definiert,
gleich kommt noch ein edit

edit 2:

public class Test
{
    public static void main(String[] args)
    {
        I_Params params = null;

        File temp = null;
        File file2 = params.getParam(temp).getValue(); // Hier hängt es nun nicht mehr

    }
}


interface I_Param<T>
{
    T getValue();
}


interface I_Params
{

    <T>I_Param<T> getParam(T t);
}

 

[bananenkasper]

Tatsache... :shock:

Wenn man es trennt geht es...

File temp = null;
        File file2 = params.getParam(temp).getValue(); // Hier hängt es nun nicht mehr

geht das noch irgendwie eleganter?
Naja, vielleicht ist mein Ansatz auch einfach "sub-optimal"...
Ich versuche Programm-Parameter zu verwalten, die logischerweise verschiedene Datentypen repräsentieren können (File, int, double...).
Wenn ich obiges Interface folgendermassen implementiere, komme ich um das Casten eh nicht drum rum...

public class Params implements I_Params{
	private final Map<I_Params.Type, I_Param<?>> map = new HashMap<I_Params.Type, I_Param<?>>();
	public <T> void addParam(Type type, I_Param<T> param) {
		map.put(type, param);
	}
	public <T> I_Param<T> getParam(Type type) {
		return map.get(type);        // Fehler
	}
}