java 基础之一 泛型（Generic）

  1. 泛型是1.5新加的功能之一。它是java 的基础，同时也是通向高级所必需掌握的。 

   这里需要了解的是，泛型是java 编译时限制的。

   其实在我们的开发过程中，经常会用到泛型，比如说集合List、Map是我们经常用的吧。只有使用泛型我们才能new 出任何类型的List 和map。比如List<String>、List<User>、     Map<String,User> 。  

  

   2.自定义泛型：

    泛形的基本术语，以List<E>为例：<>念着typeof
    List<E>中的E称为类型参数变量
    List<String>中的String称为实际类型参数

     例子：

    在方法上面声明泛型：

    public <T> T GenericMethod1(T t,List<T>list){...} 

   public <T, S extends T> TGenericMethod2(T t, S s){...}

   GenericMethod1、GenericMethod2 修饰符后的<T>、<T, S extends T> 代表是泛型。 如果不声明那么编译器是不知道这个是泛型的。

   Number n=new Number(1);

  Integer i=new Integer(2);

  String   s ="String";  

   List<String> list=new ArrayList<String>();

   list.add(s);

   GenericMethod1(s,list) // 编译正确：T 是String 

 GenericMethod1(n,list)// 编译错误：提示必须是String 

  GenericMethod2（n,i）// 编译正确

    在类上面声明泛型：

    当一个类里面有很多的方法需要用到泛型的时候可以定义在类上。(看一个例子 稍微有点多)

public abstract class QdBaseAdapter <T>extends BaseAdapter{ //当定义到类上的时候就告诉编译器<T>  为泛型并且在整个类上有效。
    protected List<T> mList;
   protected Activity mContext;
    protected ListView mListView;


    public QdBaseAdapter(Activity context) {
        this.mContext = context;
    }


    @Override
    public int getCount() {
        if (mList != null)
            return mList.size();
        else
            return 0;
    }


    @Override
    public T getItem(int position) {
        return mList == null ? null : mList.get(position);
    }


    @Override
    public long getItemId(int position) {
        return position;
    }
    public void setList(List<T> list) {
        if(list!=null) {
            this.mList = list;
            notifyDataSetChanged();
        }
    }


    public List<T> getList() {
        return mList;
    }


    public void addMoreData(List<T> list) {
        if(list!=null) {


            if (mList != null) {
                this.mList.addAll(list);
            } else {
                mList = list;
            }
            notifyDataSetChanged();
        }
    }


    public void setList(T[] list) {
        if(list!=null) 
            List<T> List = new ArrayList<T>(list.length);
            for (T t : list) {
                List.add(t);
            }
            setList(List);
        }
    }


    public void removeItem(int position) {
        if (mList != null) {
            mList.remove(position);
        }
        notifyDataSetChanged();
    }


    public void clearAll() {
        if (null != mList && mList.size() != 0) {
            mList.clear();
            notifyDataSetChanged();
        }
    }


    public ListView getListView() {
        return mListView;
    }
    public void setListView(ListView listView) {
        mListView = listView;
    }

}

 3.通配符（？）

  <T>是类型参数赋予具体的值，除此，还可以对类型参数赋予不确定值,这里可以用通配符

  List<?> List1;
 List<? extends Number> List2;
 List<? super Integer> List3; 

 注意： 在Java集合框架中，对于参数值是未知类型的容器类，只能读取其中元素，不能像其中添加元素，
 因为，其类型是未知，所以编译器无法识别添加元素的类型和容器的类型是否兼容，唯一的例外是NULL

用途： 当你有两个不同的list集合。两个集合是不一样的对象集合，你用一个方法遍历它的时候可以用到通配符（代码如戏）    

 List<String> listString=new ArrayList<>();
        listString.add("String");
        List<Integer>listIngeger=new ArrayList<>();
        listIngeger.add(100);
        readList(listIngeger);
        readList(listString);   

 public static void readList(List<?>list){
        for(int i=0;i<list.size();i++){
            System.out.println("read=" + list.get(i));
        }
    }