Java泛型初探一 之 泛型类 、泛型接口 、泛型方法

泛型类

常见的泛型类的使用：容器 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

当你创建 Container 对象时，必须指明想持有什么类型的对象，并将它们置于尖括号 <> 里面，这样在使用 Container 对象时就只能存入该类型的对象了，所以在你从 Container 中取出他持有的对象时，自动就是正确的类型。

这就是 Java 泛型的核心概念： 告诉编译器想使用什么类型，然后编译器帮你处理一切细节

其实我们可以可以把泛型类当做其他类型，只不过他们有类型参数，在使用时我们需要指定它们的名字和类型参数类表即可。

泛型接口

具体栗子：

 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 为泛型而不是具体的类

从上面的栗子我们可以看到方法的参数彻底泛型化了，这个过程涉及到编译器的类型推导和自动打包，也就是说原来我们需要自己对类型进行判断和处理，现在这些事情编译器帮我们完成了。这样的话，在定义方法的时候就不必考虑以后到底需要处理哪些类型的参数，这样大大的增加了编程的灵活性。

补充：

java 泛型
泛型 ？和 T 的区别

---

参考资料

Java泛型：泛型类、泛型接口和泛型方法