泛型深入

泛型概述

• 泛型：是JDK5引入的特性，可以在编译阶段约束操作的数据类型，并进行检查。
• 泛型的格式：<数据类型>
• 注意：泛型只能支持引用数据类型

没有使用泛型的时候：

1.如果我们没有给集合指定类型，默认认为所有的数据类型都是Object类型

2.此时可以往集合添加任意的数据类型

3.坏处就是我们在获取数据的时候，无法使用他的特有行为

4.这种时候就推出了泛型，可以把添加数据的时候就把类型进行统一

好处：

1.统一数据类型

2.在运行时期的问题提前到了编译期间，避免了强制类型转换可能出现的异常，因为在编译阶段类型就确定下来了

Java中的而泛型其实是一个伪泛型，因为只是在存的时候做了个数据判断，实际上存进去的还是Object类型的数据

细节：

1.泛型中不能写基本数据类型，必须写他的包装类

2.指定泛型的具体类型后，传递数据是，可以传入该类型或者其子类型（继承）

3.如果不写泛型，类型默认的是Object

泛型类

• 使用场景：当一个类中，某个变量的数据类型不确定时，就可以定义带有泛型的类、
• 格式: 修饰符 class 类名<类型>{}
• 例如：public class ArrayList
  {} 创建该类对象时，E就确定类型
  

此处的E可以理解为变量，但是不是用来记录数据的，而是记录数据的类型，可以写成:E，T，K，V等

泛型方法

方法中形参类型不确定时，可以使用类后面定义的泛型

例如：

public<E> boolean add(E e){
    return true;
}

方法一：使用类后面定义的泛型 (所有方法都可以用)

方法二：在方法声明定义自己的泛型 (只有本方法能用)

泛型方法类型练习

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        //定义一个工具类：ListUtil
        //类中定义一个静态方法addAll，用来添加多个集合的元素
        ArrayList<String> list=new ArrayList<>();
        ListUtil.addAll(list,"aaa","bbb");
        System.out.println(list);
    }
}

import java.util.ArrayList;

public class ListUtil<E> {
    private ListUtil(){}

    public static<E> void addAll(ArrayList<E> list,E...e){
        for (E element:e) {
            list.add(element);
        }
    }
}

泛型接口

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

重点：如何使用一个带泛型的接口

方式1：实现类给出具体类型

方式2：实现类延续泛型，创建对象时候再确定

方式1代码演示：

public class Demo1 {
    public static void main(String[] args) {
        /*方式1：实现类给出具体类型

         方式2：实现类延续泛型，创建对象时候再确定*/
        MyArrayList2 list=new MyArrayList2();
        list.add("123");
    }
}

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class MyArrayList2 implements List<String> {
    @Override
    public int size() {
        return 0;
    }

    @Override
    public boolean isEmpty() {
        return false;
    }

    @Override
    public boolean contains(Object o) {
        return false;
    }

    @Override
    public Iterator<String> iterator() {
        return null;
    }

    @Override
    public Object[] toArray() {
        return new Object[0];
    }

    @Override
    public <T> T[] toArray(T[] a) {
        return null;
    }

    @Override
    public boolean add(String s) {
        return false;
    }

    @Override
    public boolean remove(Object o) {
        return false;
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean addAll(Collection<? extends String> c) {
        return false;
    }

    @Override
    public boolean addAll(int index, Collection<? extends String> c) {
        return false;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        return false;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        return false;
    }

    @Override
    public void clear() {

    }

    @Override
    public String get(int index) {
        return null;
    }

    @Override
    public String set(int index, String element) {
        return null;
    }

    @Override
    public void add(int index, String element) {

    }

    @Override
    public String remove(int index) {
        return null;
    }

    @Override
    public int indexOf(Object o) {
        return 0;
    }

    @Override
    public int lastIndexOf(Object o) {
        return 0;
    }

    @Override
    public ListIterator<String> listIterator() {
        return null;
    }

    @Override
    public ListIterator<String> listIterator(int index) {
        return null;
    }

    @Override
    public List<String> subList(int fromIndex, int toIndex) {
        return null;
    }
}

方式2代码演示：

MyArrayList3<String> list1=new MyArrayList3<>();

public class MyArrayList3<E> implements List<E>

原文地址：http://www.cnblogs.com/lovedong/p/16875443.html