JAVA-泛型

泛型

泛型概述

泛型：是JDK5中引入的特性，可以在编译阶段约束操作的数据类型，并进行检查。

泛型的格式：<数据类型>; 注意：泛型只能支持引用数据类型。（基本数据类型使用包装类）

集合体系的全部接口和实现类都是支持泛型的使用的。

泛型的优点

• 统一数据类型。
• 把运行时期的问题提前到了编译期间，避免了强制类型转换可能出现的异常，因为编译阶段类型就能确定下来。

泛型可以在很多地方进行定义

类后面—————>泛型类。

方法申明上—————>泛型方法。

接口后面—————>泛型接口。

泛型类

泛型类：定义类时同时定义了泛型的类就是泛型类。

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

范例：

public class MyArrayList<T> {  }

此处泛型变量T可以随便写为任意标识，常见的如E、T、K、V等。

作用：编译阶段可以指定数据类型，类似于集合的作用。

示例1：需求：模拟ArrayList集合自定义一个集合MyArrayList集合,完成添加和删除功能的泛型设计即可。

import java.util.ArrayList;

public class test {
        public static void main(String[] args) {
                MyArrayList<Integer> list = new MyArrayList<>();
                list.add(56);
                list.add(89);
                list.add(99);
                list.add(88);
                list.remove(89);
                System.out.println(list);
        }
}
class MyArrayList<T>{
        private ArrayList<T> list = new ArrayList<T>();
        //利用装饰模式的思维，在类里new一个类
        public void add(T t){
                list.add(t);
        }
         //这不是泛型方法，这只是泛型类中的一个方法
        public void remove(T t){
                list.remove(t);
        }
        public String toString(){
                return list.toString();
        }
        }
//泛型类

运行结果：

[56, 99, 88]

泛型类的原理

把出现泛型变量的地方全部替换成传输的真实数据类型。

泛型方法

泛型方法：定义方法时同时定义了泛型的方法就是泛型方法。

泛型方法的格式：修饰符 <泛型变量> 方法返回值 方法名称(形参列表){}

范例;

public <T> void show(T t) {  }

作用：方法中可以使用泛型接收一切实际类型的参数，方法更具备通用性。

示例2：需求：给你任何一个类型的数组，都能返回它的内容。也就是实现Arrays.toString(数组)的功能！

public class test {
        public static void main(String[] args) {
                String[] s = {"篮球","两年半","鸡"};
                printArray(s);
                Integer[] a = {12,34,56,78,88};
                //泛型必须使用引用数据类型
                printArray(a);
                Integer[] a1 = null;
                printArray(a1);
        }
        public static <T> void printArray(T[] t){
                if(t!=null){
                        StringBuilder s = new StringBuilder("[");
                for (int i = 0; i < t.length; i++) {
                        s.append(t[i]).append(i==t.length-1?"":",");
                }
                        s.append("]");
                        System.out.println(s);
                }
                else {
                        System.out.println(t);
                }

        }
}

运行结果：

[篮球,两年半,鸡]
[12,34,56,78,88]
null

泛型方法的原理

把出现泛型变量的地方全部替换成传输的真实数据类型。

泛型接口

泛型接口：使用了泛型定义的接口就是泛型接口。

泛型接口的格式：修饰符 interface 接口名称<泛型变量>{}

范例：

public interface Data<E>{}

作用：泛型接口可以让实现类选择当前功能需要操作的数据类型。

示例3：需求;教务系统，提供一个接口可约束一定要完成数据（学生，老师）的增删改查操作（不用实现，只要体现思想）

定义一个Data接口

public interface Data<T> {
    void add(T t);
    void delete(T t);
    void update(T t);
    T queryById(int id);
}

定义Student，Teacher类

public class Student {
    private int id;
    private String name;

    public Student() {
    }

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Teacher {
    private int id;
    private String name;
    private String course;

    public Teacher() {
    }

    public Teacher(int id, String name, String course) {
        this.id = id;
        this.name = name;
        this.course = course;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getCourse() {
        return course;
    }

    public void setCourse(String course) {
        this.course = course;
    }
}

实现类StudentData

public class StudentData implements Data<Student>{
    @Override
    public void add(Student student) {

    }

    @Override
    public void delete(Student student) {

    }

    @Override
    public void update(Student student) {

    }

    @Override
    public Student queryById(int id) {
        return null;
    }
}

实现类TeacherData

public class TeacherData implements Data<Teacher>{
    @Override
    public void add(Teacher teacher) {
        
    }

    @Override
    public void delete(Teacher teacher) {

    }

    @Override
    public void update(Teacher teacher) {

    }

    @Override
    public Teacher queryById(int id) {
        return null;
    }
}

泛型通配符、上下限

通配符：“?” 可以在“使用泛型”的时候代表一切类型。(E T K V 是在定义泛型的时候使用的。)

补充：<?>表示任何一种对象类型，等价于<? extends Object>。

泛型的上下限:

? extends Car: ?必须是Car或者其子类 泛型上限

? super Car ： ?必须是Car或者其父类 泛型下限

示例4：需求：模拟汽车比赛（体现思想即可）

import java.util.ArrayList;

public class GenericDemo {
    public static void main(String[] args) {
        
    }
    public static void go(ArrayList<? extends Car> cars){

    }
}
class Car{

}
class BMW extends Car{

}
class BENZ extends Car{

}

注意：虽然BMW和BENZ都继承了Car但是ArrayList<BWM>和ArrayList<BENZ>与ArrayList<Car>没有关系的！!

问题

1、泛型类的核心思想

把出现泛型变量的地方全部替换成传输的真实数据类型。

2、泛型类的作用

编译阶段约定操作的数据的类型，类似于集合的作用。

3、泛型方法的核心思想

把出现泛型变量的地方全部替换成传输的真实数据类型。

4、泛型方法的作用

方法中可以使用泛型接收一切实际类型的参数，方法更具备通用性

5、泛型接口的作用

泛型接口可以约束实现类，实现类可以在实现接口的时候传入自己操作的数据类型这样重写的方法都将是针对于该类型的操作。