转载

Java语法总结——泛型

当定义类时，有些方法的参数是不能够确定的，可以用泛型类名来表示，当类的对象创建时会指出具体的类型，类型作为参数传递给泛型，从而进行使用。

二、集合使用泛型

1.不使用泛型：创建集合对象时，如果不指定类型，默认是object类型

优点：可以存储任意类型。

弊端：在使用元素时，要类型转换，容易引发异常。

2.使用泛型：优点：把运行时异常提升到了编译时异常，不用类型转换。

弊端：只能存储单一类型。

三、定义含有泛型的类

public class GenericClass {
    public static void main(String[] args) {
        User user1 = new User(); //当不指定泛型时，默认是object类型
        user1.setUser("hello");
        Object obj = user1.getUser();
        User<Integer> user2 = new User<>();//使用泛型，类型为integer
        user2.setUser(123);
        Integer user = user2.getUser();
        User<String> user3 = new User<>();//使用泛型，类型为string
        user3.setUser("hhhhhhh");
        String u = user3.getUser();
    }
}
class User<E>{  //定义泛型
    private E user;

    public E getUser() {
        return user;
    }

    public void setUser(E user) {
        this.user = user;
    }
}
复制代码

四、定义含有泛型的方法

1.格式

修饰符 泛型 返回值 方法名（参数（可使用泛型））{
    方法体
}
复制代码

2.举例

public class GenericMethod {
    public static void main(String[] args) {
        GenericMethod gm = new GenericMethod();
        gm.m1(123);  //方法参数可以是任意类型
        gm.m1("hello");
        gm.m1(true);
        GenericMethod.m2("hello");
        GenericMethod.m2(123);
        GenericMethod.m2(10);
    }
    //定义含有泛型的方法
    public <M> void m1(M m){  //参数列表可使用泛型
        System.out.println(m);
    }
    //定义含有泛型的静态方法
    public static <M> void m2(M m){
        System.out.println(m);
    }
}

复制代码

五、定义含有泛型的接口

定义接口

public interface GernericInterface<I> {
    void print(I i);
}
复制代码

实现方式一：指定具体类型

public class GernericInterfaceImpl1 implements GernericInterface<String>{
    @Override
    public void print(String s) {
        System.out.println(s);
    }
}
复制代码

实现方式二：不进行具体类型的指定，创建类对象时再指定

public class GernericInterfaceImpl2<I> implements GernericInterface<I>{
    @Override
    public void print(I i) {
        System.out.println(i);
    }
}
复制代码

测试

public class GernericInterfaceTest {
    public static void main(String[] args) {
        //第一种方法测试
        GernericInterfaceImpl1 g1=new GernericInterfaceImpl1();
        g1.print("hello");
        //第二种方法测试
        GernericInterfaceImpl2<Integer> g2 = new GernericInterfaceImpl2<>();
        g2.print(123);
    }
}
复制代码

六、泛型通配符

语法格式<?> 可以接受不明确的类型

可用于方法的参数中，不能用在创建对象中。

例子

public class demo_3_Generic {
    public static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();//创建两个不同类型的集合
        list1.add(100);
        list1.add(200);
        ArrayList<String> list2 = new ArrayList<>();
        list2.add("hello");
        list2.add("world");
        printArrayList(list1); //都调用打印方法
        printArrayList(list2);
    }
    public  static void  printArrayList(ArrayList<?> list){ //运用通配符
        Iterator<?> it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}
复制代码

泛型的上限限定：<? extends E> 接收参数的类型必须是E类型的子类或本身

泛型的下限限定：<? super E> 接收参数的类型必须是E类型的父类或本身

原文 https://juejin.im/post/5efc9735e51d45346810514c

正文到此结束