java泛型总结(一)

泛型方法

class Arraylg
{
public static <T> T getMiddle(T...a)
{
return a[a.length / 2];
}
}

泛型可以在普通类中定义，也可以在泛型类中定义

String middle = Arraylg.<String>getMiddle("a","b","c");

类型变量的限定

类或方法需要对类型变量加以约束

class Arraylg
{
public static <T> T min(T[] a)
{
if (a == null || a.length == 0)
{
return null;
}
T smallest = a[0];
for (int i=1;i<a.length;i++)
{
if (smallest.compareTo(a[i] > 0))
smallest = a[i];
}
return smallest;
}
}

smallest类型为T，意味着它可以使任何一个类的对象

—–可以将T限制为实现了Comparable接口

—–public static T min(T[] a)…—–(没错，就是extends，不是implements，因为extends更接近子类的概念)

表示的含义是返回值的类型必须是Comparable的子类

—–也可以用T extends Comparable & Serializable //一个类型变量或通配符可以有多个限定，用&分隔

—–借用java核心技术中的例子

public class pairTest
{
public static void main(String[] args)
{
GregorianCalendar birthdays =
{
new GregorianCalendar(1906 , Calendar.DECEMBER , 9),
new GregorianCalendar(1815 , Calendar.DECEMBER , 10),
new GregorianCalendar(1903 , Calendar.DECEMBER , 3),
new GregorianCalendar(1910 , Calendar.DECEMBER , 2),
};
Pair<GregorianCalendar> mm = ArrayAlg.minmax(birthdays);
System.out.println("min = " + mm.getFirst().getTime());
System.out.println("max = " + mm.getSecond().getTime());
}
}

class ArrayAlg
{
public static <T extends Comparable> Pair<T> minmax(T[] a)
{
if (a == null || a.length == 0)
return null;
T min = a[0];
T max = a[0];

for (int i=1;i<a.length;i++)
{
if (min.compareTo(a[i]>0))
min = a[i];
if (max.compareTo(a[i]<0))
max = a[i];
}

return new Pair<>(min , max);
}
}

class Pair<T>
{
private T first;
private T second;

public Pair()
{
first = null;
second = null;
}
public Pair(T first , T second)
{
this.first = first ;
this.second = second;
}

public T getFirst()
{
return first;
}
public T getSecond
{
return second;
}

public void setFirst(T newValue)
{
first = newValue;
}
public void setSecond(T newValue)
{
second = newValue;
}

}