泛型
概述
什么是泛型?
泛型就是一个标签:<数据类型>
泛型可以在编译阶段约束只能操作某种数据类型。
注意:JDK 1.7开始之后,泛型后面的申明可以省略不写!!
泛型和集合都只能支持引用数据类型,不支持基本数据类型。小结:
泛型可以在编译阶段约束只能操作某种数据类型。
泛型和集合都只能支持引用数据类型,不支持基本数据类型。
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);
}
}
}
自定义泛型类
引入:
我们之前用的泛型都是别人写好的,接下来我们来自定义泛型类使用。泛型类的概念:
使用了泛型定义的类就是泛型类。泛型类的格式:
修饰符 class 类名<泛型变量>{}
泛型变量建议使用 E , T , K , V需求:模拟ArrayList集合自定义一个集合MyArrayList集合。
泛型类的核心思想:是把出现泛型变量的地方全部替换成传输的真实数据类型。小结:
自定义泛型的核心思想:是把出现泛型变量的地方全部替换成传输的真实数据类型。
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);
}
@Override
public String toString() {
return lists.toString();
}
}
自定义泛型方法
什么是泛型方法?
定义了泛型的方法就是泛型方法。泛型方法的定义格式:
修饰符 <泛型变量> 返回值类型 方法名称(形参列表){ }
注意:方法定义了是什么泛型变量,后面就只能用什么泛型变量。泛型类的核心思想:是把出现泛型变量的地方全部替换成传输的真实数据类型。
需求:给你任何一个类型的数组,都能返回它的内容。
小结:
泛型方法和泛型类可以做通用技术架构。
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();
}
}
泛型接口的使用
什么是泛型接口?
使用了泛型定义的接口就是泛型接口。泛型接口的格式:
修饰符 interface 接口名称<泛型变量>{ }需求:教务系统,提供一个接口可约束一定要完成数据(学生,老师)的增删改查操作
小结:
泛型接口的核心思想,在实现接口的时候传入真实的数据类型
这样重写的方法就是对该数据类型进行操作!
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> {
@Override
public void add(Teacher stu) {
System.out.println("添加老师!");
}
@Override
public void delete(Teacher stu) {
System.out.println("删除老师!");
}
@Override
public void update(Teacher stu) {
}
@Override
public Teacher query(int id) {
return null;
}
}
3.student类继承泛型接口并重写方法
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;
}
}
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());
}
}
通配符和上下限
需求:开发一个极品飞车的游戏,所有的汽车都能一起参与比赛。
注意:
虽然BMW和BENZ都继承了Car
但是ArrayList和ArrayList与ArrayList没有关系的!泛型没有继承关系!通配符:?
?可以用在使用泛型的时候代表一切类型。
E , T , K , V是在定义泛型的时候使用代表一切类型。泛型的上下限:
? extends Car : 那么?必须是Car或者其子类。(泛型的上限)
? super Car :那么?必须是Car或者其父类。(泛型的下限。不是很常见)小结:
通配符:?可以用在使用泛型的时候代表一切类型。
? 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{}