泛型类
常见的泛型类的使用：容器 Map<K ，V>
public class Container{
private String key;
private String value;
public Container(String key, String value) {
this.key = key;
this.value = value;
}
public String getKey() {
return key;
}
public void setKey(String key) {
this.key = key;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
}
Container 类中保存类一对 key-value （String - String ） 键值对 ， 但是该种写法的可扩展性较差，如果需要保存一对 key-value （Integer - String ），那么该类不符合要求，要做的就是在重新定义一个类进行相关的操作。虽然可以通过 Object 来代替 String ,但是这样灵活性还是不够，只不过这次将数据类型定义为更高的数据类型而已。而泛型则实现了不指定数据类型，只有到了运行时才能够知道具体的数据类型是什么。
栗子：
public class Cantainer < K , V >{
private K key;
private V value;
public Cantainer(K key, V value) {
this.key = key;
this.value = value;
}
public K getKey() {
return key;
}
public void setKey(K key) {
this.key = key;
}
public V getValue() {
return value;
}
public void setValue(V value) {
this.value = value;
}
}
在编译期间是无法知道具体的 K 和 V 是什么数据类型， 只有在运行时才会真正的根据具体的数据类型来进行构造和分配内存。
对泛型类的具体使用：
public class Main {
public static void main(String[] args) {
Container<String, String> c1 = new Container<String, String>("key", "value");
Container<String, Integer> c2 = new Container<String, Integer>("age", 24);
Container<Double, Double> c3 = new Container<Double, Double>(1.1, 2.2);
System.out.println(c1.getKey() + " : " + c1.getValue());
System.out.println(c2.getKey() + " : " + c2.getValue());
System.out.println(c3.getKey() + " : " + c3.getValue());
}
}
输出：
key : value
age : 24
1.1 : 2.2
泛型接口
具体栗子：
public interface Generator<T>{
public T next();
}
public class MyGenerator implements Generator<String>{
@Override
public String next(){
return "泛型类 返回值 generator";
}
}
需要注意的是在实现接口时要指明具体的数据类型 Generator<String>
具体调用：
public class Main {
public static void main(String[] args) {
MyGenerator generator = new MyGenerator();
System.out.println(generator.next());
}
}
输出：
泛型类 返回值 generato
在相应类的具体实现中(具体实现指的是：接口 Generator 的实现类 MyGenerator 指定MyGenerator<String>)可以指定接口泛型 T 的数据类型（本栗子中指定 T 的数据类型为 String ），从而指定了接口方法的数据返回值类型--String 。
泛型方法
一个基本的原则： 无论如何，只要你能做到，就应该使用泛型方法. 也就是说，如果泛型方法能将整个类泛化，那么应该优先使用泛型方法。
栗子说明泛型方法的定义：
public class Method
{
public static <T> void out (T t){
System.out.print(t);
}
public static void main(String[] args) {
out("124");
out(true);
out(124);
}
}
注意： <T>是为了规范参数；T表示的是返回值类型.
从上面的栗子我们可以看到方法的参数彻底泛型化了，这个过程涉及到编译器的类型推导和自动打包，也就是说原来我们需要自己对类型进行判断和处理，现在这些事情编译器帮我们完成了。这样的话，在定义方法的时候就不必考虑以后到底需要处理哪些类型的参数，这样大大的增加了编程的灵活性。
