Java泛型：概述、自定义泛型类、方法、接口、泛型通配符上下限

Java多态详解
Java内部类详解

1.概述

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

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

代码示例

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

public class Fan {
    public static void main(String[] args) {
        List list=new ArrayList();

        list.add("Java");
        list.add("HTML");
        list.add(11);
        list.add(22);

        //定义时没有指定类型，就要使用Object来承接 因此可以直接定义为 List<Object> list2 = new ArrayList<>();
        for(Object i:list){
            System.out.println(i);
        }

//        而泛型的存在就是要求指定数据类型，避免引发其它异常问题。
//        泛型就是一个标签：<数据类型> 
//        泛型可以在编译阶段约束只能操作某种数据类型。
    }
}

2.自定义泛型类

泛型类介绍

1.定义类时同时定义了泛型的类就是泛型类；

泛型类的格式

修饰符 class 类名<泛型变量>{
}

范例：
public class MyArrayList<T> {
}

1.此处泛型变量T可以随便写为任意标识，常见的如E、T、K、V等;
2.作用：编译阶段约束操作的数据类型，类似于集合的作用;

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

代码示例

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

Test.java

public class Test {
    public static void main(String[] args) {
        // 需求：模拟ArrayList定义一个MyArrayList ，关注泛型设计
        MyArrayList<String> list = new MyArrayList<>();
        list.add("Java");
        list.add("Java");
        list.add("MySQL");
        list.remove("MySQL");
        System.out.println(list);

        MyArrayList<Integer> list2 = new MyArrayList<>();
        list2.add(23);
        list2.add(24);
        list2.add(25);
        list2.remove(25);
        System.out.println(list2);
    }
}

MyArrayList.java

import java.util.ArrayList;

public class MyArrayList<E> {
	//本例主要是为了理解泛型类的定义，因此不关注具体实现，而是借用ArrayList
    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();
    }
}

3.自定义泛型方法

泛型方法介绍

泛型方法的概述
1.定义方法时同时定义了泛型的方法就是泛型方法；

泛型方法的格式

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

范例： 
public <T> void show(T t) {
}

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

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

代码示例

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

/**
    目标：自定义泛型方法。

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

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

        }
        注意：方法定义了是什么泛型变量，后面就只能用什么泛型变量。
        泛型类的核心思想：是把出现泛型变量的地方全部替换成传输的真实数据类型。

    需求：给你任何一个类型的数组，都能返回它的内容。Arrays.toString(数组)的功能！

    小结：
        泛型方法可以让方法更灵活的接收数据，可以做通用技术！
 */
public class GenericDemo {
    public static void main(String[] args) {
        String[] names = {"小璐", "蓉容", "小何"};
        printArray(names);

        Integer[] ages = {10, 20, 30};
        printArray(ages);

        Integer[] ages2 = getArr(ages);
        String[]  names2 = getArr(names);
    }

    public static <T> T[] getArr(T[] arr){
        return arr;
    }

    public static <T> void printArray(T[] arr){
        if(arr != null){
            StringBuilder sb = new StringBuilder("[");
            for (int i = 0; i < arr.length; i++) {
                sb.append(arr[i]).append(i == arr.length - 1 ? "" : ", ");
            }
            sb.append("]");
            System.out.println(sb);
        }else {
            System.out.println(arr);
        }
    }
}

3.自定义泛型接口

泛型接口介绍

泛型接口的概述

1. 使用了泛型定义的接口就是泛型接口；

泛型接口的格式

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

范例： 
public interface Data<E>{
}

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

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

代码示例

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

GenericDemo.java

public class GenericDemo {
    public static void main(String[] args) {
		//在该类中调用数据的各种方法：增删改查
    }
}

Student.java

public class Student {
	//该类中定义学生对象的各项信息，如姓名。学号、成绩
}

StudentData.java

public class StudentData implements Data<Student>{
	//该类是数据接口Data的实现类，在定义的同时声明了只传入Student类型
    @Override
    public void add(Student student) {

    }

    @Override
    public void delete(int id) {

    }

    @Override
    public void update(Student student) {

    }

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

Teacher.java

public class Teacher {
	//同Student类
}

TeacherData.java

public class TeacherData implements Data<Teacher>{
	//同StudentData类
    @Override
    public void add(Teacher teacher) {

    }

    @Override
    public void delete(int id) {

    }

    @Override
    public void update(Teacher teacher) {

    }

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

Data.java

public interface Data<E> {
	//接口定义类，规范对学生、教师的操作方法
    void add(E e);
    void delete(int id);
    void update(E e);
    E queryById(int id);
}

5.泛型通配符、上下限

泛型通配符、上下限

通配符：？
1.? 可以在“使用泛型”的时候代表一切类型；
2. E T K V 是在定义泛型的时候使用的；

泛型的上下限
1.? extends Car: ?必须是Car或者其子类 泛型上限；
2.? super Car ： ?必须是Car或者其父类 泛型下限；

代码示例
开发一个极品飞车的游戏，所有的汽车都能一起参与比赛。

GenericDemo.java

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());
        go(bmws);

        ArrayList<BENZ> benzs = new ArrayList<>();
        benzs.add(new BENZ());
        benzs.add(new BENZ());
        benzs.add(new BENZ());
        go(benzs);

        ArrayList<Dog> dogs = new ArrayList<>();
        dogs.add(new Dog());
        dogs.add(new Dog());
        dogs.add(new Dog());
        // go(dogs);
    }

    /**
       所有车比赛
	   有了上下限，可以避免乱传参，万一把Dog传过来怎么办？
	 */
    public static void go(ArrayList<? extends Car> cars){  
    }
}

class Dog{

}

class BENZ extends Car{
}

class BMW extends Car{
}

// 父类
class Car{
}