Java 从入门到进阶之路（二十三）

在之前的文章我们介绍了一下 Java 中的集合框架中的Collection 的迭代器 Iterator，本章我们来看一下 Java 集合框架中的Collection 的泛型。

在讲泛型之前我们先来看下面一段代码：

 public class Main {

     public static void main(String[] args) {

         Point point = new Point(1, 2);

         point.setX(2);

         int ix = point.getX();

         System.out.println(ix); // (2, 2)

         /**

          * 如果想要 x 值变为 double 类型则可以强转为 double 类型

          * */

         point.setX(2);

         double dx = (double) point.getX();

         System.out.println(dx); // 2.0

     }

 }

 class Point {

     private int x;

     private int y;

     public Point(int x, int y) {

         this.x = x;

         this.y = y;

     }

     public int getX() {

         return x;

     }

     public void setX(int x) {

         this.x = x;

     }

     public int getY() {

         return y;

     }

     public void setY(int y) {

         this.y = y;

     }

     @Override

     public String toString() {

         return "(" + x + ", " + y + ")";

     }

 }

上面的代码我们之前的文章讲过，我们可以通过传入 x 和 y 值来定义 Point 点，如果我们想要 double 类型的点时需要造型为 double 类型，那我要定义汉字类型的呢？那就造型成 String 类型，这就很麻烦，每次都需要自己来造型，有种鞋不合脚的感觉，那能不能定义我想要什么类型就是什么类型呢，如下：

 public class Main {

     public static void main(String[] args) {

         Point<Integer> point1 = new Point<Integer>(1, 2); // 必须是包装类

         point1.setX(1);

         System.out.println(point1.getX()); //

         Point<Double> point2 = new Point<Double>(1.1, 2.1); // 必须是包装类

         point2.setX(1.2);

         System.out.println(point2.getX()); // 1.2

         Point<String> point3 = new Point<String>("一", "二"); // 必须是包装类

         point3.setX("三");

         System.out.println(point3.getX()); // 三

     }

 }

 /**

  * 泛型

  * 又称参数化类型，是将当前类的属性的类型，方法参数的类型及方法

  * 返回值的类型的定义权移交给使用者，

  * 使用者在创建当前类的同时将泛型的试剂类型传入

  * 数字和字母组合，数字不能开头

  */

 class Point<T> { // 定义为泛型 T 类型

     private T x;

     private T y;

     public Point(T x, T y) {

         this.x = x;

         this.y = y;

     }

     public T getX() {

         return x;

     }

     public void setX(T x) {

         this.x = x;

     }

     public T getY() {

         return y;

     }

     public void setY(T y) {

         this.y = y;

     }

     @Override

     public String toString() {

         return "(" + x + ", " + y + ")";

     }

 }

从上面的代码中，我们定义了一个 T 的类型 Point，当我们要实例化该类时，根据自己的需求传入想要的包装类类型即可，这样就满足了不同的需求，各取所需。

泛型从底层来说其实就是 Object，定义了泛型只是编译器在做一些验证工作，当我们对泛型类型设置值时，会检查是否满足类型要求，当我们获取一个泛型类型的值时，会自动进行类型转换。

在平时我们是很少自己来定义泛型的，泛型是用来约束集合中元素的类型，如下：

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Iterator;

 public class Main {

     public static void main(String[] args) {

         Collection<String> collection = new ArrayList<String>(); // 只能添加 String 类型的元素

         collection.add("one");

         collection.add("two");

         collection.add("thee");

         collection.add("four");

         // collection.add(1); // 编译错误

         for (String string : collection) {

             System.out.println(string); // one two three four

         }

         Iterator<String> iterator = collection.iterator();

         while (iterator.hasNext()) {

             // String string = (String) iterator.next(); 不需要再造型

             String string = iterator.next();

             System.out.println(string); // one two three four

         }

     }

 }

巴特西

Java 从入门到进阶之路（二十三）

最新文章

热门文章