1、简单的泛型类示例如下：

public class DAO<T> {
     /**
      * 泛型类
      * 声明类的同时声明泛型类型
      * 1.方法的返回值可以是使用声明的泛型类型
      * 2.方法的参数也可以是声明类的泛型类型
      * 3.方法体内可以使用泛型类型
      */
     public T get(Integer id){
        return null;
     }
     
     public void save(T entity){        
     }
 }

类中的类型参数就跟在方法或构造函数中普通的函数一样。当一个泛型声明被调用，实际类型参数取代形式类型参数。

相当于声明的时候public class DAO<T> ,T是一个形参，而使用的时候DAO<Person> dao  = new DAO<>()；相当于传入了一个实参。

泛型类 


    泛型类封装不是特定于具体数据类型的操作。泛型类最常用于集合，如链接列表、哈希表、堆栈、队列、树等，其中，像从集合中添加和移除项这样的操作都以大体上相同的方式执行，与所存储数据的类型无关。
    对于大多数需要集合类的方案，推荐的方法是使用 .NET Framework 2.0 类库中所提供的类。有关使用这些类的更多信息。
    一般情况下，创建泛型类的过程为：从一个现有的具体类开始，逐一将每个类型更改为类型参数，直至达到通用化和可用性的最佳平衡。创建您自己的泛型类时，需要特别注意以下事项：

将哪些类型通用化为类型参数。
一般规则是，能够参数化的类型越多，代码就会变得越灵活，重用性就越好。但是，太多的通用化会使其他开发人员难以阅读或理解代码。


如果存在约束，应对类型参数应用什么约束（请参见类型参数的约束（C# 编程指南））。
一个有用的规则是，应用尽可能最多的约束，但仍使您能够处理需要处理的类型。例如，如果您知道您的泛型类仅用于引用类型，则应用类约束。这可以防止您的类被意外地用于值类型，并允许您对 T 使用 as 运算符以及检查空值。 


是否将泛型行为分解为基类和子类。
由于泛型类可以作为基类使用，此处适用的设计注意事项与非泛型类相同。有关从泛型基类继承的规则，请参见下面的内容。


是否实现一个或多个泛型接口。 
例如，如果您设计一个类，该类将用于创建基于泛型的集合中的项，则可能需要实现一个接口，如 IComparable<T>，其中 T 是您的类的类型。

有关简单泛型类的示例，请参见泛型介绍（C# 编程指南）
类型参数和约束的规则对于泛型类行为有几方面的含义，特别是关于继承和成员可访问性。请务必先理解一些术语，然后再继续进行。对于泛型类 Node<T>,，客户端代码可以通过指定类型参数引用该类，以创建封闭式构造类型 (Node<int>)，或者可以让类型参数处于未指定状态（例如在指定泛型基类时）以创建开放式构造类型 (Node<T>)。泛型类可以从具体的、封闭式构造或开放式构造基类继承：
class BaseNode { }
class BaseNodeGeneric<T> { }

// concrete type
class NodeConcrete<T> : BaseNode { }

//closed constructed type
class NodeClosed<T> : BaseNodeGeneric<int> { }

//open constructed type 
class NodeOpen<T> : BaseNodeGeneric<T> { }


    非泛型（具体）类可以从封闭式构造基类继承，但无法从开放式构造类或裸类型参数继承，因为在运行时客户端代码无法提供实例化基类所需的类型变量。
//No error
class Node1 : BaseNodeGeneric<int> { }

//Generates an error
//class Node2 : BaseNodeGeneric<T> {}

//Generates an error
//class Node3 : T {}


    从开放式构造类型继承的泛型类必须为任何未被继承类共享的基类类型参数提供类型变量，如以下代码所示：
class BaseNodeMultiple<T, U> { }

//No error
class Node4<T> : BaseNodeMultiple<T, int> { }

//No error
class Node5<T, U> : BaseNodeMultiple<T, U> { }

//Generates an error
//class Node6<T> : BaseNodeMultiple<T, U> {} 


    从开放式构造类型继承的泛型类必须指定约束，这些约束是基类型约束的超集或暗示基类型约束：
class NodeItem<T> where T : System.IComparable<T>, new() { }
class SpecialNodeItem<T> : NodeItem<T> where T : System.IComparable<T>, new() { }


    泛型类型可以使用多个类型参数和约束，如下所示：
class SuperKeyType<K, V, U>
    where U : System.IComparable<U>
    where V : new()
{ }

    开放式构造类型和封闭式构造类型可以用作方法参数：
void Swap<T>(List<T> list1, List<T> list2)
{
    //code to swap items
}

void Swap(List<int> list1, List<int> list2)
{
    //code to swap items
}


泛型类是不变的。也就是说，如果输入参数指定 List<BaseClass>，则当您试图提供 List<DerivedClass> 时，将会发生编译时错误。 

一、自定义泛型类
自定义泛型结构：泛型类、泛型接口、泛型方法
自定义泛型类的内部结构(方法、属性、构造器等)，可以使用类的泛型
如果定义了泛型类，实例化时没有指明类的泛型，则认为泛型类型为Object类型
要求：如果定义了泛型类，在实例化时，要指明类的泛型；
/**
* 自定义泛型类
*/
public class Order {
private String orderName;
private Integer orderAge;
//自定义泛型类的内部结构(方法、属性、构造器等)，可以使用类的泛型
private T orderT;
public Order() {
}
public Order(String orderName, Integer orderAge, T orderT) {
this.orderName = orderName;
this.orderAge = orderAge;
this.orderT = orderT;
}
public String getOrderName() {
return orderName;
}
public void setOrderName(String orderName) {
this.orderName = orderName;
}
public Integer getOrderAge() {
return orderAge;
}
public void setOrderAge(Integer orderAge) {
this.orderAge = orderAge;
}
//自定义泛型类的内部结构(方法、属性、构造器等)，可以使用类的泛型
public T getOrderT() {
return orderT;
}
public void setOrderT(T orderT) {
this.orderT = orderT;
}
@Override
public String toString() {
return "Order{" +
"orderName='" + orderName + '\'' +
", orderAge=" + orderAge +
", orderT=" + orderT +
'}';
}
}
public class GenericTest2 {
@Test
public void test01() {
//如果定义了泛型类，实例化时没有指明类的泛型，则认为泛型类型为Object类型
//要求：如果定义了泛型类，在实例化时，要指明类的泛型；
Order order = new Order();
order.setOrderT(1);
order.setOrderT("很好");
//如果定义了泛型类，实例化时应指明类的泛型
Order order1 = new Order<>();
order1.setOrderT(1);
}
}
二、泛型类的继承特点
子类继承泛型类，泛型类未指明泛型类型，那么子类仍然为泛型类
子类继承泛型类，泛型类指明泛型类型
/**
* 子类继承泛型类，泛型类未指明泛型类型
*/
public class Sub1Order extends Order {
}
/**
* 子类继承泛型类，泛型类指明泛型类型
*/
public class Sub2Order extends Order {
}
@Test
public void test01() {
//子类继承泛型类，泛型类未指明泛型类型，那么子类仍然为泛型类
Sub1Order sub1Order = new Sub1Order<>();
sub1Order.setOrderT(1);
//子类继承泛型类，泛型类指明泛型类型
Sub2Order sub2Order = new Sub2Order();
sub2Order.setOrderT(1);
}

Java泛型类声明除了类名之后是类型参数部分，其它看起来像非泛型类声明。
泛型类的类型参数部分可以有一个或多个类型参数，它们之间用逗号分隔。这些类称为参数化类或参数化类型，因为它们接受一个或多个参数。
语法
public class Box {
private T t;
}
在上面声明中，
Box - Box是一个泛型类。
T - 这是参数传递给泛型类的泛型类型，它可以采取任何对象。
t - 泛型类型T的一个实例
描述
T是传递给泛型类Box的类型参数，当创建一个Box对象时就要传递了。
示例
使用您喜欢的编辑器创建以下java程序代码并保存到文件：GenericsClasses.java，如下所示 -
package com.yiibai;
public class GenericsClasses {
public static void main(String[] args) {
Box integerBox = new Box();
Box stringBox = new Box();
integerBox.add(new Integer(199));
stringBox.add(new String("Hello World"));
System.out.printf("Integer Value :%d\n", integerBox.get());
System.out.printf("String Value :%s\n", stringBox.get());
}
}
class Box {
private T t;
public void add(T t) {
this.t = t;
}
public T get() {
return t;
}
}
执行上面代码，将产生以下结果 -
Integer Value :199
String Value :Hello World
¥ 我要打赏
纠错/补充
收藏
加QQ群啦，易百教程官方技术学习群
注意：建议每个人选自己的技术方向加群，同一个QQ最多限加 3 个群。