泛型...

为什么要使用泛型

package MONA.demo04_泛型;

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

/**
 * 为什么要用泛型
 */
public class Demo01 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add(100);
        list.add(false);

        //1.迭代器
        //2.for循环

        for (int i = 0; i < list.size(); i++) {
            //ClassCastException
            String s = (String) list.get(i);
            System.out.println("获取到的值是："+s);
        }
        //为什么会出现此问题？
        //因为集合中的数据类型有多种
        //解决？
        //限制集合中的数据类型
    }
}

集合中使用泛型

package MONA.demo04_泛型;

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

/**
 * 使用泛型解决数据类型安全问题
 * 泛型类：
 * public class ArrayList<E>
 * 泛型接口：
 * public interface List<E>
 * 使用：
 * List集合元素的类型必须为String
 * List<String>
 */
public class Demo02 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        //list.add(100);
        //list.add(false);

        //1.迭代器
        //2.for循环

        for (int i = 0; i < list.size(); i++) {
            //ClassCastException
            String s = (String) list.get(i);
            System.out.println("获取到的值是：" + s);
        }
    }
}

 Arrays的asList泛型方法介绍

package MONA.demo04_泛型;

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

public class Demo03 {
    public static void main(String[] args) {
        //List<String> list = new ArrayList<>();
        //list.add();
        /**
         *public interface List<E> extends Collection<E>{
         *         boolean add(E e)}
         */

        /**
         * public static <T> List<T> asList(T... a) {
         *         return new ArrayList<>(a);
         * }
         */
        //aList:将多个数据转成集合
        List<Integer> list = Arrays.asList(1,2,3);
        List<String> strings = Arrays.asList("a", "b", "c");
    }
}

使用泛型改造工具类

代码1：

package MONA.demo04_泛型;

import java.util.List;

/**
 * 泛型方法：
 * 修饰符：public static  表示是泛型方法：<T>
 * 方法的返回值类型：List<T>   方法名<参数>:asList(T... a)
 *
 *  public static <T> List<T> asList(T... a) {
 *                   return new ArrayList<>(a);
 *           }
 */
public class Demo04 {
    public static void main(String[] args) {
        //传入1 2 3，返回存储1 2 3 的集合
        
        List<Integer> integers= ArrayTools.toList(1, 2, 3);
        System.out.println(integers);

        // aaa nnn ccc
        List list2 = ArrayTools.toList("aaa","bbb","ccc");
        System.out.println(list2);

        //Double
        List<Double> doubles = ArrayTools.toList(1.0, 2.0, 3.0);
        System.out.println(doubles);
    }
}

代码2：

package MONA.demo04_泛型;

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

/**
 * 数组的工具类
 */
public class ArrayTools {
    /**
     * <T>:表示该方法为泛型方法
     *  T ：泛型类型
     */
    public static <T> List toList(T...ints) {
        List<T> list = new ArrayList<>();
        for (int i = 0; i < ints.length; i++) {
            list.add(ints[i]);
        }
        return list;
    }
}

 接口中使用泛型

package MONA.demo04_泛型;

/**
 * 泛型接口
 * 不写泛型类型时默认的类型为：Object
 */
public class Demo05 {
    public static void main(String[] args) {
        Inter<String> inter = new InterImpl();
    }
}
interface Inter<T>{
    T getVar(T t);
}
class InterImpl<T> implements Inter<T>{

    @Override
    public T getVar(T t) {
        return null;
    }
}

泛型通配符

类型通配符一般是使用？代替具体的类型参数。

package MONA.demo04_泛型;

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

public class Demo06 {
    public static void main(String[] args) {
        List<String> strings = new ArrayList<>();
        m1(strings);
        List<String> integers = new ArrayList<>();
        m1(integers);

        List<Person> persons = new ArrayList<>();
        List<Student> Student = new ArrayList<>();
        m2(persons);
        m2(Student);
        List<Teacher> Teacher = new ArrayList<>();
        //错误因为Integer不是Person的子类
        //m2(integers);

        m3(Student);
        //错误m3(Teacher);
    }
    public static void m1(List<?> list){ }
    //上限：list的类型只能是Person以及Person的子类
    public static void m2(List<? extends Person> list){ }
    //下限：只能是Student类型，或者Student类的父类类型
    public static void m3(List<? extends Student> list){ }
}
class Person{}
class Student extends Person{}
class Teacher extends Person{}

使用泛型的好处

1.类型安全

2.消除强制类型转换

   package MONA.demo04_泛型;

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

public class Demo07 {
    public static void main(String[] args) {
        List<String> list = new ArrayList();
        list.add("aaa");
        list.add("bbb");

        //ListIterator<String> it = list.listIterator();

        List<A> as = new ArrayList<>();
    }
}
class A{ }