泛型的使用

泛型

泛型的概念

Java泛型是一种在编译时期进行类型检查和类型安全的机制，它可以让我们在编写代码时指定参数或返回值的类型，从而提高代码的可读性和可维护性。

孩童的智商可能还不足以理解泛型的具体概念和实现细节，但是我们可以通过类比的方式来帮助他们理解。

可以将泛型比喻为一个容器，这个容器可以存放不同类型的对象。就像一个玩具箱，可以放入不同种类的玩具，但是每个玩具都有自己的特点和功能。

孩童可以将泛型看作是一个多功能的盒子，可以根据需要放入不同类型的对象。比如，可以有一个盒子专门放玩具车，另一个盒子专门放娃娃。这样，当孩童需要玩具车时，就可以从玩具车盒子中取出玩具车，而不会取出其他类型的玩具。

在Java中，泛型的使用方式类似于上面的例子。我们可以定义一个泛型类或泛型方法，然后在使用时指定具体的类型。这样，编译器会在编译时期进行类型检查，确保我们只能使用指定类型的对象。

例如，我们可以定义一个泛型类Box，用来存放不同类型的对象：

public class Box<T> {
    private T item;

    public void setItem(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }
}

然后，孩童可以将Box看作是一个玩具箱，可以放入不同类型的玩具：

Box<Car> carBox = new Box<>();
carBox.setItem(new Car());

Box<Doll> dollBox = new Box<>();
dollBox.setItem(new Doll());

在上面的例子中，carBox是一个Box对象，它只能存放Car类型的对象；dollBox是另一个Box对象，它只能存放Doll类型的对象。这样，孩童就可以根据需要选择不同类型的玩具箱，并确保只能取出相应类型的玩具。

通过这种类比的方式，孩童可以初步理解Java泛型的概念和用法，尽管可能还不完全理解其中的技术细节。随着孩童的成长和学习，他们可以逐渐深入理解泛型的原理和更复杂的用法。

泛型的格式

• <类型>：指定一种类型的格式，这里的类型可以看成是形参

• <类型1, 类型2……>：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参

• 将来具体调用时，给定的类型可以看成是实参，并且实参的类型只能是引用数据类型

泛型的好处

• 把运行时期的问题提到了编译期间

• 避免了强制数据类型转换的问题

泛型类的定义和使用

• 泛型类的定义格式

  • 格式：修饰符 class 类名<类型>{}

  • 范例：public class Generic{}

    此处 T 可以是任意标识符，常见的有 T、E、K、V 等形式的参数，常用于表示泛型

demo:

创建一个泛型类

package com.itxiaosi.demo01;

/**
 * @Classname : Generic
 * @Description : TODO 泛型类
 * @Author : [email protected]
 */
public class Generic<T> {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

定义一个学生类

package com.itxiaosi.demo01;

/**
 * @Classname : Student
 * @Description : TODO 学生类
 * @Author : [email protected]
 */
public class Student {
    //学生类的两个基本属性
    private String name; //姓名
    private int age; // 年龄

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试泛型类

package com.itxiaosi.demo01;

/**
 * @Classname : GenericTest
 * @Description : TODO 泛型类测试
 * @Author : [email protected]
 */
public class GenericTest {
    public static void main(String[] args) {
        //TODO 泛型括号里面的类型必须是引用数据类型
        //1.String类型放入
        Generic<String> strG = new Generic<>();
        strG.setT("我是一个字符串");
        String str = strG.getT();
        System.out.println(str); // 我是一个字符串
        System.out.println("====================");
        //2.Integer类型放入
        Generic<Integer> intG = new Generic<>();
        intG.setT(9527);
        Integer interG = intG.getT();
        System.out.println(interG); // 9527
        System.out.println("===================");
        //3.定义的学生类放入
        Generic<Student> StuG = new Generic<>();
        StuG.setT(new Student("小肆",20));
        Student Stud = StuG.getT();
        System.out.println(Stud);
    }
}

运行结果：

泛型方法

• 泛型方法的定义格式

  • 格式：修饰符 <类型> 返回值类型 方法名(类型名 变量名){}

  • 范例：public void show(T t)

个人理解泛型方法，可以避免同一个方法多次重载

package com.itxiaosi.demo02;

/**
 * @Classname : Generic
 * @Description : TODO 泛型方法
 * @Author : [email protected]
 */
public class Generic {
    //泛型方法
    public <T> void show(T t){
        System.out.println(t);
    }
}

泛型方法测试

package com.itxiaosi.demo02;

import com.itxiaosi.demo01.Student;

/**
 * @Classname : GenericTest
 * @Description : TODO 泛型方法测试类
 * @Author : [email protected]
 */
public class GenericTest {
    public static void main(String[] args) {
        Generic Gen = new Generic();
        Gen.show("莲");
        Gen.show(1231);
        Gen.show(new Student("小肆",12));
    }
}

运行结果：

泛型接口

• 泛型接口的定义格式

  • 格式：修饰符 interface 接口名<类型>{}

  • 范例：public interface Generic{}

demo:

泛型接口实现类

泛型接口测试

运行结果

泛型通配符

为了表示各种泛型 List 的父类，可以使用类型通配符

• 类型通配符：

• List ：表示类型未知的 List，它的元素可以匹配 任意类型

• 这种带通配符的 List 仅表示它是 各种泛型 List 的父类，并不能把元素添加到其中

如果说我们不希望 List 是任何泛型 List 的父类， 只希望他代表某一泛型 List 的父类，可以使用类型通配符的上限

• 类型通配符上限：

• List ：它表示类型是 Number 或者其子类型

除了可以指定类型通配符的上限，我们还可以指定类型通配符的下限

• 类型通配符的下限：

• List ：它表示的类型是 Number 或者其父类型

可以理解为泛型限制符，不能随意写入

package com.itxiaosi.demo04;

import com.itxiaosi.demo01.Student;

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

/**
 * @Classname : demo01
 * @Description : TODO 泛型通配符（泛型的限制）
 * @Author : [email protected]
 */
public class demo01 {
    public static void main(String[] args) {
        // : 尖括号里面的?等同于是 Object ,是所有类的父类，可以随意写入
        List<?> list = new ArrayList<Object>();
        //可以随意放入其他引用数据类型
        List<?> list01 = new ArrayList<Integer>();
        List<?> list02 = new ArrayList<String>();
        List<?> list03 = new ArrayList<Student>();
        //****************************************************
        // // 表示继承的上限例如  写入泛型只能写入 Number和继承Number的子类
        List<? extends Number> list07 = new ArrayList<Number>();
        List<? extends Number> list04 = new ArrayList<Integer>();
        List<? extends Number> list05 = new ArrayList<Float>();
        List<? extends Number> list06 = new ArrayList<Double>();
        //例如：写入一个没有继承Number的类或者Number的类则是超过上限，出现异常
       // List list08 = new ArrayList