除了制作类型安全的集合之外，java中泛型的使用？

Question

我大多使用泛型来制作类型安全的集合。泛型的其他用途是什么？

Answer 1

I've used it to write a very slim DAO-layer:

/*
  superclass for all entites, a requirement is that they have the 
  same kind of primary key
*/
public abstract class Entity {
}

/*
  superclass for all DAOs. contains all CRUD operations and anything else
  can be generalized
*/
public abstract class DAO<T extends Entity> {

  //assuming full control over the database, all entities have Integer pks.
  public T find(Integer pk) {...}
  public void save(T entity) {...}
  public void remove(T entity) {...}
  etc...

}

/*
  Complete example of an ideal DAO, assuming that there are no special
  operations specific for the Entity.
  Note the absence of any implementation at all.
*/
public class SpecificDAO extends DAO<SpecificEntity> {}

Answer 2

To allow user-created, custom classes to be used with your code.

Say you release an SDK that enables some kind of special functionality. Generics will allow developers to utilise your functionality in many places, with almost any class.

The purpose of generics to reduce code repetition.

Answer 3

Another interesting use is to represent types as variables in Java's reflection framework .

In particular, note that java.lang.Class has a type parameter, specifying which class the Class object represents.

See Wikipedia for general information.

Answer 4

还有其他用途，例如泛型类和泛型方法。

Answer 5

Generic are used to make a generalised class, so when you create a class you can make it a parameterised class. Later on when its object is created, you can specify which datatype or classtype that class's parameters will get type-casted to. Also, it can make a class cast safe, so that elements of only one datatype or classtype can be inserted. This technique is mainly useful in data structure classes.

Answer 6

Generics enables types to be parameters Generics enable types (classes and interfaces) to be parameters when defining classes, interfaces and methods. This is just like the familiar formal parameters used in method declarations. The difference is that the inputs to formal parameters are values, while the inputs to type parameters are types. Example below:- Use of formal parameterized method and generics :-

class Room {

    private Object object;

    public void add(Object object) {
        this.object = object;
    }

    public Object get() {
        return object;
    }
}

public class Main {
    public static void main(String[] args) {
        Room room = new Room();
        room.add(60);
        //room.add("60"); //this will cause a run-time error
        Integer i = (Integer)room.get();
        System.out.println(i);
    }
}

Generics version of above:-

class Room<T> {

    private T t;

    public void add(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }
}

public class Main {
    public static void main(String[] args) {
        Room<Integer> room = new Room<Integer>();
        room.add(60);

        Integer i = room.get();
        System.out.println(i);
    }
}

In geneics version of class if someone adds room.add("60") , a compile-time error will be shown.

1.Info source 2. Example taken from

Answer 7

Generics uses:

• Compile-time type safety.
• Avoid casting (hence avoid ClassCastException ).
• Readable Code.

Refer Java Generics tutorial for detailed explanation.

Answer 8

Enums are another example from the JDK. Basically whenever you have two classes working together, but don't know exactly which classes,generics become interesting.