一天一个Java基础——泛型

这学期的新课——设计模式，由我仰慕已久的老师传授，可惜思维过快，第一节就被老师挑中上去敲代码，自此在心里烙下了阴影，都是Java基础欠下的债

这学期的新课——算法设计与分析，虽老师不爱与同学互动式的讲课，但老师讲的挺好，不过由于数据结构欠缺课听的有点烧脑，都是数据结构欠下的债

这学期的新课——英语口语，虽外教老师风骚逗趣浪荡不羁爱自由，但我辈词汇量欠缺，表明淡定说yeah，但心中一万匹草泥马策马奔腾，都是英语欠下的债

1.泛型类

　　实体类（容器类），经常重用的类，下面是一个没有用泛型的实体类：

 public class User{
     private String username;
     private int number;
     public String getUsername() {
         return username;
     }
     public void setUsername(String username) {
         this.username = username;
     }
     public int getNumber() {
         return number;
     }
     public void setNumber(int number) {
         this.number = number;
     }
     public String toString() {
         return "User [username=" + username + ", number=" + number + "]";
     }
     public User(String username, int number) {
         super();
         this.username = username;
         this.number = number;
     }
     public User() {
         super();
     }
 }

　　属性number可以作为存放学生的证件号码，如果是int类型，11位的学号是够用了，但如果是身份证呢，一是长度不够，二是存在字符X，所以就需要重定义，那么这样这个实体类的重用性就很低了。

　　但如果用上泛型，就是这样的：

 public class User<K,V> {
     private K usrename;
     private V number;
     public K getUsrename() {
         return usrename;
     }
     public void setUsrename(K usrename) {
         this.usrename = usrename;
     }
     public V getNumber() {
         return number;
     }
     public void setNumber(V number) {
         this.number = number;
     }
     public String toString() {
         return "User [usrename=" + usrename + ", number=" + number + "]";
     }
     public User(K usrename, V number) {
         super();
         this.usrename = usrename;
         this.number = number;
     }
     public User() {
         super();
     }
 }

　　这样的好处就是：

 public class Test1 {
     public static void main(String[] args) {
         User<String,Integer> u = new User<String,Integer>();
         u.setUsrename("zhengbin");
         u.setNumber(2013734217);
         User<String,String> u1 = new User<String,String>();
         u1.setUsrename("zhengbin");
         u1.setNumber("4*****19951029****");
         System.out.println(u);
         System.out.println(u1);
     }
 }

　　运行结果：

User [usrename=zhengbin, number=2013734217]
User [usrename=zhengbin, number=41****19951029****]

　　注意：

　　　　（1） 按照惯例，像E或T这样的单个大写字母用于表示一个形式泛型类型

　　　　（2） 泛型类型必须是引用类型。不能用像int、double或char这样的基本类型来替换泛型类型

　　　　

2.泛型接口

　　定义一个生成器的接口：

 package Entity;

 public interface Generator<T> {
     public T next();
 }

　　实现这个接口：

 package Test;
 import java.util.Random;
 import Entity.Generator;
 public class FruitGenerator implements Generator<String> {
     private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
     public String next() {
         Random rand = new Random();
         return fruits[rand.nextInt(3)];
     }
 }

　　测试类：

 package Test;
 public class Main {
     public static void main(String[] args) {
         FruitGenerator generator = new FruitGenerator();
         System.out.println(generator.next());
         System.out.println(generator.next());
         System.out.println(generator.next());
         System.out.println(generator.next());
     }
 }

　　运行结果：

Banana
Apple
Apple
Pear

3.泛型方法

　　从jdk 1.5开始，可以定义泛型接口，和泛型类，还可以使用泛型类型来定义泛型方法

 public class Test2 {
     public static void main(String[] args) {
         Integer[] integers = {1,2,3,4,5};
         String[] strings = {"London","Paris","New York","Austin"};
         //为了调用泛型方法，需要将实际类型放在尖括号内作为方法名的前缀（不加也行）
         Test2.<Integer>print(integers);
         Test2.<String>print(strings);
     }

     public static <E> void print(E[] list){
         for(int i = 0;i < list.length;i++){
             System.out.print(list[i]+"-");
         }
         System.out.println();
     }
 }

　　可以看到方法的参数彻底泛化了，这个过程涉及到编译器的类型推导和自动打包，也就说原来需要我们自己对类型进行的判断和处理，现在编译器帮我们做了

　　这样在定义方法的时候不必考虑以后到底需要处理哪些类型的参数，大大增加了编程的灵活性

4.通配泛型

　　通配泛型类型有三种形式：

　　（1）? ，称为非受限通配，它和? extends Object 是一样的

　　（2）? extends T 称为受限通配

　　（3）? super T 称为下限通配，表示T或T的一个未知父类型