泛型

概述

1. 什么是泛型？
   泛型就是一个标签：<数据类型>
   泛型可以在编译阶段约束只能操作某种数据类型。
   注意：JDK 1.7开始之后，泛型后面的申明可以省略不写!!
   泛型和集合都只能支持引用数据类型，不支持基本数据类型。

2. 小结：
   泛型可以在编译阶段约束只能操作某种数据类型。
   泛型和集合都只能支持引用数据类型，不支持基本数据类型。
   JDK 1.7开始之后，泛型后面的申明可以省略不写!!

public class GenericityDemo {public static void main(String[] args) {//ArrayList<String> lists = new ArrayList<String>();ArrayList<String> lists = new ArrayList<>(); // JDK 1.7开始之后，泛型后面的申明可以省略不写!!lists.add("Java");lists.add("MySQL");
//      lists.add(false);
//      lists.add(99.9);
//      lists.add('a');System.out.println(lists);ArrayList<Integer> lists1 = new ArrayList<>();lists1.add(10);lists1.add(20);System.out.println(lists1);}
}

优势

这泛型在编译阶段约束了操作的数据类型，从而不会出现类型转换异常。
体现的是Java的严谨性和规范性，数据类型,经常需要进行统一！

	public class GenericityDemo {public static void main(String[] args) {ArrayList<String> lists = new ArrayList<>();lists.add("赵敏");lists.add("张无忌");
//        lists.add(false);  //不定义<>打印会报错
//        lists.add(99.9);for(int i = 0 ; i < lists.size() ; i++ ){String ele = lists.get(i);System.out.println(ele);}}
}

自定义泛型类

1. 引入：
   我们之前用的泛型都是别人写好的，接下来我们来自定义泛型类使用。

2. 泛型类的概念：
   使用了泛型定义的类就是泛型类。

3. 泛型类的格式：
   修饰符 class 类名<泛型变量>{

   }
   泛型变量建议使用 E , T , K , V

4. 需求：模拟ArrayList集合自定义一个集合MyArrayList集合。
   泛型类的核心思想：是把出现泛型变量的地方全部替换成传输的真实数据类型。

5. 小结：
   自定义泛型的核心思想：是把出现泛型变量的地方全部替换成传输的真实数据类型。

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>{  //自定义泛型类  需要的类型全为E!!!!private ArrayList lists = new ArrayList();public void add(E e){lists.add(e);}public void remove(E e){lists.remove(e);}@Overridepublic String toString() {return lists.toString();}
}

自定义泛型方法

1. 什么是泛型方法？
   定义了泛型的方法就是泛型方法。

2. 泛型方法的定义格式:
   修饰符 <泛型变量> 返回值类型 方法名称(形参列表){ }
   注意：方法定义了是什么泛型变量，后面就只能用什么泛型变量。

3. 泛型类的核心思想：是把出现泛型变量的地方全部替换成传输的真实数据类型。

4. 需求：给你任何一个类型的数组，都能返回它的内容。

5. 小结：
   泛型方法和泛型类可以做通用技术架构。

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);}
//T可以传任何类型，即实现了通用性。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. 泛型接口的格式：
   修饰符 interface 接口名称<泛型变量>{ }

3. 需求:教务系统，提供一个接口可约束一定要完成数据（学生，老师）的增删改查操作

4. 小结：
   泛型接口的核心思想，在实现接口的时候传入真实的数据类型
   这样重写的方法就是对该数据类型进行操作!

1.创建Data泛型接口

public interface Data<E> {void add(E stu);void delete(E stu);void update(E stu);E query(int id);
}

2.Teacher类继承泛型接口并重写方法

public class TeacherData implements Data<Teacher> {@Overridepublic void add(Teacher stu) {System.out.println("添加老师！");}@Overridepublic void delete(Teacher stu) {System.out.println("删除老师！");}@Overridepublic void update(Teacher stu) {}@Overridepublic Teacher query(int id) {return null;}
}

3.student类继承泛型接口并重写方法

public class StudentData implements Data<Student> {@Overridepublic void add(Student stu) {System.out.println("添加学生！");}@Overridepublic void delete(Student stu) {System.out.println("删除学生！");}@Overridepublic void update(Student stu) {}@Overridepublic Student query(int id) {return null;}
}

4.main调用

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. 注意：
   虽然BMW和BENZ都继承了Car
   但是ArrayList和ArrayList与ArrayList没有关系的！泛型没有继承关系！

3. 通配符：？
   ?可以用在使用泛型的时候代表一切类型。
   E , T , K , V是在定义泛型的时候使用代表一切类型。

4. 泛型的上下限：
   ? extends Car : 那么?必须是Car或者其子类。(泛型的上限)
   ? super Car :那么?必须是Car或者其父类。（泛型的下限。不是很常见）

5. 小结：
   通配符：?可以用在使用泛型的时候代表一切类型。
   ? extends Car : 那么?必须是Car或者其子类。(泛型的上限)

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());// run(dogs); // 就进不来了！}// 定义一个方法，可以让很多汽车一起进入参加比赛public static void run(ArrayList<? extends Car> cars){}
}
class Car{}
class BMW extends Car{}
class BENZ extends Car{}
class Dog{}