泛型引入

如果我们需要产生多个对象，每个对象的逻辑完全一样，只是对象内的成员变量的类型不同，那我们如何去做？
此时，我们就引入了泛型。

泛型：让数据类型变得参数化。定义泛型时，对应的数据类型是不确定的。泛型方法被调用时，才指定具体类型
这样就解决了多个相似的类（方法、接口 ）创建的问题，一个泛型类即可代替所有相关类（方法、接口），提高代码的重用性

1. 泛型类特点

• 泛型的类型参数可以是泛型类
• 泛型类可是同时设置多个类型参数
• 泛型类可以继承泛型类
• 泛型类可以实现泛型接口

2. 最简单泛型类

泛型类：

调用泛型类时才指定具体类型：

3. 泛型方法

3.1 定义泛型方法

• 定义格式：

访问修饰符 <泛型列表> 返回类型 方法名(参数列表) {
		实现代码；
}

• 在泛型列表中声明的泛型，可用于该方法的返回类型声明、参数类型声明和方法代码中的局部变量的类型声明
• 类中的其他方法不能使用当前方法声明的泛型

注意： 是否拥有泛型方法，与其所在的类是否是泛型没有关系，要定义泛型方法，只需将泛型参数列表置于返回值前

示例：

package com.demo;

class Parent {
	//泛型方法
	public <T> void printInfo(T a) {
		System.out.println(a);
	}
	//重载泛型方法
	public <T, T2> T2 printInfo(T a, T2 b) {
		System.out.println(a);
		System.out.println(b);
		return b;
	}
}

public class Test {
	public static void main(String[] args) {
		Parent one = new Parent();
		one.printInfo("hello");
		one.printInfo("hello", 10);
	}
}

结果：

3.2 使用extends关键字限制泛型类型

格式：

访问修饰符 <泛型 extends A> 返回类型 方法名(参数列表) {
		实现代码；
}

此时泛型的类型就只能是 A 类或者 A 的子类

示例：

package com.demo;

class Parent {
	void print() {
		System.out.println("上限为父类");
	};
}

class Child extends Parent {
	//重写方法
	void print() {
		System.out.println("下限为子类");
	}
}

class User{
	//泛型方法
	public <T extends Parent> void printInfo(T t) {
		t.print();
	}
}

public class Test {
	public static void main(String[] args) {
		User one = new User();
		one.printInfo(new Child());
		one.printInfo(new Parent());
	}
}	

结果：

3.3 静态泛型方法

使用static进行修饰

示例：

package com.demo;

class Parent {
	void print() {
		System.out.println("上限为父类");
	};
}

class Child extends Parent {
	//重写方法
	void print() {
		System.out.println("下限为子类");
	}
}

class User{
	//静态泛型方法
	public static <T extends Parent> void printInfo(T t) {
		t.print();
	}
}

public class Test {
	public static void main(String[] args) {
		User one = new User();
		//静态泛型方法通过实例化对象去动态调用会出现警告
		one.printInfo(new Child());	
		one.printInfo(new Parent());
		//静态调用则不会出现警告
		User.printInfo(new Child());
	}
}

结果：

4. 泛型接口

5. 泛型类可是同时设置多个类型参数

6. 泛型的类型参数可以是泛型类

注意：第一个getMessage() 获取的是泛型类，第一个获取的是 getMessage() 获取的才是整数a的值

7. 泛型类可以继承泛型类

8. 泛型类可以实现泛型接口

一、泛型

• 泛型：本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型。这种参数可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口。

泛型定义格式：

• <类型>：指定一种类型的格式。这里的类型可以看成是形参。
• <类型1,类型2…>：指定多种类型的格式，多种类型用逗号隔开，这里的类型可以看成是形参。
• 将来具体调用时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型。

泛型的好处：

• 把运行时期的问题提前到了编译期间
• 避免了强制类型转换

二、泛型类

泛型类的定义格式：

• 格式：修饰符 class 类名<类型>{}
• 泛例：public class Generic<T> {}
• T可以是任意标识

public class Generic<T>{
    private T t;

    public T get(){
        return t;
    }

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

public class CollectionDemo {

    public static void main(String[] args) {
        Generic<String> stu = new Generic<String>();
        stu.set("鸣人");
        System.out.println(stu.get());

        Generic<Integer> stu1 = new Generic<Integer>();
        stu1.set(10);
        System.out.println(stu1.get());
    }
}

三、泛型方法

泛型方法的定义格式：

• 格式：修饰符 <类型> 返回值类型方法名(类型变量名){}
• 范例：public <T> void show(T t){}

    public <T> T show(T t){
        return t;
    }

    public <T> void show1(T t){
        System.out.println(t);
    }

四、泛型接口

泛型接口的定义格式：

• 格式：修饰符 interface 接口名<类型>{}
• 范例：public interface Generic <T>{}

public interface GenInterface<T> {
    void show(T t);
}

public class GenImpl<T> implements GenInterface<T>{
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

public class CollectionDemo{

    public static void main(String[] args) {
        GenImpl<String> str = new GenImpl<String>();
        str.show("加油");

        GenImpl<Integer> i = new GenImpl<>();
        i.show(30);
    }
}

五、类型通配符

为了表示各种泛型List的父类，可以使用类型通配符：

• 类型通配符：<?>
• List<?>：表示元素类型未知的List，它的元素可以匹配任何的类型
• 这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中

如果不希望List<?>是任何泛型的父类，只希望代表某一类泛型List的父类，可以使用类型通配符的上限。

• 类型通配符上限：<?extends类型>
• List<? extends Number>：表示的类型是Number或者其子类型

除了可以指定类型通配符的上限，也可以指定类型通配符的下限：

• 类型通配符下限：<?super类型>
• List<?super Number>：表示的类型是Number或者其父类型

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

public class CollectionDemo{

    public static void main(String[] args) {
        List<?> numbersList = new ArrayList<Number>();

        //类型通配符上限
        List<? extends Number> list1 = new ArrayList<Number>();
        List<? extends Number> list2 = new ArrayList<Integer>();

        //类型通配符下限
        List<? super Number> list3 = new ArrayList<Number>();

    }
}

在 Java 1.5 之前没有泛型，通常需要使用强制类型转换的方式将一种数据类型转换为另一种数据类型，这种转换要求开发者对实际参数的类型具有可预知性。对于强制类型转换错误的情况，编译器可能不会提示错误，但是在运行时会出现异常，这是一个安全隐患。

为了解决这一隐患，从 Java 1.5 开始提供了泛型。泛型可以在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高了代码的重用率。本节将详细介绍 Java 中泛型的使用。

泛型集合

泛型本质上是提供类型的“类型参数”，也就是参数化类型。我们可以为类、接口或方法指定一个类型参数，通过这个参数限制操作的数据类型，从而保证类型转换的绝对安全。

例 1

下面将结合泛型与集合编写一个案例实现图书信息输出。

(1) 首先需要创建一个表示图书的实体类 Book，其中包括的图书信息有图书编号、图书名称和价格。Book 类的具体代码如下：

1. public class Book
2. {
3. private int Id; //图书编号
4. private String Name; //图书名称
5. private int Price; //图书价格
6. public Book(int id,String name,int price)
7. { //构造方法
8. this.Id=id;
9. this.Name=name;
10. this.Price=price;
11. }
12. public String toString()
13. { //重写 toString()方法
14. return this.Id+", "+this.Name+"，"+this.Price;
15. }
16. }

(2) 使用 Book 作为类型创建 Map 和 List 两个泛型集合，然后向集合中添加图书元素，最后输出集合中的内容。具体代码如下：

1. import java.util.ArrayList;
2. import java.util.HashMap;
3. import java.util.List;
4. import java.util.Map;
5. public class Test14
6. {
7. public static void main(String[] args)
8. {
9. //创建3个Book对象
10. Book book1=new Book(1,"唐诗三百首",8);
11. Book book2=new Book(2,"小星星",12);
12. Book book3=new Book(3,"成语大全",22);
13. Map<Integer,Book> books=new HashMap<Integer,Book>(); //定义泛型 Map 集合
14. books.put(1001,book1); //将第一个 Book 对象存储到 Map 中
15. books.put(1002,book2); //将第二个 Book 对象存储到 Map 中
16. books.put(1003,book3); //将第三个 Book 对象存储到 Map 中
17. System.out.println("泛型Map存储的图书信息如下：");
18. for(Integer id:books.keySet())
19. {
20. //遍历键
21. System.out.print(id+"——");
22. System.out.println(books.get(id)); //不需要类型转换
23. }
24. List<Book> bookList=new ArrayList<Book>(); //定义泛型的 List 集合
25. bookList.add(book1);
26. bookList.add(book2);
27. bookList.add(book3);
28. System.out.println("泛型List存储的图书信息如下：");
29. for(int i=0;i<bookList.size();i++)
30. {
31. System.out.println(bookList.get(i)); //这里不需要类型转换
32. }
33. }
34. }

在该示例中，代码“Map<Integer,Book> books=new HashMap<Integer,Book>();”创建了一个键类型为 Integer、值类型为 Book 的泛型集合，即指明了该 Map 集合中存放的键必须是 Integer 类型、值必须为 Book 类型，否则编译出错。在获取 Map 集合中的元素时，不需要将"books.get(id);"获取的值强制转换为 Book 类型，程序会隐式转换。在创建 List 集合时，同样使用了泛型，因此在获取集合中的元素时也不需要将“bookList.get(i)”代码强制转换为 Book 类型，程序会隐式转换。

执行结果如下：

泛型Map存储的图书信息如下：
1001——1, 唐诗三百首，8
1003——3, 成语大全，22
1002——2, 小星星，12
泛型List存储的图书信息如下：
1, 唐诗三百首，8
2, 小星星，12
3, 成语大全，22

泛型类

除了可以定义泛型集合之外，还可以直接限定泛型类的类型参数。语法格式如下：

public class class_name<data_type1,data_type2,…>{}

其中，class_name 表示类的名称，data_ type1 等表示类型参数。Java 泛型支持声明一个以上的类型参数，只需要将类型用逗号隔开即可。

泛型类一般用于类中的属性类型不确定的情况下。在声明属性时，使用下面的语句：

1. private data_type1 property_name1;
2. private data_type2 property_name2;

该语句中的 data_type1 与类声明中的 datajype1 表示的是同一种数据类型。

例 2

在实例化泛型类时，需要指明泛型类中的类型参数，并赋予泛型类属性相应类型的值。例如，下面的示例代码创建了一个表示学生的泛型类，该类中包括 3 个属性，分别是姓名、年龄和性别。

1. public class Stu<N,A,S>
2. {
3. private N name; //姓名
4. private A age; //年龄
5. private S sex; //性别
6. //创建类的构造函数
7. public Stu(N name,A age,S sex)
8. {
9. this.name=name;
10. this.age=age;
11. this.sex=sex;
12. }
13. //下面是上面3个属性的setter/getter方法
14. public N getName()
15. {
16. return name;
17. }
18. public void setName(N name)
19. {
20. this.name=name;
21. }
22. public A getAge()
23. {
24. return age;
25. }
26. public void setAge(A age)
27. {
28. this.age = age;
29. }
30. public S getSex()
31. {
32. return sex;
33. }
34. public void setSex(S sex)
35. {
36. this.sex=sex;
37. }
38. }

接着创建测试类。在测试类中调用 Stu 类的构造方法实例化 Stu 对象，并给该类中的 3 个属性赋予初始值，最终需要输出学生信息。测试类的代码实现如下：

1. public class Test14
2. {
3. public static void main(String[] args)
4. {
5. Stu<String,Integer,Character> stu=new Stu<String,Integer,Character>("张晓玲",28,'女');
6. String name=stu.getName();
7. Integer age=stu.getAge();
8. Character sex=stu.getSex();
9. System.out.println("学生信息如下：");
10. System.out.println("学生姓名："+name+"，年龄："+age+"，性别："+sex);
11. }
12. }

该程序的运行结果如下：

学生信息如下：
学生姓名：张晓玲，年龄：28，性别：女

在该程序的 Stu 类中，定义了 3 个类型参数，分别使用 N、A 和 S 来代替，同时实现了这 3 个属性的 setter/getter 方法。在主类中，调用 Stu 类的构造函数创建了 Stu 类的对象，同时指定 3 个类型参数，分别为 String、Integer 和 Character。在获取学生姓名、年龄和性别时，不需要类型转换，程序隐式地将 Object 类型的数据转换为相应的数据类型。

泛型方法

到目前为止，我们所使用的泛型都是应用于整个类上。泛型同样可以在类中包含参数化的方法，而方法所在的类可以是泛型类，也可以不是泛型类。也就是说，是否拥有泛型方法，与其所在的类是不是泛型没有关系。

泛型方法使得该方法能够独立于类而产生变化。如果使用泛型方法可以取代类泛型化，那么就应该只使用泛型方法。另外，对一个 static 的方法而言，无法访问泛型类的类型参数。因此，如果 static 方法需要使用泛型能力，就必须使其成为泛型方法。

定义泛型方法的语法格式如下：

[访问权限修饰符][static][final]<类型参数列表>返回值类型方法名([形式参数列表])

例如：

1. public static List<T> find(Class<T>class,int userId){}

一般来说编写 Java 泛型方法，其返回值类型至少有一个参数类型应该是泛型，而且类型应该是一致的，如果只有返回值类型或参数类型之一使用了泛型，那么这个泛型方法的使用就被限制了。下面就来定义一个泛型方法，具体介绍泛型方法的创建和使用。

例 3

使用泛型方法打印图书信息。定义泛型方法，参数类型使用“T”来代替。在方法的主体中打印出图书信息。代码的实现如下：

1. public class Test16
2. {
3. public static<T> void List(T book)
4. { //定义泛型方法
5. if(book!=null)
6. {
7. System.out.println(book);
8. }
9. }
10. public static void main(String[] args)
11. {
12. Book stu=new Book(1,"细学 Java 编程",28);
13. List(stu); //调用泛型方法
14. }
15. }

该程序中的 Book 类为前面示例中使用到的 Book 类。在该程序中定义了一个名称为 List 的方法，该方法的返回值类型为 void，类型参数使用“T”来代替。在调用该泛型方法时，将一个 Book 对象作为参数传递到该方法中，相当于指明了该泛型方法的参数类型为 Book。

该程序的运行结果如下：

1, 细学 Java 编程，28

泛型的高级用法

泛型的用法非常灵活，除在集合、类和方法中使用外，本节将从三个方面介绍泛型的高级用法，包括限制泛型可用类型、使用类型通配符、继承泛型类和实现泛型接口。

1. 限制泛型可用类型

在 Java 中默认可以使用任何类型来实例化一个泛型类对象。当然也可以对泛型类实例的类型进行限制，语法格式如下：

class 类名称<T extends anyClass>

其中，anyClass 指某个接口或类。使用泛型限制后，泛型类的类型必须实现或继承 anyClass 这个接口或类。无论 anyClass 是接口还是类，在进行泛型限制时都必须使用 extends 关键字。

例如，在下面的示例代码中创建了一个 ListClass 类，并对该类的类型限制为只能是实现 List 接口的类。

1. //限制ListClass的泛型类型必须实现List接口
2. public class ListClass<T extends List>
3. {
4. public static void main(String[] args)
5. {
6. //实例化使用ArrayList的泛型类ListClass，正确
7. ListClass<ArrayList> lc1=new ListClass<ArrayList>();
8. //实例化使用LinkedList的泛型类LlstClass，正确
9. ListClass<LinkedList> lc2=new ListClass<LinkedList>();
10. //实例化使用HashMap的泛型类ListClass，错误，因为HasMap没有实现List接口
11. //ListClass<HashMap> lc3=new ListClass<HashMap>();
12. }
13. }

在上述代码中，定义 ListClass 类时设置泛型类型必须实现 List 接口。例如，ArrayList 和 LinkedList 都实现了 List 接口，所以可以实例化 ListClass 类。而 HashMap 没有实现 List 接口，所以在实例化 ListClass 类时会报错。

当没有使用 extends 关键字限制泛型类型时，其实是默认使用 Object 类作为泛型类型。因此，Object 类下的所有子类都可以实例化泛型类对象，如图 1 所示的这两种情况。
 

图1 两个等价的泛型类

2. 使用类型通配符

Java 中的泛型还支持使用类型通配符，它的作用是在创建一个泛型类对象时限制这个泛型类的类型必须实现或继承某个接口或类。

使用泛型类型通配符的语法格式如下：

泛型类名称<? extends List>a=null;

其中，“<? extends List>”作为一个整体表示类型未知，当需要使用泛型对象时，可以单独实例化。

例如，下面的示例代码演示了类型通配符的使用。

1. A<? extends List>a=null;
2. a=new A<ArrayList> (); //正确
3. b=new A<LinkedList> (); //正确
4. c=new A<HashMap> (); //错误

在上述代码中，同样由于 HashMap 类没有实现 List 接口，所以在编译时会报错。

3. 继承泛型类和实现泛型接口

定义为泛型的类和接口也可以被继承和实现。例如下面的示例代码演示了如何继承泛型类。

1. public class FatherClass<T1>{}
2. public class SonClass<T1,T2,T3> extents FatherClass<T1>{}

如果要在 SonClass 类继承 FatherClass 类时保留父类的泛型类型，需要在继承时指定，否则直接使用 extends FatherClass 语句进行继承操作，此时 T1、T2 和 T3 都会自动变为 Object，所以一般情况下都将父类的泛型类型保留。

下面的示例代码演示了如何在泛型中实现接口。

1. interface interface1<T1>{}
2. interface SubClass<T1,T2,T3> implements
3. Interface1<T2>{}