一个问题引出泛型：
如果一个大类 如篮子类里装物品鸡蛋和面包，数组类型如何定义可以满足存放不同类型的物品？可以用所以类型父类Object来定义。但有弊端，输出时不能全部转换为一个类输出
源码如下：
public static void main(String[] args ) {
Egg egg[] =new Egg[2];
egg[0]=new Egg();
egg[1]=new Egg();
Basket basket = new Basket(3);
for(int i=0;i<egg.length;i++)
basket.add(egg[i]);
basket.add(new Bread());//①混入Bread对象,编译通过，因为数组类型为Object
for(int i=0;i<basket.length();i++) {
Egg g=(Egg)basket.indexOf(i);
System.out.println(g);//②运行时出错，当i=2时，对象实际是Bread
//不能强制转换为Egg;
}
}
}
class Basket{
int n; //篮子能放入的物品总数
int total; //物品的实际个数
private Object arr[]; //利用数组放物品
public Basket(int n) {
this.n=n;
total=0;
arr=new Object[n];
}
public void add(Object obj) { //将一个对象加到数组
arr[total++]=obj;
}
public Object indexOf(int i) { //获取数组第i个元素的对象
return arr[i];
}
public int length() { //获得对象数组的长度
return total;
}
}
class Egg{
double weight;
public String toString(){
return ("我是鸡蛋");
}
}
class Bread{
double weight;
@Override
public String toString() {
return "Bread [weight="+"我是面包"+"]";
}
}
运行结果如下：
编译通过，但运行出错。
这时，泛型就要出场了。利用泛型可以定义类的实际类型实现多类型存入。
略微增加泛型改动如下：（测试类中，不同类型会报错了）
public static void main(String[] args) {
// TODO Auto-generated method stub
Egg1 egg[] =new Egg1[2];
egg[0]=new Egg1();
egg[1]=new Egg1();
Basket1<Egg1> basket = new Basket1<>(3);
for(int i=0;i<egg.length;i++)
basket.add(egg[i]);
//basket.add(new Bread1());//编译不通过，因为不是Egg类型
for(int i=0;i<basket.length();i++) {
Egg1 g=basket.indexOf(i);
System.out.println(g);
}
}
}
class Basket1<T>{
int n; //篮子能放入的物品总数
int total; //物品的实际个数
private Object arr[]; //利用数组放物品
public Basket1(int n) {
this.n=n;
total=0;
arr=new Object[n];
}
public void add(T obj) { //将一个对象加到数组
arr[total++]=obj;
}
public T indexOf(int i) { //获取数组第i个元素的对象
return (T) arr[i];
}
public int length() { //获得对象数组的长度
return total;
}
}
class Egg1{
double weight;
public String toString(){
return ("我是鸡蛋");
}
}
class Bread1{
double weight;
@Override
public String toString() {
return "Bread [weight="+"我是面包"+"]";
}
}
什么是泛型？
泛型，也称之为“参数化类型”，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
泛型类的定义
关于定义的模板与常用参数意义：
泛型类的使用规则：
泛型的类型参数只能是类类型，而不能是简单类型为；
泛型的类型参数可以有多个；
静态字段的类型不能是类型参数；
不能直接创建类型参数变量的数组，只能通过反射创建；
泛型的参数类型可以使用extends和super关键词；
泛型的参数类型还可以是通配符类型。
看完上述内容还是无法做到，不同类型输出...咋办呢？
这时可以利用咱的【泛型方法】来输出；
泛型方法
泛型方法实例：
@SafeVarargs //T(类型参数名)
static <T> void print(T...ts) { //泛型方法，形参是可变参数 ,ts(参数名)实质上是一个数组
for (int i=0;i<ts.length;i++)
System.out.print(ts[i]+" ");
System.out.println();
}
public static void main(String[] args) {
print("北京市","长江","泰山"); //类型一样
print("这个手机","价格","2000.00","元"); //四个参数，类型不一样
String fruit[]= {"apple","banana","orange","peach","pear"}; //String 数组对象
print(fruit);
}运行结果：
细心的你可能已经知道，如何输出了吧！
将上述篮子类中的add()方法改为泛型方法：
public <T>void add(T...arr) { //【用泛型方法实现输出】
for (int i=0;i<arr.length;i++)
System.out.println(arr[i]); //将一个对象加到数组
}就可以完成所有类的输出啦！
如果对你有所帮助，记得点赞收藏噢！
