Java泛型的使用

1、概念

泛型是一种未知的类型，当不知道使用什么数据类型的时候，可以使用泛型

2、使用泛型的好处

下面列举在创建集合对象时候使用泛型与不使用泛型优缺点的对比：

/*
        创建集合对象，使用泛型
        好处：
            避免了类型转换的麻烦，存储什么类型，取出就是什么类型
            把运行期间（代码运行之后）的异常提前到编译器（写代码的时候）
        弊端：
            泛型是什么类型，只能存储什么类型的数据
    */
    //创建集合对象，使用泛型
    private static void show02() {
        ArrayList<String> list=new ArrayList<>();
        list.add("xcv");
//        list.add(1);//因为创建集合使用String类型，所以不能存储整数类型的数据

        //使用迭代器遍历list集合
        Iterator<String>it= list.iterator();
        //while循环判断是否包含可以迭代元素
        while (it.hasNext()){
            //返回下一个迭代的元素
            String s=it.next();
            System.out.println(s);
        }
    }

/*
        创建集合不使用泛型
        好处：
            集合不使用泛型，默认类型为Object类型，可以存储任意类型的数据
        弊端：
            不安全，会引发异常
    */

    //创建集合对象，不使用泛型
    private static void show01(){
        ArrayList list=new ArrayList();
        list.add("1,2,3");
        list.add(1);

        //使用迭代器遍历集合
        Iterator it=list.iterator();
        while (it.hasNext()){
            Object obj=it.next();
            System.out.println(obj);
        }
    }

3、泛型的定义和使用

3.1定义和使用含有泛型的类

//创建泛型类
public class Generic<E> {
    /*
       定义泛型集合的类，泛型是一个未知的数据类型
       创建对象的时候确定泛型的类型
    */
    private E name;

    public E getName() {
        return name;
    }

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

public static void main(String[] args) {
    //创建Generic对象，类型为Integer
    Generic<Integer> gc=new Generic<>();
    gc.setName(1);
    Integer name = gc.getName();
    System.out.println(name);

    //创建Generic对象，类型为String
    Generic<String> gc1=new Generic<>();
    gc1.setName("鸟");
    String name1 = gc1.getName();
    System.out.println(name1);
}

3.2定义和使用含有泛型的方法

public class GenericMethod {
    //创建一个泛型方法
    public <M>void method01(M m){
        System.out.println(m);
    }
    
    //创建一个静态泛型方法
    public static <s>void method02(s s){
        System.out.println(s);
    }
}

public class test {
    public static void main(String[] args) {
        //创建类对象
        GenericMethod gm=new GenericMethod();
        //调用泛型方法，传入数据类型
        gm.method01("这是一个泛型方法，类型为String");
        //调用静态泛型方法，传入数据类型
        GenericMethod.method02("这是一个静态泛型方法，可以直接用类调用");
    }
}

3.3定义和使用含有泛型的接口

//创建泛型接口
public interface MyGenericInterface<E>{
	public abstract void add(E e);
	
	public abstract E getE();  
}

使用泛型接口包含两种方式：
1、定义类时确定泛型的类型

public class MyImp1 implements MyGenericInterface<String> {
@Override
   public void add(String e) {
       // 省略...
  }
​
@Override
    public String getE() {
        return null;
    }
}
此时，泛型E的值就是String类型。

2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型

public class MyImp2<E> implements MyGenericInterface<E> {
@Override
public void add(E e) {
      // 省略...
}
​
@Override
public E getE() {
return null;
}
}
确定泛型：
/*
* 使用
*/
public class GenericInterface {
   public static void main(String[] args) {
       MyImp2<String>  my = new MyImp2<String>();  
       my.add("aa");
  }
}