什么是泛型？
1
2
| 泛型就是一个标签：<数据类型>
泛型可以在编译阶段约束只能操作某种数据类型
|
注意：JDK 1.7开始之后，泛型后面的申明可以省略不写!!
泛型和集合都只能支持引用数据类型，不支持基本数据类型!
泛型的好处
1
2
| 泛型在编译阶段约束了操作的数据类型，从而不会出现类型转换异常。
体现的是Java的严谨性和规范性，数据类型,经常需要进行统一！
|
自定义泛型类
泛型类的概念
泛型类的格式
1
2
3
4
| 修饰符 class 类名<泛型变量>{
}
泛型变量建议使用 E , T , K , V
|
需求
1
| 模拟ArrayList集合自定义一个集合MyArrayList集合
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| public class GenericDemo {
public static void main(String[] args) {
MyArrayList<String> lists = new MyArrayList<String>();
MyArrayList<String> lists1 = new MyArrayList<>();
lists1.add("java");
lists1.add("mysql");
lists1.remove("java");
System.out.println(lists1);
}
}
class MyArrayList<E>{
private ArrayList lists = new ArrayList();
public void add(E e){
lists.add(e);
}
public void remove(E e){
lists.remove(e);
}
@Override
public String toString() {
return lists.toString();
}
}
|
泛型类的核心思想
1
| 是把出现泛型变量的地方全部替换成传输的真实数据类型。
|
自定义泛型方法
什么是泛型方法？
泛型方法的定义格式
1
2
3
| 修饰符 <泛型变量> 返回值类型 方法名称(形参列表){
}
|
注意：方法定义了是什么泛型变量，后面就只能用什么泛型变量。
泛型类的核心思想
1
| 是把出现泛型变量的地方全部替换成传输的真实数据类型。
|
需求
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| public class GenericDemo {
public static void main(String[] args) {
Integer[] nums = {10 , 20 , 30 , 40 , 50};
String rs1 = arrToString(nums);
System.out.println(rs1);
String[] names = {"贾乃亮","王宝绿","陈羽凡"};
String rs2 = arrToString(names);
System.out.println(rs2);
}
public static <T> String arrToString(T[] nums){
StringBuilder sb = new StringBuilder();
sb.append("[");
if(nums!=null && nums.length > 0){
for(int i = 0 ; i < nums.length ; i++ ){
T ele = nums[i];
sb.append(i == nums.length-1 ? ele : ele+", ");
}
}
sb.append("]");
return sb.toString();
}
}
|
泛型接口
什么是泛型接口
泛型接口的格式
1
2
3
| 修饰符 interface 接口名称<泛型变量>{
}
|
需求
1
| 教务系统，提供一个接口可约束一定要完成数据（学生，老师）的增删改查操作
|
1
2
3
4
5
6
| public interface Data<E> {
void add(E stu);
void delete(E stu);
void update(E stu);
E query(int id);
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
public class StudentData implements Data<Student> {
@Override
public void add(Student stu) {
System.out.println("添加学生！");
}
@Override
public void delete(Student stu) {
System.out.println("删除学生！");
}
@Override
public void update(Student stu) {
}
@Override
public Student query(int id) {
return null;
}
}
|
1
2
| public class Student {
}
|
1
2
3
4
5
6
7
8
9
10
11
| public class GenericDemo {
public static void main(String[] args) {
StudentData data = new StudentData();
data.add(new Student());
data.delete(new Student());
TeacherData data1 = new TeacherData();
data1.add(new Teacher());
data1.delete(new Teacher());
}
}
|
泛型通配符
通配符
1
2
| ?可以用在使用泛型的时候代表一切类型。
E , T , K , V是在定义泛型的时候使用代表一切类型。
|
注意：虽然BMW和BENZ都继承了Car,但是ArrayList和ArrayList与ArrayList没有关系的！泛型没有继承关系！
泛型的上下限
1
2
| ? extends Car : 那么?必须是Car或者其子类。(泛型的上限)
? super Car :那么?必须是Car或者其父类。（泛型的下限。不是很常见）
|
需求
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
| public class GenericDemo {
public static void main(String[] args) {
ArrayList<BMW> bmws = new ArrayList<>();
bmws.add(new BMW());
bmws.add(new BMW());
bmws.add(new BMW());
run(bmws);
ArrayList<BENZ> benzs = new ArrayList<>();
benzs.add(new BENZ());
benzs.add(new BENZ());
benzs.add(new BENZ());
run(benzs);
ArrayList<Dog> dogs = new ArrayList<>();
dogs.add(new Dog());
dogs.add(new Dog());
dogs.add(new Dog());
}
public static void run(ArrayList<? extends Car> cars){
}
}
class Car{
}
class BMW extends Car{
}
class BENZ extends Car{
}
class Dog{
}
|