泛型

泛型概述

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

 

泛型方法 泛型类

/**
 *     泛型类
 * @author 黄旺林啊
 *
 * @param <T>
 */
public class User<T> {

    private T data;

    public User(T data) {
        super();
        this.data = data;
    }

    public User() {
        super();
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
    
}

 

来个测试类

public class TestUser {

    public static void main(String[] args) {
        
        User<String> user1 = new User<String>("李华");//字符串型对象，用户名
        User<Integer> user2 = new User<Integer>(789);//整形对象，用户编号吧
        getData(user1);
        getData(user2);
            
    }
    
}

 

类型通配符

类型通配符一般是使用?代替具体的类型参数。例如 List<?> 在逻辑上是List<String>,List<Integer> 等所有List<具体类型实参>的父类

import java.util.*;
 
public class GenericTest {
     
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
        
        name.add("icon");
        age.add(18);
        number.add(314);
 
        getData(name);
        getData(age);
        getData(number);
       
   }
 
   public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));
   }
}

 

因为getData()方法的参数是List类型的，所以name，age，number都可以作为这个方法的实参，这就是通配符的作用

 

泛型上下界

泛型上下界，其实就是对类型的一种范围约束，比如类型Number,可以作为int、doublle等的类型上限，形式为：<T extends Number >,一般上下限和通配符用，理解如下：

类型通配符上限通过形如Box<? extends Number>形式定义，相对应的，类型通配符下限为Box<? super Number>形式，其含义与类型通配符上限正好相反

<? extends T>表示该通配符所代表的类型是T类型的子类。

<? super T>表示该通配符所代表的类型是T类型的父类。

 

其他补充

具有多个泛型的泛型类

有时候，一个对象的属性中，具有不同的类型属性，那么这样的类也就是需要多种类型，若要用泛型，就需要多个，如下例子：

/**
 *     泛型类
 *     多个不同类型的
 * @author 黄旺林啊
 *
 * @param <T1>
 * @param <T2>
 * @param <T3>
 */

public class Bike<T1,T2,T3> {

    private T1 color;
    private T2 band;
    private T3 price;
    
    public Bike() {
        super();
    }

    public Bike(T1 color, T2 band, T3 price) {
        super();
        this.color = color;
        this.band = band;
        this.price = price;
    }

    public T1 getColor() {
        return color;
    }

    public void setColor(T1 color) {
        this.color = color;
    }

    public T2 getBand() {
        return band;
    }

    public void setBand(T2 band) {
        this.band = band;
    }

    public T3 getPrice() {
        return price;
    }

    public void setPrice(T3 price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Bike [color=" + color + ", band=" + band + ", price=" + price + "]";
    }
    
    
    
}

 

来个测试类

public class TestBike {

    public static void print( Bike<? extends Object,? extends Object,? extends Object> bike) {
        System.out.println(bike);
//        System.out.println(bike.getBand());
    }
    
    public static void main(String[] args) {
//        Bike<String> bike = new Bike<String>("红色","永久牌","899");
//        Bike<String,String,Double> bike = new Bike<String,String,Double>("红色","永久牌",(double)899);//int 能自动转double,Intege不能自动转Double,因为他们是同级类，
        Bike<?,?,?> bike = new Bike<>("红色","永久牌",899);
        print(bike);
    }
}