泛型
先给大家举个例子；如现在有一家工厂，可以生产手机，也可以生产电脑。以后还可能生产其他产品。
如果给某个工厂加上了泛型，就规定了这个工厂只能生产手机或电脑，不能再生产其他产品了。
实例：
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();
}
}
运行结果：
拨打电话
编写代码
--------------
拨打电话
编写代码
小结：
使用父类型数组存储子类对象
优点：可以存储任何一种子类型
缺点：从数组中获取对象，并调用子类中特有方法时，需要强制类型转换
存在类型转换异常的风险
使用泛型数组
优点：获取对象无限强制类型转换，也就不存在类型转换异常的风险
类型的扩展性好
缺点：创建泛型相关的实例麻烦
使用时，泛型一旦传入参数，类型就固定了，导致类型单一（例如，上面的两个泛型工厂，可以看出两个不同的类型）
泛型相当于给类型加上一个参数，类似带参数的方法，方法的形参是声明某种数据类型的变量，使用小括号将参数括起来，传入的实参是某种数据类型的值或对象，在方法内便可以使用参数变量；而类型的形参只是一个占位符，使用尖括号括起来，传入的实参为类型（类名），在类的内部便可以将占位符作为数据类型使用；这就是泛型。
泛型应用最多的是集合。
时间： 2024-10-04 02:19:23