泛型
先给大家举个例子;如现在有一家工厂,可以生产手机,也可以生产电脑。以后还可能生产其他产品。如果给某个工厂加上了泛型,就规定了这个工厂只能生产手机或电脑,不能再生产其他产品了。
实例:
package generic;
/**
* 产品枚举Product
* @author 学霸联盟 - 赵灿
*/
public enum Product {
手机,电脑
}
package generic;
/**
* 手机类Phone
* @author 学霸联盟 - 赵灿
*/
public class Phone {
/**
* 拨打电话的方法call
*/
public void call(){
System.out.println("拨打电话");
}
}
package generic;
/**
* 电脑类Computer
* @author 学霸联盟 - 赵灿
*/
public class Computer {
/**
* 编写代码的方法
*/
public void coding() {
System.out.println("编写代码");
}
}
package generic;
/**
* 普通工厂类Factory:用于和泛型工厂类做对比
* @author 学霸联盟 - 赵灿
*/
public class Factory {
/**
* 创建返回值类型为Object[],功能是生产多个产品对象
* 由于存在多种产品类型,所以返回值取所有产品共同的父类型Objec的数组
*/
public Object[] getProduct(){
// 创建长度为2的Object类型的一维数组,可以存储手机,也可以存放电脑
Object[] products = new Object[2];
// 创建手机对象,存入数组下标为0的位置
products[0] = new Phone();
// 创建电脑对象,存入数组下标为1的位置
products[1] = new Computer();
// 返回数组products
return products;
}
/**
* 创建根据参数值获取相应的产品
* 如果以后需要使用该方法创建其他产品,还要在switch语句中增加case语句,拓展性差
*/
public Object[] getProduct(Product productType){
// 创建长度为2的Object类型的一维数组,可以存储手机,也可以存放电脑
Object[] products = new Object[2];
switch (productType) {
case 手机:
// 创建手机对象,存入数组下标为0的位置
products[0] = new Phone();
/*
* 即使productType的值为手机,此处依然可以存入电脑对象
* 如果此处误创建成Computer对象,获取时极有可能被误转为Phone类型
* 从而导致类型转换异常,健壮性(安全性)差
*/
products[1] = new Computer();
break;
case 电脑:
// 创建两个Computer对象存入数组
products[0] = new Computer();
products[1] = new Computer();
break;
}
// 返回数组products
return products;
}
}
package generic;
import java.lang.reflect.Array;
/**
* 泛型工厂类GenericFactory<T>:用于演示泛型
* 其中T是类型GenericFactory类的形参
* 使用类型GenericFactory可以传入一个类型(类名)作为实参
* 在类型GenericFactory的内部便可以将T作为数据类型使用
* 例如:GenericFactory<String>这样编译后类中所有的T都会被替换为String
*
* T在这里一般称作占位符,也可以是其他的任意符合标识符命名规则的符号
* 常用的为T和E,T:type(类型)首字母;E:element(元素)首字母
*
* 如果需要使用多个泛型,占位符中间使用英文格式的逗号隔开
* 例如:GenericFactory<T,E>
* 使用时也是按照位置顺序对应传入
* 例如:GenericFactory<String,Integer>
* 其类中所有的T都会被替换成String,所有的E都会被替换成Integer
*
* @author 学霸联盟 - 赵灿
*/
public class GenericFactory<T> {
/**
* 声明一个返回值类型为T[](T类型的数组),参数为Class类型对象的方法
* 该方法用于获取工厂的产品
*/
public T[] getProduct(Class<T> cls){
//创建一个长度为2,T类型的数组t;初学的同学知道以下代码的作用即可
T[] t = (T[]) Array.newInstance(cls, 2);
try {
//创建类型T的对象;等价于 t = new T();
t[0] = cls.newInstance();
t[1] = cls.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
//返回对象t
return t;
}
}
package generic;
/**
* 泛型测试类GenericTest
* 用于测试和对比两种工厂的使用
* @author 学霸联盟 - 赵灿
*/
public class GenericTest {
public static void main(String[] args) {
//创建普通工厂对象f
Factory f = new Factory();
//通过工厂f的getProduct方法获取的产品数组是Object类型的数组
//所以这个数组中可能存储着多种产品
Object[] products = f.getProduct(Product.手机);
//当从数组中取出产品时是Object类型的,需要强制类型转换
Phone fp = (Phone)products[0];
//使用手机对象fp调用拨打电话的方法call
fp.call();
/*
* 我们知道此时下标为1处的产品是电脑
* 如果使用者不知道产品数组中存储的是什么类型的产品时,依然将其强制转换成手机类型
* Phone fp = (Phone)products[1];这时就会出现类型转换异常
*/
Computer fc = (Computer)products[1];
fc.coding();
System.out.println("--------------");
/*
* 创建泛型工厂对象phoneFactory,泛型工厂的参数T位置传入Phone
* 那么工厂phoneFactory变只能生产手机,不能再生产电脑
* 如果想要生产电脑则需要,另外创建生产电脑的工厂
*/
GenericFactory<Phone> phoneFactory = new GenericFactory<Phone>();
//通过泛型工厂phoneFactory生产手机,参数只能传入Phone.class
Phone[] phone = phoneFactory.getProduct(Phone.class);
phone[0].call();
//创建电脑工厂,只能生产电脑
GenericFactory<Computer> computerFactory = new GenericFactory<Computer>();
Computer[] computer = computerFactory.getProduct(Computer.class);
computer[0].coding();
}
}
运行结果:
拨打电话
编写代码
--------------
拨打电话
编写代码
小结:
使用父类型数组存储子类对象优点:可以存储任何一种子类型
缺点:从数组中获取对象,并调用子类中特有方法时,需要强制类型转换
存在类型转换异常的风险
使用泛型数组
优点:获取对象无限强制类型转换,也就不存在类型转换异常的风险
类型的扩展性好
缺点:创建泛型相关的实例麻烦
使用时,泛型一旦传入参数,类型就固定了,导致类型单一(例如,上面的两个泛型工厂,可以看出两个不同的类型)
泛型相当于给类型加上一个参数,类似带参数的方法,方法的形参是声明某种数据类型的变量,使用小括号将参数括起来,传入的实参是某种数据类型的值或对象,在方法内便可以使用参数变量;而类型的形参只是一个占位符,使用尖括号括起来,传入的实参为类型(类名),在类的内部便可以将占位符作为数据类型使用;这就是泛型。
泛型应用最多的是集合。
版权声明:本文为博主原创文章,未经博主允许不得转载。