JDK5.0新特性系列---8.泛型编程

 

import java.util.ArrayList;

import java.util.Collection;

import java.util.List;

 

/**

 *泛型编程关键掌握两点:

 *1.在方法参数中使用通配符

 *2.在方法的参数类型和返回类型中使用通用类型

 */

/**关键技术

 *1.通配符问号(?)表示任意类型.如"List<?>"表示可以存放任意对象类型的List

 *2.通配符可以接extends和super,表示有限制的通配符.如"List<? extends Parent>"

 *  声明的List能且仅能存放Parent及其子类的对象,而"List<? super Child>"

 *  声明的List仅能存放Child及其父类的对象

 *3.通用类型是指不指定参数或者返回值的类型,常用一个大写的字母代表类型,

 *  它能代表任何类型,需要在方法声明的返回值前用<>声明通用类型.如"public <T> String

 *  getName(T data)"的方法声明中,String前用<T>表示T是通用类型,它的data参数的类型是T,

 *  表示能接收任意类型的参数,方法的返回值是String类型

 */

public class GeneralProgram {

       /**使用问号"?*通配符,"?"代表任何类型,所以它的参数可以是任何类型的Collection*/

       public static void printCollection(Collection<?> collect){

              if(collect == null){

                     return;

              }

              for(Object obj : collect){

                     System.out.println(obj + "  ");

              }

              System.out.println();

       }

       /**使用有限制的通配符"? extends",可以接受任何Parent及其子类的Collection*/

       public static void printNames(Collection<? extends Parent> collect){

              if(collect == null){

                     return;

              }

              for(Object obj : collect){

                     System.out.println(obj + "  ");

              }

              System.out.println();

       }

       /**将一个任意类型的数组添加到列表里*/

       public static <T> List<T> arrayToList(T[] datas){

              if (datas == null){

                     return null;

              }

              List<T> list_T = new ArrayList<T>();

              for(T x : datas){

                     list_T.add(x);

              }

              return list_T;

       }

       /**在一组parent对象中查找名字为name的Parent对象*/

       public static <T extends Parent> T findParent(T[] parents, String name){

              if(parents == null){

                     return null;

              }

              T parent = null;

              //依次遍历Parent对象数组

              for(T x : parents){

                     //如果Parent对象的name与参数name匹配,则退出遍历

                     if(x.name.equals(name)){

                            parent = x;

                            break;

                     }

              }

              //返回

              return parent;

       }

       public static void main(String[] args){

              /***指定具体的类型***/

              //声明一个用于装字符串的列表,该列表只能装字符串的对象

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

              list_S.add("first");

              list_S.add("second");

              list_S.add("third");

              //不能装整数对象

              Integer iObj = 10;

              //list_S.add(iObj);//error!!

              //从列表中取值时,不用作强制类型转换

              String firstS = list_S.get(0);

              String thirdS = list_S.get(2);

              System.out.println("firstS: " + firstS + "; thirdS: " + thirdS);

             

              /***泛型和继承***/

              //String继承Object

              String s = "sss";

              Object o = s;

              //但List<String>不继承List<Object>

              //List<Object> list_O = list_s;//error!!!!!!!!!

             

              /***通配符***/

              //调用具有"?"通配符的方法

              List<Integer> list_I = new ArrayList<Integer>();

              list_I.add(5555);

              list_I.add(6666);

              list_I.add(7777);

              //该方法可以打印整型列表,也可以打印字符串列表

              printCollection(list_I);

              printCollection(list_S);

             

              /***调用具有"?"通配符的方法***/

              //只接受父类以及子类类型的列表

              List<Parent> list_Parent = new ArrayList<Parent>();

              list_Parent.add(new Parent("parentOne"));

              list_Parent.add(new Parent("parentTwo"));

              list_Parent.add(new Parent("parentThree"));

              List<Child> list_Child = new ArrayList<Child>();

              list_Child.add(new Child("childOne",20));

              list_Child.add(new Child("childTwo",22));

              list_Child.add(new Child("childThree",21));

              printNames(list_Parent);

              printNames(list_Child);

              //不能接受其它类型的参数

              //printNames(list_S);//error!

             

              /***泛型方法***/

              //arrayToList方法将任意类型的对象数组变成相应的列表

              Integer[] iObjs = {55,66,77,88,99};

              List<Integer> result_I = arrayToList(iObjs);//转换整型数组

              printCollection(result_I);

              String[] ss = {"temp","temptemp","hehe","he","hehehe"};

              //转换字符串数组

              List<String> result_S = arrayToList(ss);

              printCollection(result_S);

             

              //findParent方法在一组Parent对象中根据name查找Parent

              Parent[] parents = {new Parent("abc"),new Parent("bcd"),newParent("def")};

              Parent parent = findParent(parents, "bcd");

              System.out.print("找到的bcd: "+parent);

              Child[] children = {new Child("abc",22),new Child("bcd",23),newChild("def",22)};

              Child child = findParent(children, "bcd");

              System.out.print("找到的bcd: "+child);

              //但是不能在字符串数组中进行查找

              //String sss = findparent(ss,"temp");//error!

       }

}

class Parent{

       public String name;

       public Parent(String name){

              this.name = name;

       }

       public String toString(){

              return "name = " + this.name;

       }

}

class Child extends Parent{

       public int age;

       public Child(String name,int age){

              super(name);

              this.age = age;

       }

       public String toString(){

              return super.toString() + "; age = " + age;

       }

}