1.如何理解泛型？

1)参数化类型,是JDK1.5的新特性。（定义泛型时使用参数可以简单理解为形参）
2)编译时的一种类型，此类型仅仅在编译阶段有效，运行时无效。

2.为何使用泛型？

3)提高编程时灵活性。
4)提高程序运行时的性能。（在编译阶段解决一些运行时需要关注的问题，例如强转）

3.泛型的应用类型？

5)泛型类： class 类名<泛型>{}
6)泛型接口: interface 接口名<泛型>{}
7)泛型方法: 访问修饰符 <泛型> 方法返回值类型方法名(形参){}

4.泛型的通配符？（这里的通配符可以看成是一种不确定的类型）

8)泛型应用时有一个特殊符号”?”,可以代表一种任意参数类型，注释是实参。
9)通配符泛型只能应用于变量的定义。

5.泛型的上下界问题？

10)指定泛型下界：<? super 类型>
11)指定泛型上界：<? extends 类型>

例如：
List<? extends CharSequence> list1=new ArrayList<String>();
List<? super Integer> list2=new ArrayList<Number>();

说明：这种上下界一般会用于方法参数变量定义，方法返回值类型定义。

6.泛型类型擦除？

泛型是编译时的一种类型，在运行时无效，运行时候都会变成Object类型。

//泛型类
package com.java.generic;

import java.util.ArrayList;
import java.util.List;
class Container<T>{//类泛型：类名<泛型>
    
    private T t1;//很少用
    
    public void add( T t) {}//通过类泛型约束方法参数
    public T get() {//通过类泛型约束方法返回值类型
        return null;
    }
}
public class TestGeneric01 {

    //alt+shift+m（抽取方法）
    public static void main(String[] args) {
        //doMethod01();
        
    }
    private static void doMethod02() {
        Container<Integer> c1 = new Container<Integer>();
        c1.add(100);//自动封箱integer.valueOf()
        //c1.add("abc");
        //c1.get
    }

    private static void doMethod01() {
        List list0 = new ArrayList();
        List<String> list1 = new ArrayList<String>();
        List<String> list2 = new ArrayList<>();//jdk1.7
        ArrayList<Integer> list3 = new ArrayList<>();
        list1.add("ABCD");
        String s1 = list1.get(0);
        list0.add("ABCD");
        String s2 = (String)list1.get(0);//强转操作会在运行时
        //泛型不允许是基础数据类型，所以如下写法是错误的
        //List<boolean> list4 = new ArrayList<boolean>();
    }
}

//泛型接口
package com.java.generic;

/**
 * 接口或类上可以定义多个泛型，例如：
 * Task接口的定义
 * @author tedu
 *
 * @param <Param>
 * @param <Result>
 */
interface Task<Param,Result>{
    /**
     * 此方法用于执行任务
     *  @param arg其类型由泛型参数param来决定
     * @return 其类型由泛型参数result来决定
     */
    Result execute(Param arg);
}

class AsyncTask implements Task<Integer,Integer>{

    @Override
    public Integer execute(Integer arg) {
        int result = 0;
        for(int i = 1;i<arg;i++) {
            if(i%2!=0) {
                result+=i;
            }
        }
        return result;
    }//让此类实现Task接口

}

abstract class ConverTask<Param,Result> implements Task<Param,Result>{

    
    public abstract Result execute(Param arg);
    
}

public class TestGeneric02 {
    public static void main(String[] args) {
        //借助AsyncTask将某整数以内的奇数求和
         AsyncTask task = new AsyncTask();
         int result;
         result=task.execute(10);
         System.out.println(result);
         //============================
         //借助ConverTask将某一个字符串转换成整数
         ConverTask<String,Integer> task1 = new  ConverTask<String,Integer>(){
             //匿名内部类
            @Override
            public Integer execute(String arg) {
                return Integer.parseInt(arg);
            } 
         };
         
         Integer  result1 = task1.execute("123456");
         System.out.println(result1);
    }
}

泛型

泛型