java泛型总结

概述

Java SE5的重大变化之一：泛型的概念。泛型实现了参数化类型的概念，使代码可以应用于多种类型。什么是泛型?参数化类型,定义类的时候不确定类型,使用类的时候确定类型，有点像变量一样可以变化,泛型的好处?只能存储指定的类型,将运行时的问题,提前到编译时,避免强制类型转换带来的失败问题

我们来看一下在没有泛型的时候会出现什么情况

public class Demo01 {
    public static void main(String[] args) {
        // 没有泛型的时候,看做Object类型,在取数据的时候强转就可能会失败.
        ArrayList list = new ArrayList();
        list.add("张三");
        list.add("李四");
        //list.add(111); //111是Integer类型,不能强制转换成String类型,在运行时会报错

        // 打印人名和长度
        for (int i = 0; i < list.size(); i++) {
            String name = (String) list.get(i);
            System.out.println(name + ",长度:" + name.length());
        }
        // 有了泛型的好处,只能存储指定的类型,将运行时的问题,提前到编译时,避免强制类型转换带来的失败问题
    }
}

泛型类
什么是泛型类?泛型定义在类上面就叫做泛型类

泛型类的格式

        class 类名 {
            修饰符 返回值类型 方法名(E 变量名) {

            }
        }

举一个例子

//定义车的时候,不确定装什么类型
public class Car {
    private E element; // 车装的东西

    public void setElement(E element) {
        this.element = element;
    }

    public E getElement() {
        return element;
    }
}

定义两个空壳类,表示车具体要装的东西

public class Person {
}

public class Pig {
}

使用类创建对象时确定类型

public class Demo02 {
    public static void main(String[] args) {
        // 2.使用类创建对象时确定类型
        Car c1 = new Car<>();
        c1.setElement(new Pig());

        Car c2 = new Car<>();
        c2.setElement(new Person());
        c2.getElement();
    }
}

泛型类的缺点:当创建对象时指定一种类型.就固定是这种类型

泛型方法

什么是泛型方法：泛型定义在方法上
泛型方法的好处：任何类型都能传入

    泛型方法格式:
        修饰符  返回值类型 方法名(E 变量名) {
        }

举个例子

public class Demo02 {
    public static void main(String[] args) {
        show("大家好");
        show(6.66);
        show(true);
        show('好');
    }

    public static  void show(T msg) {
        // 会将T看做Object类型
        System.out.println("msg = " + msg);
    }
}

泛型方法和普通方法的区别:
返回值类型前面添加，参数的类型就写E

泛型接口
什么是泛型接口? 泛型定义在接口上

    泛型接口的定义格式?
        interface 接口名 {
            public abstract 返回值类型 方法名(E 变量名);
        }

泛型接口的使用?
1.定义实现类时确定泛型的类型
2.定义类沿用泛型,创建对象时指定类型

1.定义实现类时确定泛型的类型
定义一个可游泳的接口,接口里面写一个游泳的抽象方法，子类来重写

public interface Swimmable {
    public abstract void swimming(E msg);
}

定义一个学生类来实现这个接口

// 1.定义实现类时确定泛型的类型
public class Student implements Swimmable {
    @Override
    public void swimming(String msg) {
        System.out.println("学生游泳时说: " + msg);
    }
}

使用类创建对象

public class Demo03 {
    public static void main(String[] args) {
        // 实现类已经确定传入的数据类型,创建对象时不需要再指定类型
        Student s = new Student();
        s.swimming("好爽啊");
    }
}

// 2.定义类沿用泛型,创建对象时指定类型

//实现接口时没有确定类型,需在new对象的时候指定传入的类型
public class Teacher implements Swimmable {
    @Override
    public void swimming(E msg) {
        System.out.println("老师游泳时说: " + msg);
    }
}

public class Demo04 {
    public static void main(String[] args) {
        // 2.定义类沿用泛型,创建对象时指定类型
        Teacher t1 = new Teacher<>();
        t1.swimming("好爽啊!");

        Teacher t2 = new Teacher<>();
        t2.swimming(666);
    }
}

一般情况下,用第二种方式的会比较多一些

泛型通配符

泛型通配符?: 表示右边的泛型可以是任意泛型

举个例子

import java.util.ArrayList;

public class Demo051 {
    public static void main(String[] args) {
        //       Object s  = new String();
        // 多态: 父类 变量名 = new 子类();
        // 泛型不存在多态,泛型左边和右边要一样
        // ArrayList