java 5.0 tiger学习笔记(二)

generic 学习

一.使用Type-safe的list。
例如：

List<E> list = new List<E>();
public boolean addMessage(E o){    };

其中E只是一个占位符，上例中，List<E> 中E表示list的参数可以接受的数据的类型。第二个表示函数addMessage声明了一个变量
E,并将它参数化。

   //表示listOfString可以存入String实例，但是必须指定一个可以接受相同类型的实例给他。
   List<String> listStrings ;
   // 表示可以将String加入到listOfString中，但是无法加入其他的类型。
   List<String> listStrings = new LinkedList<String>();

   例:

      List<String> onlyStrings = new LinkedList<String>;
      onlyStrings.add("Hello");
      //onlyStrings.add(new StringBuilder("World")); 编译出现错误
      onlyStrings.add("Welcome to java");

注意：List所容许的是所有类型的对象，所以List不接受初始值，所以 primitive 类型的List。

      //错误定义
      List<int> intOfList = new LinkedList<int>();

      //正确定义
      List<Integer> integerOfList = new LinkedList<Integer>();
 

二.使用Type-sefe的Map。
例如：

       Map<Integer , Integer> map = new HashMap<Integer,Integer>();
       Map<E,T> map = new HashMap<E,T>();

其中E,T与上例中的相似，只是占位符。

   语法：

        Map<Integer,Integer> intOfMap ;
        Map<Integer,Integer> intOfMap = new Map<Integer,Integer>();

   例子：

        Map<Integer,Integer> intOfMap = new Map<Integer,Integer>();
        for(int i = 0;i<10;i++){
            intOfMap.put(i,i*3);
        }
        for(int i = 0;i<10;i++){

            System.Out.println("Map--->"+i+"  "+intOfMap.get(i));

       }

注意:此处我们加入的是int的i,默认情况下,java会在幕后把int自动转化成Integer.

三. 参数类型的遍历.

当遍历已经参数化的 List的时候,修要参数化你的Iterator.

例如:

    List<String> stringOfList = new LinkedList<String>();
    stringOfList.add("Welcome");
    stringOfList.add("To");
    stringOfList.add("Java World");
    for(Iterator<String> i = stringOfList.iterator();i.hasNext();){
        String s = i.next();
        System.out.println("---s---〉"+s);
    }

四. 以参数类型作为参数：（接受参数类型；返回参数类型；参数类型作类型参数）
   1. 接受参数类型：

      public String getString（List<String> stringOfList）{
        for(Iterator<String> i = stringOfList.iterator();i.hasNext();){
            String s = i.next();
            System.out.println("---s---〉"+s);
         }
      }

   2.返回参数类型 ：

      public List<String> getList(){
            List<String> sList = new LinkedList<String>();
            sList.add("Hello");
            sList.add("Java");
            return sList;
      }

     上述方法发挥安全类型的List，所以可以立即按照安全类型方式使用。

   3.参数类型作类型参数：

      Map<Integer,List<String>> mMap = new HashMap<Integer,List<String>>();

五.generic与类型转换

      generic类型转化是按照非generic 的类型转化的，即是依照他本身的层次类型转化，而不是参数类型的层次类型
转化。
  类如：

     LinkedList<Float> floatList = new LinkedList<Float>();

     转化是基于LinkedList的层次类型转化的，而不是参数 Float类型转化。


六.类型通配符
   普通应用：

       public void printList(List list){
            for(Iterator i = list.iterator();i.hasNext();){
                System.out.println("--print---"+i.next().toString());
            }
       }

如果使用generic类型,是函数可以接受所有类型的List.可以使用generic中的通配符号 ? 来表示"通配"的目的

  即

        public void printList（List<?> list）{
            for(Iterator<?> i = list.iterator();i.hasNext();){
                System.out.println("---print---->"+i.next().toString());
            }
        }

  注意:  List<?> list   和 List<Object> list 是两种不同的概念。

七 撰写自己的generic

     public class Ball<T>{
        public List<T>  list;
        public Ball(){
            list = new ArrayList<T>();
        }

        public int getLenght(){
            return list.size();

        }
        public boolean isEmpty(){
            return (list.size()==0);
        }
        public void add(T o){
            list.add();
        }       
     }

     如果你想使用String类型，用String替换 T 的

       Ball<String> ball = new Ball<String>();

八：限制类型参数

     public class IntBall<N extends Number> extends Ball<N>{

     }

   如果使用

     IntBall<String> ball = new IntBall<String>();

     也可以在参数中使用限制。

     public  static public sum(Ball<? extends Number> ball_1,Ball<? extends Number> ball_2){

     }

     也可以换成另外形式 ：

      public static <A extends Number> public sum(Ball<A> ball_1,Ball<A> ball_2){

      }

哈哈,删除了以前的版本,重新发布了一次!! 这次格式正确了!