java 泛型深入

java 泛型深入

1.泛型的概述

泛型概述

• 泛型：是JDK5中引入的特性。可以在编译阶段约束操作的数据类型，并进行检查
• 泛型的格式：<数据类型>；注意：泛型只能支持引用数据类型
• 集合体系的全部接口和实现类都是支持泛型的使用的

泛型的好处:

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

泛型可以在很多地方定义

类后面 ------> 泛型类

方法声明上面 ------> 泛型方法

接口后面 ------> 泛型接口

2.自定义泛型

泛型类的概述

• 定义类的同时定义了泛型的类就是泛型类
• 泛型类的格式：修饰符 class 类名 <泛型变量>{}

public class MyArrayList<E>{
    
}

• 此处泛型变量E可以随便写为任意标识
• 作用：编译阶段可以指定数据类型，类似于集合的作用

泛型类的原理

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

实例：

import java.util.ArrayList;

public class MyArrayList<E> {
    //模拟出ArrayList的内部功能

    ArrayList list = new ArrayList<>();

    public void add(E e){
        list.add(e);
    }

    public void remove(E e){
        list.remove(e);
    }

    @Override
    public String toString(){
        return list.toString();
    }
}



---------------------------------------

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

public class Test {
    public static void main(String[] args) {
        MyArrayList<String> list = new MyArrayList<>();
        list.add("java");
        list.add("mySql");
        list.add("HTML");
        list.add("java");
        list.add("java");
        System.out.println(list);

        list.remove("mySql");
        System.out.println(list.toString());

    }
}

3.自定义泛型方法

泛型方法的概述

• 定义方法同时定义了泛型的方法就是泛型方法
• 泛型方法的格式： 修饰符 <泛型变量>方法返回值 方法名称（形参列表）{}

public<E> void show(E e){
    //方法体
}

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

泛型方法的原理

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

public class Test {
    public static void main(String[] args) {
        Integer[] arr1 = new Integer[]{1, 432, 342, 3545643};
        String[] arr2 = new String[]{"dad", "dsafd", "fdfdd"};
        
        print(arr1);
        print(arr2);

    }

    public static<E> void print(E[] e){
        StringBuilder sb = new StringBuilder("[");

        for (int i = 0; i < e.length; i++) {
            sb.append(e[i]).append(i == e.length-1 ? "" : ",");
        }
        sb.append("]");
        System.out.println(sb);
    }
}

4.自定义泛型接口

泛型接口的概述

• 使用泛型定义的接口就是泛型接口
• 泛型接口的格式：修饰符 interface 接口名<泛型变量>{}

public interface MyInterface<E>{
    
}

泛型接口的原理：

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

public interface data <E>{
    void update(E e);
    void query(E e);
}
--------------------------------
    

public class Student implements data<Student>{
    private int id;
    private String name;
    private double score;

    @Override
    public void update(Student student) {

    }

    @Override
    public void query(Student student) {

    }
}
   

-----------------------------------
    


public class Teacher implements data<Teacher> {
    private int id;
    private String name;
    private double salary;

    @Override
    public void update(Teacher teacher) {

    }

    @Override
    public void query(Teacher teacher) {

    }
}

5.泛型通配符，上下限

通配符：？

• ？可以在“使用泛型”的时候代表一切类型
• E T K V是在定义泛型的时候使用的

泛型的上下限

• ？extends Car : ?必须是Car或者其子类 泛型上限
• ？super Car : ?必须是Car或者其父类 泛型下限

实例

/*
    理解泛型通配符，极其上下限
 */

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList<Benz> benzs = new ArrayList<>();
        benzs.add(new Benz());
        benzs.add(new Benz());
        benzs.add(new Benz());
        go(benzs);

        ArrayList<BMW> BMWs = new ArrayList<>();
        BMWs.add(new BMW());
        BMWs.add(new BMW());
        BMWs.add(new BMW());
        go(BMWs);




    }

    public static void go(ArrayList<? extends Car> cars){

    }

}

class Car{

}

class Benz extends Car{

}

class BMW extends Car{

}