Java 泛型

Java 泛型

泛型在Java中被称之为”JAVA类型”，简称GJ。泛型是JavaSE平台1.5版本增加的新特性。泛型在Java中不是一种数据类型，是一种在编译时期的特殊语法，
它能够让JVM识别从而确定在应用泛型的操作中体现泛型特点，帮助程序员在开发中从泛型中获得更高效和更安全数据的管理操作。
泛型由于不是一种Java的数据类型所以在运行时，JVM将使用擦除法将泛型描述还原成未应用泛型语法的规则进行执行。
泛型基本语法:<T>

泛型能够在代码书写过程中帮助程序员提高效率和数据类型安全。
泛型能够在编译阶段确定数据类型是否符合要求，规避错误发生。
泛型能否避免数据对象强制类型转换操作。
泛型也能够支持在动态下确定数据类型。

 

 

import java.util.Date;

/**
 * 员工实体类
 */
public class Employee {

    private int id;
    private String name;
    private String longName;
    private String password;
    private Date birth;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getLongName() {
        return longName;
    }

    public void setLongName(String longName) {
        this.longName = longName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Date getBirth() {
        return birth;
    }

    public void setBirth(Date birth) {
        this.birth = birth;
    }
}

import com.GJ.entity.Employee;

import java.util.ArrayList;
import java.util.List;

public class Test {

    public static void main(String[] args) {

        List<Employee> employeeList=new ArrayList<Employee>();
        Employee emp=new Employee();
        emp.setId(1);
        emp.setName("十三");

        Employee emp2=new Employee();
        emp2.setId(2);
        emp2.setName("十四");

        Employee emp3=new Employee();
        emp3.setId(3);
        emp3.setName("十五");

        employeeList.add(emp);
        employeeList.add(emp2);
        employeeList.add(emp3);

        for (Employee e:employeeList){

            System.out.println(e.getName()+"\t"+e.getId());
        }
    }
}

Java通配符泛型

List<?> numList = new ArrayList<>(); 使用通配符<?>的泛型，可以把任意类型的对象丢进去。
但是缺点是，调用的时候只能用Object接收，并通过强制类型转换强转，这样就失去了泛型的一个省事儿的优势。所以最好还是使用确定了类型的泛型比较好些。

public class Demo01 {

    public static void main(String[] args) {

        List<Integer> intList=new ArrayList<Integer>();
        intList.add(new Integer(100));
        intList.add(new Integer(200));
       /*  List<Number> numberList=intList;  //会报错*/
        List<?> list=intList;

        for (Object intObj:list){

            System.out.println((Integer)intObj);
        }
        System.out.println("-----------------------------");
        List<Number> numberList=new ArrayList<Number>();
        numberList.add(new Double(6.66));
        numberList.add(new Double(7.66));
        numberList.add(new Double(16.66));
        for (Number n:numberList){

            System.out.println(n);
        }
    }
}

/**
 * 使用Map集合应用泛型
 */
public class Demo02 {

    public static void main(String[] args) {


        Map<String, Set<Employee>> map=new HashMap<String, Set<Employee>>();

        //创建员工对象
        Employee emp=new Employee();
        emp.setName("十三");

        Employee emp2=new Employee();
        emp2.setName("十四");

        Set<Employee> set=new HashSet<Employee>();
        set.add(emp);
        set.add(emp2);
        map.put("e",set);

       Set<Employee> empSet=map.get("e");

       for (Employee e:empSet){

           System.out.println(e.getName());
       }
    }
}

带泛型的类

public class GJClass<T>{ //这种属于隐式泛型。显示的一般有明确的数据类型如<Integer>

public String getClassName(T t){

　　　　return t.getClass().getName();
　　
　　}

}
一般情况下隐式的用的比较多，显示的用得少。

带泛型的接口

public interface CountManager<T>{

　　double count(T t,double r);
　　double count(T t,double bottom,double height);
}

 总结图