Java — 泛型程序设计（1）（Core Java I）

12.2 定义简单的泛型类

1）文档目录：

2）代码：

Pair.java

package com.test1;
//泛型类generic class 就是具有一个或者多个类型变量的类
public class Pair<T> {
  private T first;
  private T second;
  //构造器
  public Pair(){
    first = null;
    second = null;
  }
  public Pair(T first,T second){
    this.first = first;
    this.second = second;
  }
  //访问器
  public T getFirst() {
    return first;
  }
  public T getSecond() {
    return second;
  }
  //修改器
  public void setFirst(T first) {
    this.first = first;
  }
  public void setSecond(T second) {
    this.second = second;
  }
  
  
}      

PairTest1.java

package com.test1;

public class PairTest1 {

  public static void main(String[] args) {
    // TODO Auto-generated method stub
    //String [] words = { "mary","had","a","little","lamb"};
    //大写字母的字典序排在小写的后面
    String [] words = { "Mary","had","a","little","lamb"};
    Pair<String> mm = ArrayAlg.minmax(words);
    System.out.println("min: "+mm.getFirst());
    System.out.println("max: "+mm.getSecond());
  }

}

class ArrayAlg{
  public static Pair<String> minmax(String[] a){
    if(a == null || a.length == 0) return null;
    String min = a[0];
    String max = a[0];
    //O（n） 复杂度求最大值最小值
    for(int i = 1;i<a.length;i++){
      if(min.compareTo(a[i]) > 0) min = a[i];
      if(max.compareTo(a[i]) < 0) max = a[i];
    }
    //这个T可加可不加，因为创建过程中 参数类型已经确认，并且他就是个代号
    return new Pair<String>(min,max);
  }
}      

12.4 类型变量的限定

这里直接贴 PairTest2.java的代码

package com.test1;

import java.util.Calendar;
import java.util.GregorianCalendar;
/**
 * 这里的泛型类依然是Pair
 * 传入泛型类中的类型变量是GregorianCalendar类
 * 此类已经实现Comparable接口进行日期的比较
 * @author PeersLee
 *
 */
public class PairTest2 {

  public static void main(String[] args) {
    // TODO Auto-generated method stub
    GregorianCalendar[] birthdays = {
  
        new GregorianCalendar(1900,Calendar.DECEMBER,9),
        new GregorianCalendar(1815,Calendar.DECEMBER,10),
        new GregorianCalendar(1903,Calendar.DECEMBER,3),
        new GregorianCalendar(1910,Calendar.DECEMBER,22),
    };
    Pair<GregorianCalendar> mm = ArrayAlg.minmax(birthdays);
    System.out.println("min: "+mm.getFirst().getTime());
    System.out.println("max: "+mm.getSecond().getTime());
  }

}

class ArrayAlg{
  /**对类型变量进行限制
   * 可以通过对类型变量设置限定实现这 确信T所属的类一sing有compareTo方法
   * 将T限制限制为实现了Comparable接口（只含有compareTo的标准接口）
  */
  public static <T extends Comparable> Pair<T> minmax(T[] a){
    //T的绑定类型可以是类，也可以是接口，选择 extends 的原因是更接近于子类的概念
    //可以有多个绑定 例如 T extends Comparable & Serializable 中间用 ‘&’分格
    if(a == null || a.length == 0) return null;
    T min = a[0];
    T max = a[0];
    for(int i = 1;i<a.length;i++){
      if(min.compareTo(a[i])>0) min = a[i];
      if(max.compareTo(a[i])<0) max = a[i];
    }
    return new Pair<>(min,max);
    
  }
}      

12.5 泛型代码和虚拟机

• 虚拟机中没有泛型，只有普通的类和方法。
• 所有的类型参数都用他们的限定类型替换。
• 桥方法被合成来保持多态。
• 为保持类型安全性，必要时插入强制类型转换