Generics

[MQue]

Hallo,

wann verwendet man eine generische Klasse, mit ist da die Anwendung nicht ganz klar, das heißt ja , dass das T für alle Methoden gilt oder wie ist das ?

Vielen Dank

public class MeinTest<T> {

// was mach ich da mit dem T

}

 

[SlaterB]

Generics in Java 1.5

 

[ARadauer]

T ist der Typ der Klasse für die das Objekt erzeugt wird... mit der kannst du schon arbeiten obwohl du noch gar nicht weißt, was es mal sein wird....

public class Test<T> {



      public static void main(String[] args) throws IOException {
         Test<String> t = new Test<String>();
         Test<Integer> t2 = new Test<Integer>();
      }
      
      public void ichErwarteT(T o){
         //mache was mit T...
      }
      
}

... mhn furchtbar von mir erklärt...

 

[Gast2]

Mhm ich versuch mal ein Beispiel zu machen sagen wir du hast verschiedene Textfelder...
Eines wo nur Zahlen eingeben kannst und in einem wo du alles eingeben kannst...

[HIGHLIGHT="Java"]
import javax.swing.JTextField;

public interface TextfieldValueIF<T>
{
public T getValue();
}

public class IntegerTextField extends JTextField implements TextfieldValueIF<Integer>
{

public Integer getValue() {
return Integer.parseInt(getText());
}

}

public class StringTextField extends JTextField implements TextfieldValueIF<String>
{

public String getValue() {
return getText();
}

}
[/HIGHLIGHT]

Du kannst dann mit dem T bestimmen welcher Datentyp du zurück geben möchtest du kannst die ganze Sachen noch einschränken wenn du T extend irgendwas machst.Genauso kannst du natürlich setter dafür schreiben. Du weißt im interface nicht was T ist aber wenn du es implementierst weißt du was für ein Datentyp es ist.

 

[Landei]

Zwei übliche Szenarien:

1) Du willst eine "containerartige" Klasse schreiben. Normalerweise unterliegt dann T keinen Beschränkungen:

class Tree<T> {
   private T value = null;
   private Tree<T> left = null
   private Tree<T> right = null
   public Tree<T>(T value) {
      this.value = value;
   }
   public void setLeft(Tree<T> left) {
       this.left = left;
   }
   public void setRight(Tree<T> right) {
       this.right = right;
   }
   public boolean contains(T t) {
      return t.equals(value) || (left != null && left.contains(t)) || (right != null && right.contains(t));
   }
   ...
}

2) irgendwelche Algorithmen sollen möglichst "allgemein" implementiert werden. Dazu muss man gewöhnlich Annahmen über T machen

public static <T extends Comparable<T>> T max(T t1, T t2) {
   return (t1.compareTo(t2)  >= 0) ? t1 : t2; 
}

Natürlich gibt es noch viel mehr Anwendungsfälle...