JAVA中的泛型

JAVA中的泛型

泛型是一种数据类型参数化以最大限度的进行代码重用的技术。

泛型类的定义：
在类声明的同时通过<>声明泛型参数

<>中声明的类型参数可以用于定义类属性和类方法

 

Class Lsit<T>{

  Void add(T item){
    ….

     }

  T get(int i){
    T ret = null;

     ……

      Return ret;

}

   }

泛型类的使用：
包含泛型声明的类类型可以再定义引用创建对象时候传入类型参数；

传入类型实参后创建的对象是一个在逻辑上处理特定类型的“专用”对象。

  Public class test{

     Public static void main(String [] args){
        List<string> list1 = new List<string>();        //传入类型参数string

        List<teacher> list1 = new List<steacher>();     //传入类型参数teacher

 深入泛型：

泛型是一种模板

通过泛型可以创建任意个处理特殊类型的类

理论上可以吧任何一个类都定义成泛型类。

实际开发中把容器类型的类定义成泛型类：
链表

   栈

   队列

可以在定义泛型时候指定任意个的类型参数。

声明引用和创建对象时必须指定所有的类型参数

定义泛型类的构造方法时不需要增加泛型声明。

从泛型类派生子类

泛型类可以传入实际类型参数创建一个实现类，而且可以从泛型类派生子类；

当泛型类作为父类使用时不能再包含类型参数

使用泛型类是如果不指定类型实参，则类型实参默认为object

当泛型类作为父类使用时必须传入实际类型，否则所有类型参数被当做object类处理。

范例：

package org.lxh.demo;

import java.util.*;

class store<T>{

   protected Vector<T> items = new Vector<T>();//为vector传入实际类型

   void add(T item){

      items.add(item);

   }

   T get(int index){

      T ret = null;

      try{

        ret=items.get(index);

      }catch(Exception e){

        ret = null;

      }

      return ret;

     

   }

}

 

class stringstore extends store<String>{

   int size(){

      return items.size();

   }

   String remove (int size){

      String ret = null;

      ret = get(size);

      if(ret != null){

        items.remove(size);

       

      }

      return ret;

   }

}

public class Math{

    public static void main(String[] args){

       stringstore s =new stringstore();

       s.add("java");

       s.add("linux");

       s.add("android");

       while(s.size()>0){

           System.out.println(s.remove(0));

       }

    }

}

运行结果：

java

linux

android

 

结论：

1、           当定义类和接口时候才可以使用类型参数

2、           当使用类和接口时候必须为类型参数传入实际的类型。

Vector是JAVA系统提供的一个表示一维向量的泛型类。

构造方法摘要
Vector()        构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。
方法摘要
boolean	add(E e)            将指定元素添加到此向量的末尾。
void	add(int index, E element)            在此向量的指定位置插入指定的元素。
boolean	addAll(Collection<? extends E> c)            将指定 Collection 中的所有元素添加到此向量的末尾，按照指定 collection 的迭代器所返回的顺序添加这些元素。
boolean	addAll(int index, Collection<? extends E> c)            在指定位置将指定 Collection 中的所有元素插入到此向量中。
void	addElement(E obj)            将指定的组件添加到此向量的末尾，将其大小增加1。
int	capacity()            返回此向量的当前容量。
void	clear()            从此向量中移除所有元素。
Object	clone()            返回向量的一个副本。
boolean	contains(Object o)            如果此向量包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c)            如果此向量包含指定 Collection 中的所有元素，则返回 true。
void	copyInto(Object[] anArray)            将此向量的组件复制到指定的数组中。
E	elementAt(int index)            返回指定索引处的组件。
Enumeration<E>	elements()            返回此向量的组件的枚举。
void	ensureCapacity(int minCapacity)            增加此向量的容量（如有必要），以确保其至少能够保存最小容量参数指定的组件数。
boolean	equals(Object o)            比较指定对象与此向量的相等性。
E	firstElement()            返回此向量的第一个组件（位于索引 0) 处的项）。
E	get(int index)            返回向量中指定位置的元素。
int	hashCode()            返回此向量的哈希码值。
int	indexOf(Object o)            返回此向量中第一次出现的指定元素的索引，如果此向量不包含该元素，则返回 -1。
int	indexOf(Object o, int index)            返回此向量中第一次出现的指定元素的索引，从index 处正向搜索，如果未找到该元素，则返回 -1。
void	insertElementAt(E obj, int index)            将指定对象作为此向量中的组件插入到指定的 index处。
boolean	isEmpty()            测试此向量是否不包含组件。
E	lastElement()            返回此向量的最后一个组件。
int	lastIndexOf(Object o)            返回此向量中最后一次出现的指定元素的索引；如果此向量不包含该元素，则返回 -1。
int	lastIndexOf(Object o, int index)            返回此向量中最后一次出现的指定元素的索引，从index 处逆向搜索，如果未找到该元素，则返回 -1。
E	remove(int index)            移除此向量中指定位置的元素。
boolean	remove(Object o)            移除此向量中指定元素的第一个匹配项，如果向量不包含该元素，则元素保持不变。
boolean	removeAll(Collection<?> c)            从此向量中移除包含在指定 Collection 中的所有元素。
void	removeAllElements()            从此向量中移除全部组件，并将其大小设置为零。
boolean	removeElement(Object obj)            从此向量中移除变量的第一个（索引最小的）匹配项。
void	removeElementAt(int index)            删除指定索引处的组件。
protected  void	removeRange(int fromIndex, int toIndex)            从此 List 中移除其索引位于 fromIndex（包括）与toIndex（不包括）之间的所有元素。
boolean	retainAll(Collection<?> c)            在此向量中仅保留包含在指定 Collection 中的元素。
E	set(int index, E element)            用指定的元素替换此向量中指定位置处的元素。
void	setElementAt(E obj, int index)            将此向量指定 index 处的组件设置为指定的对象。
void	setSize(int newSize)            设置此向量的大小。
int	size()            返回此向量中的组件数。
List<E>	subList(int fromIndex, int toIndex)            返回此 List 的部分视图，元素范围为从fromIndex（包括）到 toIndex（不包括）。
Object[]	toArray()            返回一个数组，包含此向量中以恰当顺序存放的所有元素。
<T> T[]	toArray(T[] a)            返回一个数组，包含此向量中以恰当顺序存放的所有元素；返回数组的运行时类型为指定数组的类型。
String	toString()            返回此向量的字符串表示形式，其中包含每个元素的String 表示形式。
void	trimToSize()            对此向量的容量进行微调，使其等于向量的当前大小。

 

Store类是一个泛型类T为类型参数

Store类中用参数T创建了vector的实现类。

 

泛型类的本质

JAVA编译器不允许同一个泛型类的不同实现类的引用间赋值；

同一个泛型类的不同实现类的类型是相同的

所有泛型类的实现类对象共享静态属性和方法

静态方法和静态属性不允许使用类型参数。

JAVA中泛型准则：

 

只要编译时系统没有产生“未经检查的转换”警告，则程序运行时候不会产生ClasscastExecption异常。

 

泛型类本质

 

范例：

package org.lxh.demo;

import java.util.*;

class Store<T>{

   protected Vector<T> items = new Vector<T>();

   void add(T item){

      items.add(item);

   }

   T get(int index){

      T ret = null;

      try{

        ret=items.get(index);

      }catch(Exception e){

        ret = null;

      }

      return ret;

     

   }

}

 

class StringStore extends Store<String>{

   int size(){

      return items.size();

   }

   String remove (int size){

      String ret = null;

      ret = get(size);

      if(ret != null){

        items.remove(size);

       

      }

      return ret;

   }

}

 

public class Math{

   public static void main(String[] args){

      Store<String> sStore = new Store<String>();

      Store<Integer> dStore = new Store<Integer>();

        Store s = sStore;

        Integer num =1;

        dStore.add(num);

        s.add(dStore.get(0));

       

        System.out.println(dStore.get(0));

        System.out.println(sStore.get(0));

   }

}

结果：

1

Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

    at org.lxh.demo.Math.main(Math.java:45)

 

类型通配符

 

1、在JAVA中可以定义指向“所有泛型”的泛型类引用

2、在声明泛型类引用时把？当做具体类型传入

 

注意点：
声明为通用类型的引用不能执行add方法。

因为Add方法无法确认add中T的具体类型。

Get方法可以返回元素的值，虽然不知道T的具体类型，但是总似乎可以确定T就是一个object的对象。

可理解为通配类型的引用的方法只有返回值的类型T被替换为object。

 

范例：

package org.lxh.demo;

import java.util.*;

class Store<T>{

    protected Vector<T> items = new Vector<T>();

    void add(T item){

       items.add(item);

    }

    T get(int index){

       T ret = null;

       try{

           ret=items.get(index);

       }catch(Exception e){

           ret = null;

       }

       return ret;

      

    }

}

 

class StringStore extends Store<String>{

    int size(){

       return items.size();

    }

    String remove (int size){

       String ret = null;

       ret = get(size);

       if(ret != null){

           items.remove(size);

          

       }

       return ret;

    }

}

public class Math{

    public static void print(Store<?> s){

       for(int i=0;s.get(i)!=null;i++){

           System.out.println(s.get(i));

       }

    }

    public static void main(String[] args){

       Store<String> sStore = new Store<String>();

       Store<Integer> dStore = new Store<Integer>();

       Store<?> oStore = sStore;

      

       sStore.add("java");

       sStore.add("linux");

       sStore.add("android");

      

       //oStore.add(new Integer(1)); //声明为通用类型的引用不能执行add方法。

      

       dStore.add(1);

       dStore.add(2);

       dStore.add(3);

      

       print(sStore);

       print(dStore);

    }

}

 

结果：

java

linux

android

1

2

3

 

泛型方法：

 

可以单独为方法声明类型参数，而不需要将整个类定义为泛型类

定义了类型参数的方法叫做泛型方法

 

范例：

package org.lxh.demo;

import java.util.*;

class Store<T>{

    protected Vector<T> items = new Vector<T>();

    void add(T item){

        items.add(item);

    }

    T get(int index){

       T ret = null;

       try{

           ret=items.get(index);

       }catch(Exception e){

           ret = null;

       }

       return ret;

      

    }

}

 

class StringStore extends Store<String>{

    int size(){

       return items.size();

    }

    String remove (int size){

       String ret = null;

       ret = get(size);

       if(ret != null){

           items.remove(size);

          

       }

       return ret;

    }

}

public class Math{

    public static <T> void copy(T[] array,Store<T> store){

       for(int i=0;i<array.length;i++){

           store.add(array[i]);

       }

    }

    public static <T> void print(Store<T> store){

       for(int i=0;store.get(i)!=null;i++){

           System.out.println(store.get(i));

       }

    }

    public static void main(String[] args){

       Store<String> sStore = new Store<String>();

       Store<Integer> dStore = new Store<Integer>();

       Integer[] num = {1,2,3,4,5};

       String[] str = {"java","linux","android"};

      

       copy(num,dStore);

       copy(str,sStore);

      

       print(dStore);

       print(sStore);

    }

      

 

    }

结果：

1

2

3

4

5

java

linux

android

 

泛型的限制

泛型不支持泛型数组的创建，但是支持泛型数组的引用声明

 

避免在泛型中创建泛型数组，将数组作为方法参数传入v。