演示数据类型包装和泛型类必要性

/**
 * 演示数据类型包装和泛型类必要性
 */
package seek;

/**
 *设计一个已排序的对象数组类，实现查找的算法：
 *本例演示使用Comparable接口及实现该接口的类，演示数据类型包装类和泛型类必要性。
 *本例希望设计一个已排序的对象数组类SortedArray,该类能够在一个数组中按顺序存储一个类的多个对象，不限定
 *数组元素所属的类，如果Integer或String类都可以，并能够实现在数组中查找指定对象的功能。
 *
 */
public class SortedArray<T>{
  private  Comparable table[];         //存放实现Comparable接口对象
  private  int count;
  public SortedArray(int n)
     {
   if(n<=0)  n=10;
   this.table=new Comparable[n];
   this.count=0;
  }
     public void print()                   //输出数组元素
     {
       System.out.print("table:   " );
       for(int i=0;i<this.count;i++)      
           System.out.print("  " +table[i].toString());
           System.out.println();      
     }
     public int search(T tobj)         //顺序查找
     {
       int i=0;
       while(i<this.count&&!this.table[i].equals(tobj))       //比较两个对象是否相等
            i++;
       if(i<this.count)       //查找成功
           return i+1;        //下标转换成序号
       else
              return -1;         //查找失败
     }
     public boolean insert(T tobj)       //将元素按升序插入数组
     {
      if(this.count<this.table.length && tobj instanceof Comparable )   //数组未满且tobj是实现Comparable接口对象时
      {
       int i=0;    
       Comparable cmpobj=(Comparable)tobj;
       while(i<this.count && cmpobj.compareTo(this.table[i])>=0)  //比较两个对象的大小
        i++;
       for(int j=this.count-1;j>=i;j--)  //若干元素向后移动
        table[j+1]=table[j];
       this.table[i]=cmpobj;      //插入
       this.count++;
       return true;         //插入成功
      }
      else
       return false;       //插入未成功
     } 
}
      

package study;
import seek.SortedArray;
class SortedArray_ex {
 public static void main(String[] args) {
  SortedArray<Integer>sal1=new SortedArray<Integer>(10);
  Integer intobj=new Integer(2);
  sal1.insert(intobj);
  intobj=new Integer(3);
  sal1.insert(intobj);
  intobj=new Integer(1);
  sal1.insert(intobj);
  sal1.print();
  
  SortedArray<String>sa2=new SortedArray<String>(10);
  String strobj=new String("xyz");
  sa2.insert(strobj);
  strobj=new String("aaa");
  sa2.insert(strobj);
  strobj=new String("abc");
  sa2.insert(strobj);
  sa2.print();
  System.out.println("search      "+strobj.toString()+":   "+sa2.search(strobj));

 }

}

]程序设计说明如下：

1〉数组元素的通用性设计：
     为了设计一个通用的对象数组，使它具有适用于多个类的操作（如顺序存储或查找），则数组元素所属的类可能有多种，在编译时不能确定，需要在运行时确定。通常做法是声明数组元素为Object类，例如：
       private Object table[];
     根据子类对象即时父类对象的原则，程序运行时，数组元素table[i]可以赋值为任何类型的对象。
    上述声明对于本例则不行，因为数组元素table[i]是Object类对象，它只能调用Object类方法，而Object类只有equals（）方法，没有compareTo（）比较方法，对象之间比较是否相等，不能比较值的大小，因而不能实现排序功能。所以，本例声明数组元素类型为Comparable，它能够复制为实现Comparable接口的类的对象。声明如下：
         private Comparable table[];    //存放实现Comparable接口对象

2〉使用Integer对象的必要性：
     本例希望数组元素或者是整数，或者是字符集。为了程序的通用性，以将数组元素的类型声明为Comparable，数组中只能存放对象，而不能存放整数值，因此必须将整数值构造成对应的Integer对象存放数组，这体现了java声明基本数据类型包装类的意义。

3〉使用泛型类与否的差别：
      本例希望一个数组存储同一个类的多个对象，或者是Integer对象，或者是String类对象，必须在同一个类的对象进行比较，实现查找和排序算法，而不同类的对象之间进行比较没有实际意义。
    Integer和String类都是实现了Comparable接口中的compareTo()方法。两个类的方法分别声明如下：
     public int compareTo(Integer anotherInteger)      //Integer类
     public int compareTo(String anotherString)        //String类
   因此，不同类之间对象进行比较则会产生运行时错误。
    如果SortedArray类不声明为泛型类，如：
      public class SortedArray
则SortedArray类对象sa1中可以混合存放Integer和String等实现了comparable接口的类的对象。但是当插入一个对象时，采用comparaTo（）方法将Integer与String类对象比较，则运行时产生错误。
    将SortedArray类声明为泛型类后，在创建对象时，必须确定该类参数为另一个类，如：
       SortedArray<Integer>sa1=new SortedArray<Integer>(10);
   此时，在sa1中插入Integer对象，如果插入一个字符串对象，则编译时产生错误。

所以，对于本例而言，声明泛型类能够确保一个数组中的所有元素是同一个类的对象。而且采用泛型类将运行时的类型检查提前到编译时进行，使代码更安全。

累死我了，打这么字！