Java中泛型的应用

ゝ一世哀愁。 2022-07-15 06:45 141阅读 0赞

## Java中泛型的定义 ##

在程序编码中一些包含类型参数的类型，也就是说泛型的参数只可以代表类，不能代表个别对象。（这是当今较常见的定义）

在程序编码中一些包含参数的类。其参数可以代表类或对象等等。

不论使用那个定义，泛型的参数在真正使用泛型时都必须作出指明。

--------------------

## 泛型的实例 ##

### 泛型类 ###

有许多原因促成了泛型的出现，而最引人注意的一个原因，就是为了创建容器类。

容器类应该算得上最具重用性的类库之一。先来看一个没有泛型的情况下的容器类如何定义：

public class Container {
        private String key;
        private String value;
    
        public Container(String k, String v) {
            key = k;
            value = v;
        }
    
        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-Integer类型的，当前这个Container是做不到的，必须再自定义。那么这明显重用性就非常低。

当然，我可以用Object来代替String，并且在Java SE5之前，我们也只能这么做，由于Object是所有类型的基类，所以可以直接转型。但是这样灵活性还是不够，因为还是指定类型了，只不过这次指定的类型层级更高而已，有没有可能不指定类型？有没有可能在运行时才知道具体的类型是什么？

所以，就出现了泛型。

public class Container<K, V> {
        private K key;
        private V value;
    
        public Container(K k, V v) {
            key = k;
            value = v;
        }
    
        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具体是什么类型，只有在运行时才会真正根据类型来构造和分配内存。可以看一下现在Container类对于不同类型的支持情况：

public class Main {
    
        public static void main(String[] args) {
            Container<String, String> c1 = new Container<String, String>("name", "findingsea");
            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());
        }
    }

输出：

name : findingsea
    age : 24
    1.1 : 2.2

### 泛型接口 ###

在泛型接口中，生成器是一个很好的理解，看如下的生成器接口定义：

public interface Generator<T> {
        public T next();
    }

然后定义一个生成器类来实现这个接口：

public class FruitGenerator implements Generator<String> { 
    
        private String[] fruits = new String[]{
       "Apple", "Banana", "Pear"};
    
        @Override
        public String next() {
            Random rand = new Random();
            return fruits[rand.nextInt(3)];
        }
    }

调用：

public class Main {
    
        public static void main(String[] args) {
            FruitGenerator generator = new FruitGenerator();
            System.out.println(generator.next());
            System.out.println(generator.next());
            System.out.println(generator.next());
            System.out.println(generator.next());
        }
    }

输出：

Banana
    Banana
    Pear
    Banana

### 泛型数组 ###

public class GenericsDemo30{   
    
        public static void main(String args[]){  
            Integer i[] = fun1(1,2,3,4,5,6) ;   // 返回泛型数组 
            fun2(i) ;  
        }   
    
        public static <T> T[] fun1(T...arg){  // 接收可变参数 
            return arg ;            // 返回泛型数组 
        }  
    
        public static <T> void fun2(T param[]){   // 输出 
            System.out.print("接收泛型数组：") ;  
            for(T t:param){  
                System.out.print(t + "、") ;  
            }  
        }  
    }

### 泛型方法 ###

一个基本的原则是：无论何时，只要你能做到，你就应该尽量使用泛型方法。也就是说，如果使用泛型方法可以取代将整个类泛化，那么应该有限采用泛型方法。下面来看一个简单的泛型方法的定义：

#### 定义泛型方法 ####

public class Main {
    
        public static <T> void out(T t) {
            System.out.println(t);
        }
    
        public static void main(String[] args) {
            out("findingsea");
            out(123);
            out(11.11);
            out(true);
        }
    }

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

再看一个泛型方法和可变参数的例子：

public class Main {
    
        public static <T> void out(T... args) {
            for (T t : args) {
                System.out.println(t);
            }
        }
    
        public static void main(String[] args) {
            out("findingsea", 123, 11.11, true);
        }
    }1

输出和前一段代码相同，可以看到泛型可以和可变参数非常完美的结合。

#### 通过泛型方法返回泛型类的实例 ####

class Info<T extends Number>{ // 指定上限，只能是数字类型 
        private T var ;     // 此类型由外部决定 
        public T getVar(){  
            return this.var ;     
        }  
        public void setVar(T var){  
            this.var = var ;  
        }  
        public String toString(){       // 覆写Object类中的toString()方法 
            return this.var.toString() ;      
        }  
    }  
    
    public class GenericsDemo27{  
    
        public static void main(String args[]){  
            Info<Integer> i = fun(30) ;  
            System.out.println(i.getVar()) ;  
        }  
        public static <T extends Number> Info<T> fun(T param){  
            Info<T> temp = new Info<T>() ;      // 根据传入的数据类型实例化Info 
            temp.setVar(param) ;        // 将传递的内容设置到Info对象的var属性之中 
            return temp ;   // 返回实例化对象 
        }

#### 使用泛型统一传入参数的类型 ####

class Info<T>{    // 指定上限，只能是数字类型 
        private T var ;     // 此类型由外部决定 
        public T getVar(){  
            return this.var ;     
        }  
        public void setVar(T var){  
            this.var = var ;  
        }  
        public String toString(){       // 覆写Object类中的toString()方法 
            return this.var.toString() ;      
        }  
    }
    
    public class GenericsDemo28{  
    
        public static void main(String args[]){  
            Info<String> i1 = new Info<String>() ;  
            Info<String> i2 = new Info<String>() ;  
            i1.setVar("HELLO") ;        // 设置内容 
            i2.setVar("李兴华") ;      // 设置内容 
            add(i1,i2) ;  
        }  
    
        public static <T> void add(Info<T> i1,Info<T> i2){  
            System.out.println(i1.getVar() + " " + i2.getVar()) ;  
        }  
    }

### 泛型嵌套 ###

Demo类中的info属性是Info类的这种属性，Info类本身需要两个泛型。

class Info<T,V>{       // 接收两个泛型类型 
    
        private T var ;  
        private V value ;   
    
        public Info(T var,V value){  
            this.setVar(var) ;  
            this.setValue(value) ;  
        }   
    
        public void setVar(T var){  
            this.var = var ;  
        }   
    
        public void setValue(V value){  
            this.value = value ;  
        }   
    
        public T getVar(){  
            return this.var ;  
        }   
    
        public V getValue(){  
            return this.value ;  
        }  
    } 
    
    class Demo<S>{   
    
        private S info ;  
        public Demo(S info){  
            this.setInfo(info) ;  
        }  
    
        public void setInfo(S info){  
            this.info = info ;  
        }   
    
        public S getInfo(){  
            return this.info ;  
        }  
    }
    
    public class GenericsDemo31{  
    
        public static void main(String args[]){  
            Demo<Info<String,Integer>> d = null ;       // 将Info作为Demo的泛型类型 
            Info<String,Integer> i = null ;   // Info指定两个泛型类型 
            i = new Info<String,Integer>("李兴华",30) ;   // 实例化Info对象 
            d = new Demo<Info<String,Integer>>(i) ; // 在Demo类中设置Info类的对象 
            System.out.println("内容一：" + d.getInfo().getVar()) ;  
            System.out.println("内容二：" + d.getInfo().getValue()) ;  
        }  
    }