Java基础之泛型——使用泛型链表类型(TryGenericLinkedList)

控制台程序

定义Point类：

public class Point {
  // Create a point from its coordinates
  public Point(double xVal, double yVal) {
     x = xVal;
     y = yVal;
  }

  // Create a point from another point
  public Point(Point point) {
     x = point.x;
     y = point.y;
  }

  // Convert a point to a string
  @Override
  public String toString() {
     return x+","+y;
  }

  // Coordinates of the point
  protected double x;
  protected double y;
}

定义泛型类LinkedList<T>:

public class LinkedList<T> {
  // Default constructor - creates an empty list
  public LinkedList() {}

  // Constructor to create a list containing one object
  public LinkedList(T item) {
    if(item != null) {
      current = end = start = new ListItem(item);                      // item is the start and end
    }
  }

  // Construct a linked list from an array of objects
  public LinkedList(T[] items) {
    if(items != null) {
      // Add the items to the list
      for(int i = 0; i < items.length; ++i) {
        addItem(items[i]);
      }
      current = start;
    }
  }

  // Add an item object to the list
  public void addItem(T item) {
    ListItem newEnd = new ListItem(item);                              // Create a new ListItem
    if(start == null) {                                                // Is the list empty?
      start = end = newEnd;                                            // Yes, so new element is start and end
    } else {                                                           // No, so append new element
      end.next = newEnd;                                               // Set next variable for old end
      end = newEnd;                                                    // Store new item as end
    }
  }
  // Get the first object in the list
  public T getFirst() {
    current = start;
    return start == null ? null : start.item;
  }

  // Get the next object in the list
  public T getNext() {
    if(current != null) {
      current = current.next;                                          // Get the reference to the next item
    }
    return current == null ? null : current.item;
  }

  private ListItem start = null;                                       // First ListItem in the list
  private ListItem end = null;                                         // Last ListItem in the list
  private ListItem current = null;                                     // The current item for iterating

  private class ListItem {

    // Constructor
    public ListItem(T item) {
      this.item = item;                                                // Store the item
      next = null;                                                     // Set next as end point
    }

    // Return class name & object
    @Override
    public String toString() {
      return "ListItem " + item ;
    }

    ListItem next;                                                     // Refers to next item in the list
    T item;                                                            // The item for this ListItem
  }
}

使用LinkedList<T>泛型类的PolyLine类：

public class PolyLine {
  // Construct a polyline from an array of coordinate pairs
  public PolyLine(double[][] coords) {
    Point[] points = new Point[coords.length];                         // Array to hold points

    // Create points from the coordinates
    for(int i = 0; i < coords.length ; ++i) {
      points[i] = new Point(coords[i][0], coords[i][1]);
    }

    // Create the polyline from the array of points
    polyline = new LinkedList<>(points);                               // Create list of Point objects
  }

  // Construct a polyline from an array of points
  public PolyLine(Point[] points) {
    polyline = new LinkedList<>(points);                               // Create list of Point objects
  }

  // Add a Point object to the list
  public void addPoint(Point point) {
    polyline.addItem(point);                                           // Add the point to the list
  }

  // Add a point from a coordinate pair to the list
  public void addPoint(double x, double y) {
     polyline.addItem(new Point(x, y));                                // Add the point to the list
  }

  // String representation of a polyline
  @Override
  public String toString() {
    StringBuffer str = new StringBuffer("Polyline:");
    Point point = polyline.getFirst();
                                                                       // Set the 1st point as start
    while(point != null) {
      str.append(" ("+ point+ ")");                                    // Append the current point
      point = polyline.getNext();                                      // Make the next point current
    }
    return str.toString();
  }

  private LinkedList<Point> polyline;                                  // The linked list of points
}

程序入口：

public class TryGenericLinkedList {
  public static void main(String[] args) {
    // Create an array of coordinate pairs
    double[][] coords = { {1, 1}, {1, 2}, { 2, 3},
                          {-3, 5}, {-5, 1}, {0, 0} };

    // Create a polyline from the coordinates and display it
    PolyLine polygon = new PolyLine(coords);
    System.out.println(polygon);
    // Add a point and display the polyline again
    polygon.addPoint(10, 10);
    System.out.println(polygon);

    // Create Point objects from the coordinate array
    Point[] points = new Point[coords.length];
    for(int i = 0; i < points.length; ++i) {
      points[i] = new Point(coords[i][0],coords[i][1]);
    }
    // Use the points to create a new polyline and display it
    PolyLine newPoly = new PolyLine(points);
    System.out.println(newPoly);
  }
}

说明：

1、PolyLine类从LinkedList<T>泛型类中创建出LinkedList<Point>类型，从而实现了Point对象链表；

2、通过将Point作为类型变量T的参数传递到LinkedList<T>泛型类的定义中，可以生成相应的类类型。这个过程被称为类型擦除（Type erasure）,因为出现类型变量T的所有位置都已经被Point替换。

3、在原始的泛型类定义中，类名之后出现的类型参数已经被移除，而且在类定义中出现T类型变量的位置都已被替换为Object类型。编译器之所以选择Object类型来替换类型变量，是因为Object类型是派生Point类型的最终超类。编译器选择的用于替换类型变量的类型是类型变量的最左边界。

4、设定类型参数的优势何在？毕竟使用Object类型作为参数能提供指向任意类型对象的引用。答案是：所提供的类型变量被编译器用来确保编译期间是类型安全的。在代码中使用LinkedList<Point>类型的对象时，编译器会检查使用它只是为了存储Point类型的对象，并且会将存储其它类型对象的任何企图都标记为错误。当调用LinkedList<Point>类型的对象的方法时，编译器会确保只提供Point类型的引用，其中原始的方法参数会被设定为类型参数。

5、定义和使用泛型类的本质内容其实很少。