# Generische Typen auch für statische Methoden?



## fsteinke (26. Okt 2009)

Hallo,

eine Frage. Gibt es auch die Möglichkeit generische Datentypen <T> für statische Methoden zu vergeben? Bin da verwirrt weil ich beim googlen gegenteilige Aussagen gehört habe.  ALso einerseits wird gesagt es geht andererseit es geht eben nicht. ;-)

Danke für jeden Tip.
Gruß Frederick


----------



## Nader (26. Okt 2009)

fsteinke hat gesagt.:


> Hallo,
> 
> eine Frage. Gibt es auch die Möglichkeit generische Datentypen <T> für statische Methoden zu vergeben? Bin da verwirrt weil ich beim googlen gegenteilige Aussagen gehört habe.  ALso einerseits wird gesagt es geht andererseit es geht eben nicht. ;-)
> 
> ...



nein es geht nicht! generic und static verstehen sich leider überhaupt nicht. wie zwei Magnetpolen.


----------



## Der Müde Joe (26. Okt 2009)

sowas:

```
public static <T extends Comparable<? super T>> List<T> foo(T t) {
	return Collections.emptyList(); // also dann halt  ne T-ige Liste
}
```


----------



## bygones (26. Okt 2009)

was aber geht (mit einem voellig sinnlosen bsp)

```
public static void main(String[] args) throws IOException {
        String s = getSomeT("");
    }

    private static <T> T getSomeT(String k) {
        return (T)k;
    }
```


----------



## Der Müde Joe (26. Okt 2009)

>getSomeT

au ja...aber <E> getSomeCofE ;-)


----------



## Nader (26. Okt 2009)

bygones hat gesagt.:


> was aber geht (mit einem voellig sinnlosen bsp)
> 
> ```
> public static void main(String[] args) throws IOException {
> ...



statisch heißt ja, dass für den Compiler alles zur Kompilerzeit bekannt sein muss außer  Funktionsergebnisse und deswegen geht sowas wie dein Beispiel (übrigens so ganz sinnlos finde ich es auch nicht )


----------



## Der Müde Joe (26. Okt 2009)

>dass für den Compiler alles zur Kompilerzeit bekannt sein muss außer Funktionsergebnisse

nö. auch das Funktionsergebnis. Der Compiler überprüft, ob das Objekt passt
zB:


```
public static <T> T getT(T t) { return t;}
```

es kommt ein T rein und ein T wird returned -> passt (was auch immer T ist)


```
public static <T,E> E getEfromT(T t) { return (E)t.getE();}
```

passt. ein T geht rein und ein E kommt raus (passt, solange alle T eine getE-Methode haben und ein E liefern) Dabei wird meistens eine Boundary gesetzt zb <T extends FooBar>, somit sind alle T mindestens ein FooBar.


----------



## Nader (26. Okt 2009)

Der Müde Joe hat gesagt.:


> >...
> 
> ```
> public static <T,E> E getEfromT(T t) { return (E)t.getE();}
> ...



das geht natürlich nicht! (auch mit einer Boundary nicht) eine generische T kann keine statische Methode getE() haben!


----------



## Beni (26. Okt 2009)

Das Boundary müsste die (generische) Methode "getE" vorschreiben, dann geht es wieder.


----------



## Nader (26. Okt 2009)

Beni hat gesagt.:


> Das Boundary müsste die (generische) Methode "getE" vorschreiben, dann geht es wieder.



Beispielcode?????:L


----------



## Beni (26. Okt 2009)

So:

```
public interface Boundary<E>{
  public E getE();
}
```


```
public static <E, T extends Boundary<? extends E>> E getEfromT( T t ) { 
  return t.getE();
}
```


----------



## Der Müde Joe (26. Okt 2009)

>Beispielcode??

```
public class GeneFoo {

	public static <E extends FooIF<E>> E fooIt(E e) {
		return e.getE();
	}

	interface FooIF<E> {

		E getE();
	}
}
```


----------



## Nader (26. Okt 2009)

Beni hat gesagt.:


> So:
> 
> ```
> public interface Boundary<E>{
> ...



danke, mit Beispielcode meinte ich auch, ein Beispiel wo so etwas real eingesetzt werden kann also aufgerufen werden kann:


```
public interface Boundary<E> {
		public E getE();
	}

	public class MyBoundary<E> implements Boundary<E> {
		private E e;

		public MyBoundary(E e) {
			this.e = e;
		}

		public E getE() {
			return e;
		}
	}

	public static <E, T extends Boundary<? extends E>> E getEfromT(T t) {
		return t.getE();
	}

	private void doTest() {

		Boundary<String> bs = getEfromT( ???? )  
	}
```


----------



## Der Müde Joe (26. Okt 2009)

etwas kreiert, aber:

```
import java.util.ArrayList;
import java.util.List;


public class GeneFoo {

	public static <E, T extends ValueProvider<E>> List<E> getValues(List<T> tList) {
		List<E> result = new ArrayList<E>(tList.size());
		for (T t : tList) {
			result.add(t.getValue());
		}
		return result;
	}

	interface ValueProvider<E> { E getValue();}

	static class Entry<E> implements ValueProvider<E> {

		E e;

		@Override
		public E getValue() {
			return e;
		}
	}

	public static void main(String... _) {
		List<ValueProvider<String>> entryList = new ArrayList<ValueProvider<String>>();
		Entry<String> v = new Entry<String>();
		v.e = "test";
		entryList.add(v);
		Entry<String> b = new Entry<String>();
		b.e = "test";
		entryList.add(b);
		List<String> stringList = getValues(entryList);
		for (String s : stringList) { 
			/* do somestuff */
		}
	}
}
```


----------

