JAVA基础之泛型

Java基础之泛型

泛型是在Java5.0引入的，泛型的主要目的是加强类型安全和减少强制转换的次数。

泛型解决的问题

public static void main(String[] args) {
    List list = new ArrayList();
    list.add(Integer.valueOf(1));

    Integer i = (Integer)list.get(0);

    System.out.println(i);
}

• 以集合容器为例，如果没有泛型那么需要我们频繁的进行强制类型转换，并且也有安全隐患（向list容器添加了字符串变量，强制转换报错）。

基本语法

定义好的类型参数可以用在普通类型存在的大部分地方（包括：字段类型、对象方法参数类型、对象方法返回值、对象方法局部变量）。

public class MyBean <A,B,C>{
	
	public A a;
	public B b;
	private C[] c;
	
	public A getA() {
		return a;
	}
	public void setA(A a) {
		this.a = a;
	}
	public B getB() {
		return b;
	}
	public void setB(B b) {
		this.b = b;
	}
	public C[] getC() {
		return c;
	}
	public void setC(C[] c) {
		this.c = c;
	}
	
}

public interface MyInterface <A,B>{
	public A getA();
	public default B getB() {
		B b = null;
		return b;
	}
}

泛型与子类

测试准备

// 动物类
public class Animal {
}

// 狮子类
public class Lion extends Animal {
}

测试容器兼容

public static void main(String[] args) {
    List<Animal> animals = new ArrayList<Animal>();
    // 兼容
    animals.add(new Lion("狮子","非洲"));	//行1
    animals.add(new Animal("老虎"));
    // 兼容
    Lion l0 = (Lion) animals.get(0); // 行2
    System.out.println(l0.demesne);

    Animal l1 = animals.get(0); // 行3
    System.out.println(l1.name);

    Animal _l1 = animals.get(1); // 行4
    System.out.println(_l1.name);
}

• 当容器声明中的泛型指定的是基类时：
  • add() ：可以添加基类和子类。
  • get() ：想要获取子类需要进行强制类型转换（只有元素是子类时才能转换成功，父转子会报异常）。

public static void main(String[] args) {
    List<Lion> lions = new ArrayList<Lion>();
    lions.add(new Lion("狮子", "非洲"));	// 行1
    lions.add(new Animal("老虎"));	// 行2
}

• 当容器声明中的泛型指定的时子类时：
  • add() ：只能添加子类，添加基类编译器会报错。

public static void main(String[] args) {
    List<Animal> animals = new ArrayList<Animal>();
    List<Lion> lions = new ArrayList<Lion>();

    List<Animal> _animals = lions;	// 行1
    List<Lion> _lions = animals;	// 行2
}

• 行1和行2都在编译器报错：
  • **理解：**通过上面的测试可以看出容器方法add()和set()针对基类和子类的行为在不同的泛型容器声明的情况下，表现是不一致的，那么当他们的变量指针可以相互赋予的话必然会导致一些不可控制的情况，所以在编译器就执行强类型检查。

通配符

介绍

public static void main(String[] args) {
    List<Animal> animals = new ArrayList<Animal>();
    animals.add(new Animal("狮子"));

    List<Lion> lions = new ArrayList<Lion>();
    lions.add(new Lion("老虎"));

    showLength(animals);
    showLength(lions);
}

public static void showLength(List<?> list) {
    System.out.println(list.size());
}

• 通配符 ? 表示任意类型都可以。
• 如果将 ? 改为Object是否可以呢？答案是不行，在上一小节<泛型与子类>中我们了解到编译器对泛型引用执行的是强校验。

局部变量使用通配符

public static void main(String[] args) {
    List<?> lions = new ArrayList<Lion>();

    lions.add(new Animal("狮子"));// 行1
    lions.add(new Lion("老虎","亚洲")); // 行2
}

• 行1和行2都在编译器报错。

有界通配符

public static void main(String[] args) {
    List<Animal> animals = new ArrayList<Animal>();
    animals.add(new Animal("狮子"));

    List<Lion> lions = new ArrayList<Lion>();
    lions.add(new Lion("老虎"));

    List<Object> objs = new ArrayList<Object>();
    objs.add(new Lion("老虎"));

    showLength(animals); // 行1
    showLength(lions); // 行2
    showLength(objs); // 行3
}

public static void showLength(List<? extends Animal> list) {
    System.out.println(list.size());
}

• 当我们想限制泛型的范围是基类和它的子类时可以使用有界通配符，上面的代码示例中行3会报错。

public class MyBean <A extends Animal,B,C>{
	public A a;
	public A getA() {
		return a;
	}
	public void setA(A a) {
		this.a = a;
	}
}

• 有界通配符也可以用在类定义上。

泛型方法

public static <D> void method1(D d) {
    System.out.println("参数："+d);
}

public static <D> D method2(D d) {
    System.out.println("参数："+d);
    return d;
}

public static <E,F extends E> E method3(F f) {
    System.out.println("参数："+f);
    return f;
}

public static void main(String[] args) {
    method1("dddd");
    method1(new Animal("狮子"));

    method2("dddd");
    method2(new Animal("狮子"));

    String str = method2("dddd");
    String animal = method2(new Animal("狮子")); // Type mismatch: cannot convert from Animal to String

    Animal animal2 = method3(new Lion("狮子"));
    Lion lion = method3(new Animal("狮子")); // Type mismatch: cannot convert from Animal to Lion
}

• 编译器需要收集足够的信息完成类型推导，method1 和 不接收返回值的 method2 的形参可以接受任意类型的入参。接受返回值的method2 和 method3 由于有足够的信息完成类型推导，所以会限制入参类型。