泛型
#泛型就是参数化类型，将类作为参数传递。泛型参数可以有多个。
#泛型的几种用法：
一、类泛型。
举个例子：
class Student<T1,T2>{
private T1 var1;
private T2 var2;
public Student() {}
public Student(T1 var1, T2 var2) {
this.var1 = var1;
this.var2 = var2;
}
public T1 getVar1() {
return var1;
}
public void setVar1(T1 var1) {
this.var1 = var1;
}
public T2 getVar2() {
return var2;
}
public void setVar2(T2 var2) {
this.var2 = var2;
}
@Override
public String toString() {
return "Student [var1=" + var1 + ", var2=" + var2 + "]";
}
}
class Test{
public static void main(String[] args) {
Student<String,Integer> s = new Student("张三",18);
System.out.println(s.getVar1());//输出为：张三
System.out.println(s.getVar2());//输出为：18
}
}
泛型可以等到你穿建对象时确定类型，如：
Student<String,Integer> s = new Student("张三",18);
其中Student<String,Integer>中String,Integer就是传递实际参数的类型。
#泛型的继承：
子类继承父类，如果父类有泛型，则子类必需有父类的至少一种泛型，或者更多，而且子类的泛型名必须跟父类的一样。
class FuClass<T1>{
private T1 var1;
public FuClass(T1 var1) {
this.var1 = var1;
}
public T1 show() {
return var1;
}
}
class ZiClass<T1, T2> extends FuClass<T1> {
private T2 var2;
public ZiClass(T1 var1, T2 var2) {
super(var1);
this.var2 = var2;
}
public void show2() {
System.out.println(super.show());
System.out.println(var2);
}
}
泛型的几种用法：
二、方法泛型。
如下程序所示：
public <T> void show(T t){
System.out.println(t);
}
参数列表中的泛型必须和方法中的泛型保持一致。
三、泛型的接口。
无论泛型是继承这个类还是实现这个接口类，都必须使用extends 关键字，并且传实例化对象的时候只能传该类或者该类的子类。
public interface Animal{
public abstract void eat();
public abstract void show();
}
public Dog implements Animal{
public void eat(){
System.out.println("这是Dog吃的方法");
}
public void show(){
System.out.println("这是Dog的show方法");
}
}
public Test <T extends Animal>{
private T t;
public void setT(T t) {
this.t = t;
}
public T getT() {
return t;
}
}
public class Demo{
public static void main(String[] args) {
Test<Animal> mc = new Test();
mc.setT(new Dog());
Animal t = mc.getT();
t.eat();//这是Dog吃的方法
t.show();//这是Dog的show方法
}
}
通配符：
？：表示随便一个类型，可以是任意类型。
？ extends E :表示是本类或者是该类的子类。
？ super E :表示是本类或者是该类的父类。
本章学习实例:用泛型模拟一个仓库。
class Warehouse<T>{
private Object[] data;//使用Object类型数组来储存数据,泛型不能用作数组。
private int size = 0;
public Warehouse(){
data = new Object[10];
}
//向仓库中存物品
public void add(T t){
if(size+1>data.length){
data = Arrays.copyOf(data,data.length*2);//当仓库满的时候，对仓库进行扩容。
}
data[size++] = t;
}
public T getT(int index){
reutrn (T)data[index];//大类型转小类型需要类型强制转换
}
//得到仓库中的物品数目
public int getSize(){
return size;
}
}
public class Test {
public static void main(String[] args) {
Warehouse<Integer> w = new Warehouse();
for (int i = 0; i < 10; i++) {
w.add(i);
}
System.out.println(w.getT());//5
System.out.println(w.size());//11
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}