一、为什么使用泛型
  • 使用泛型后，集合中元素数据更统一了。
  • 泛型这种语法机制只在程序编译阶段起作用，只是给编译器参考的。（运行阶段泛型没用）
二、使用泛型的优缺点
  • 优点：从集合中取出的元素类型是泛型指定的类型，不需要进行大量的向下转型。
  • 缺点：导致集合中储存的元素缺乏多样性

大多数业务中，集合元素类型还是统一的，所以这种类型被大家认可。

三、泛型基础

1.泛型类

  • 泛型类就是把泛型定义在类上，用户使用该类的时候，才把类型明确下来....这样的话，用户明确了什么类型，该类就代表着什么类型...用户在使用的时候就不用担心强转的问题，运行时转换异常的问题了。
  • 在类上定义的泛型，在类的方法中也可以使用

/*
    //1:把泛型定义在类上
    //2:类型变量定义在类上,方法中也可以使用
 */
public class ObjectTool<T> {
private T obj;
 
public T getObj() {
return obj;
    }
 
public void setObj(T obj) {
this.obj = obj;
    }
}

用户想要使用哪种类型，就在创建的时候指定类型。使用的时候，该类就会自动转换成用户想要使用的类型了。

public static void main(String[] args) {
        //创建对象并指定元素类型
        //jdk8后引入了：自动类型推断机制。（又称钻石表达式）
        ObjectTool<String> tool = new ObjectTool<>();
 
        tool.setObj("哈哈哈");
        String s = tool.getObj();
        System.out.println(s);
 
 
        //创建对象并指定元素类型
        ObjectTool<Integer> objectTool = new ObjectTool<>();
        /**
         * 如果我在这个对象里传入的是String类型的,它在编译时期就通过不了了.
         */
        objectTool.setObj(10);
        int i = objectTool.getObj();
        System.out.println(i);
    }

2.泛型方法

  • 某一个方法上需要使用泛型....外界仅仅是关心该方法，不关心类其他的属性
  1. 定义泛型方法（泛型是先定义后使用的）
//定义泛型方法..
public <T> void show(T t) {
        System.out.println(t);
 
    }

用户传递进来的是什么类型，返回值就是什么类型了

public static void main(String[] args) {
        //创建对象
        ObjectTool tool = new ObjectTool();
 
        //调用方法,传入的参数是什么类型,返回值就是什么类型
        tool.show("hello");
        tool.show(12);
        tool.show(12.5);
 
    }

3.泛型类派生出的子类

  • 泛型类是拥有泛型这个特性的类，它本质上还是一个Java类，那么它就可以被继承，那么怎么继承呢？
  • 子类明确泛型类的类型参数变量
  • 子类不明确泛型类的类型参数变量

3.1子类明确泛型类的类型参数变量

  • 泛型接口
/*
    把泛型定义在接口上
 */
public interface Inter<T> {
public abstract void show(T t);
 
}
  • 实现接口
/**
 * 子类明确泛型类的类型参数变量:
 */
 
public class InterImpl implements Inter<String> {
    @Override
public void show(String s) {
        System.out.println(s);
 
    }
}

3.2子类不明确泛型类的类型参数变量

  • 当子类不明确泛型类的类型参数变量时，外界使用子类的时候，也需要传递类型参数变量进来，在实现类上需要定义出类型参数变量
/**
 * 子类不明确泛型类的类型参数变量:
 *      实现类也要定义出<T>类型的
 *
 */
public class InterImpl<T> implements Inter<T> {
 
    @Override
public void show(T t) {
        System.out.println(t);
 
    }
}
  • 测试
public static void main(String[] args) {
        //测试子类明确泛型类的类型参数变量
        //Inter i = new InterImpl();
        //i.show("hello");
 
        //测试子类不明确泛型类的类型参数变量
        Inter<String> ii = new InterImpl<>();
        ii.show("100");
 
    }

注：类上声明的泛形只对非静态成员有效