Java泛型基础

1. 认识泛型

泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。

在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。

泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，以提高代码的重用率，主要的原理是在类声明的时候通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。

格式：

访问权限 class 类名称<泛型, 泛型...>{
 属性
 方法
}

相信这里有很多学习java的朋友，小编整理了一份java方面的学习资料，有想要学习java的可以加一下我的学习扣扣群的哟，60833，4068，欢迎爱学习java的你们！

对象的创建:

类名称<具体类型> 对象名称 = new 类名称<具体类型>();

示例

/**
 * 经纬度
 * 
 * @author dixin
 *
 */
class Point<T> {
 private T x;
 private T 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;
 }
}
public class GenericDemo01 {
 public static void main(String[] args) {
 Point<String> p1 = new Point<String>();
 p1.setX("经度为10");
 p1.setY("纬度为100");
 Point<Integer> p2 = new Point<Integer>();
 p2.setX(10);
 p2.setY(100);
 System.out.println(p1.getX() + ", " + p1.getY());
 System.out.println(p2.getX() + ", " + p2.getY());
 }
}
// 执行结果
经度为10, 纬度为100
10, 100

2. 构造方法中使用泛型

   class Con<T> {
     private T value;
     // 类定义中已经定义泛型T, 方法中可以直接使用, 不用加<>
     public Con(T value) {
     this.value = value;
     }
     public T getValue() {
     return value;
     }
     public void setValue(T value) {
     this.value = value;
     }
    }
    public class GenericDemo02 {
     public static void main(String[] args) {
     Con<String> c = new Con<String>("构造方法中使用泛型");
     System.out.println(c.getValue());
     }
    }
   

3. 设置多个泛型

两个泛型的例子:

class Gen<K, T> {
 private K key;
 private T value;
 public K getKey() {
 return key;
 }
 public void setKey(K key) {
 this.key = key;
 }
 public T getValue() {
 return value;
 }
 public void setValue(T value) {
 this.value = value;
 }
}
public class GenericDemo03 {
 public static void main(String[] args) {
 Gen<String, Integer> gen = new Gen<String, Integer>();
 gen.setKey("key");
 gen.setValue(10);
 System.out.println(gen.getKey() + ", " + gen.getValue());
 }
}

4. 通配符

类型不统一问题

class Info<T> {
 private T value;
 public void setValue(T value) {
 this.value = value;
 }
 public T getValue() {
 return value;
 }
 @Override
 public String toString() {
 return this.getValue().toString();
 }
}
public class GenericDemo04 {
 public static void main(String[] args) {
 Info<String> i = new Info<String>();
 i.setValue("类型不统一");
 tell(i); // 编译报错
 // The method tell(Info<Object>) in the type GenericDemo04 is not applicable for the arguments 
 (Info<String>)
 }
 public static void tell(Info<Object> i) {
 System.out.println(i);
 }
}

原因:

泛型是不可变的, 对于任意两个不同的类型Type1和Type2, List既不是List的子类型, 也不是List的父类型. 所以这里不能将转换成。

解决方式:

public static void tell(Info i)中去掉, 使用raw类型, 但这样就失去了泛型的安全性检查意义。

更好的方式, 采用通配符。

修改为public static void tell(Info<?> i)

5. 泛型接口

声明泛型接口和声明泛型类的语法类似, 也是在接口名称后面加上。

格式:

interface 接口名称<泛型标识>

示例:

interface IGen<T> {
 public void say();
}
class GenImpl<T> implements IGen<T> {
 private String info;
 public GenImpl(String info) {
 this.info = info;
 }
 public void setInfo(String info) {
 this.info = info;
 }
 public String getInfo() {
 return info;
 }
 @Override
 public void say() {
 System.out.println(this.info);
 }
}
public class GenericDemo05 {
 public static void main(String[] args) {
 IGen<String> g = new GenImpl<String>("泛型接口");
 g.say();
 }
}

6. 泛型方法

泛型方法中可以定义泛型参数, 此时, 参数的类型就是传入数据类型。

格式:

访问权限 <泛型标识> 泛型标识 方法名称([泛型标识 参数名称])

示例:

public class GenericDemo06 {
 public static void main(String[] args) {
 String str = tell("Hello");
 System.out.println(str);
 int i = tell(10);
 System.out.println(i);
 }
 // <T>是第一泛型参数, 写在访问权限和static后面
 public static <T> T tell(T t) {
 return t;
 }
}
// 执行结果
Hello
10

7. 泛型数组

泛型数组的使用要和泛型方法搭配使用.

在使用泛型方法的时候, 也可以传递或返回一个泛型数组。

public class GenericDemo07 {
 public static void main(String[] args) {
 String arrStr[] = { "A", "B", "C" };
 tell(arrStr);
 Integer arrInt[] = { 1, 2, 3 };
 tell(arrInt);
 }
 public static <T> void tell(T arr[]) {
 for (int i = 0; i < arr.length; i++) {
 System.out.println(arr[i]);
 }
 }
}

欢迎关注程序胖，可视化学习java，每天更新，让Java学习更加简单。