Generics Methoden

[Gansa]

Ich verstehe nicht ganz den Unterschied zwischen einer generischen not static methode und einer static geneic method.
Ich übergebe der einen Methoden Objekt Referenzen und der anderen primitive Datentypen, wenn ich das richtig verstanden habe. Ist das eigentlich dann alles? Und wieso gebe ich in der static "<T> T" zwei mal an? Danke im Voraus!

public class GenericMethodsClass<T> {

    public T random(T t, T s) {
        return Math.random() > 0.5 ? t : s;
    }

    public static <T> T random2(T t, T s) {
        return Math.random() > 0.5 ? t : s;
    }
}

 

[Kirby.exe]

Die static Methode kann ohne Objekt verwendet werden und die non static eben nicht

 

[Gansa]

Was ich auch nicht verstehe ist das der Diamant operator manchmal hinter dem Klassennamen steht und Methoden ohne Diamant Operator angegeben werden bsp:

public class Pocket<T>
{
  private T value;

  public Pocket() {}

  public Pocket( T value )
  { this.value = value; }

  public void set( T value )
  { this.value = value;
  }

  public T get() { return value; }

  public boolean isEmpty()
  { return value != null; }

  public void empty()
  { value = null; }
}

Meine klasse sieht so aus und wenn ich die Dia op weg mache gibt es mir einen Fehler, woran liegt das? Im Netz verstehe ich die Erklärungen nicht ich glaube meine Frage ist zu spezifisch. Ich kopiere meinen Code mal rein, wo das nicht ohne Dia op funktioniert und oben neben dem Klassennamen habe ich auch keinen Dia op. Für was schreibt man eigentlich den Operator hinter den Klassennamen? Der Klassenname ist klein geschrieben ich weiss, was nur auf die schnelle um mir unterschiede klar zu machen:

public class mein {

    public static void main(String[] args) {

        String[] strings = {"h", "l", "a"};
        changePosition(strings, 1, 2);
        print(strings);

    }

    public static <T> void changePosition(T[] s, int a, int b) {

        T tmp = s[a];
        s[a] = s[b];
        s[b] = tmp;
    }

    public static <T> void print(T[] s) {
        for (T t : s) {
            System.out.println(t);
        }
    }

}

Danke falls mir das jemand verständlich machen kann !

 

[Kirby.exe]

Um Generische Methoden zu nutzen, muss deine gesamte Klasse generisch sein

 

[Gansa]

Um Generische Methoden zu nutzen, muss deine gesamte Klasse generisch sein

Ich verstehe es aber nicht warum ich neben dem klassennamen bei mir <T> weglassen kann und bei den Methoden es drint steht ohne Fehler und im ersten Code sozusagen genau das gegenteil steht

 

[Kirby.exe]

Also meines Wissens nach liegt es daran dass dort deine Methode eine static ist und somit unabhängig von einem Objekt existiert und deshalb die Klasse nicht generisch sein muss

 

[sascha-sphw]

Bei Klassen gibt man damit die Möglichkeit den Typ innerhalb der gesamten Klasse verwenden zu können.

class Foo<T> {
    private T bar;
    ...
}

Foo<String> fooInstance = new Foo<>();
// somit wird aus T = String

Bei static methods, die ja nicht auf Instanz-ebene agieren, muss man das halt vor die Methode schreiben.

public static <T> T doSomething(T foo) {
    ...
}
String bar = doSomething<String>("test");
// somit wird hier aus T String

Das erst <T> ist somit das gleiche wie in Foo<T> der Klasse und definiert den generischen Typ. Ohne <T> wäre der generische Typ T weder für Parameter noch für die Rückgabe bekannt.
Das Zweite T ist schlicht einfach der Typ des Rückgabewertes.

BTW: Die Methoden variante funktioniert auch als Instanz Methode wenn die Klasse selbst nicht generisch ist.
Du ziehst somit die Definition einfach von der Klasse zur Methode.

class Foo {
    public <T> T doSomething(T bar) {
        ...
    }
}

 

[Gansa]

Bei Klassen gibt man damit die Möglichkeit den Typ innerhalb der gesamten Klasse verwenden zu können.

class Foo<T> {
    private T bar;
    ...
}

Foo<String> fooInstance = new Foo<>();
// somit wird aus T = String

Bei static methods, die ja nicht auf Instanz-ebene agieren, muss man das halt vor die Methode schreiben.

public static <T> T doSomething(T foo) {
    ...
}
String bar = doSomething<String>("test");
// somit wird hier aus T String

Das erst <T> ist somit das gleiche wie in Foo<T> der Klasse und definiert den generischen Typ. Ohne <T> wäre der generische Typ T weder für Parameter noch für die Rückgabe bekannt.
Das Zweite T ist schlicht einfach der Typ des Rückgabewertes.

BTW: Die Methoden variante funktioniert auch als Instanz Methode wenn die Klasse selbst nicht generisch ist.

class Foo {
    public <T> T doSomething(T bar) {
        ...
    }
}

Vielen dank!!!