java中的泛型

作者 : 开心源码 本文共4498个字,预计阅读时间需要12分钟 发布时间: 2022-05-12 共193人阅读

泛型就是参数化类型

?适用于多种数据类型执行相同的代码
?泛型中的类型在使用时指定,即便用时已确认类型
?泛型归根究竟就是“模版”,所以写框架中一般都会运用到。

优点:使用泛型时,在实际使用之前类型就已经确定了,不需要强制类型转换。

泛型主要使用在集合中

public void TestArrayList() {            List list = new ArrayList();            list.add("string1");            list.add("string2");            list.add(100);//假如使用泛型(List<String>) ,此处通不过编译            for (int i = 0; i < list.size(); i++) {                String name = (String) list.get(i); // 此处会报异常java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String                System.out.println("name:" + name);            }        }

通过泛型,可以在编译阶段发现问题,避免出现类型出错的异常。

自己设置泛型

泛型字母

  • 形式类型参数(formal type parameters)即泛型字母

  • 命名泛型字母可以随便指定,尽量使用单个的大写字母(有时候多个泛型类型时会加上数字,比方T1,T2)
    常见字母(见名知意)
    ?T Type
    ?K V Key Value
    ?E Element

  • 当类被使用时,会使用具体的实际类型参数(actual type argument)代替

泛型类

? 只能用在成员变量上,只能使用引用类型
注意:
? 泛型的类型参数只能是类类型,不能是简单类型。
? 不能对确切的泛型类型使用instanceof操作。这样的操作(if(ex_num instanceof Generic<Number>){ })是非法的,编译时会出错。

/** * 自己设置泛型类 * * 定义"模版"的时候,泛型用泛型字母:T 代替 * 在使用的时候指定实际类型 * * @author Administrator * @param <T> */public class Student<T> {    private T javase;    //private static T javaee;   // 泛型不能使用在静态属性上   public Student() {  }   public Student(T javase) {    this();    this.javase = javase;  }   public T getJavase() {    return javase;  }   public void setJavase(T javase) {    this.javase = javase;  }  }/** * 自己设置泛型的使用 * 在公告时指定具体的类型 * 不能为基本类型 * */class Demo02 {  public static void main(String[] args) {    //Student<int>  Student = new Student<int>(); //不能为基本类型,编译时异常        Student<Integer> student = new Student<Integer>();    student.setJavase(85);    System.out.println(student.getJavase());    }}

泛型接口
?只能用在笼统方法上

/** * 自己设置泛型接口 * * 接口中泛型字母只能使用在方法中,不能使用在全局常量中 * * @author Administrator * @param <T> */public interface Comparator<T1,T2> {    //public static final T1 MAX_VALUE = 100; //接口中泛型字母不能使用在全局常量中  //T1 MAX_VALUE;  public static final int MAX_VALUE = 100;    void compare(T2 t);  T2 compare();  public abstract T1 compare2(T2 t);}

泛型方法
?返回值前面加上 <T>

import java.io.Closeable;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.util.List;  /** * 非泛型类中定义泛型方法 * @author Administrator * */public class Method {   // 泛型方法,在返回类型前面使用泛型字母  public static <T> void test1(T t){    System.out.println(t);  }    // T 只能是list 或者者list 的子类  public static <T extends List> void test2(T t){    t.add("aa");  }    // T... 可变参数   --->   T[]  public static <T extends Closeable> void test3(T...a) {    for (T temp : a) {     try {       if (null != temp) {         temp.close();       }     } catch (Exception e) {       e.printStackTrace();     }         }  }    public static void main(String[] args) throws FileNotFoundException {    test1("java 是门好语言");    test3(new FileInputStream("a.txt"));  }}

泛型的继承

/** * 泛型继承 * * 保留父类泛型 ----》泛型子类  * 不保留父类泛型 -----》子类按需实现 * * 子类重写父类的方法,泛型类型随父类而定 子类使用父类的属性,该属性类型随父类定义的泛型 * * @author Administrator * * @param <T1> * @param <T2> */public abstract class Father<T1, T2> {  T1 age;   public abstract void test(T2 name);} // 保留父类泛型 ----》泛型子类// 1)一律保留class C1<T1, T2> extends Father<T1, T2> {   @Override  public void test(T2 name) {   }} // 2) 部分保留class C2<T1> extends Father<T1, Integer> {   @Override  public void test(Integer name) {   }} // 不保留父类泛型 -----》子类按需实现// 1)具体类型class C3 extends Father<String, Integer> {   @Override  public void test(Integer name) {   }} // 2)没有具体类型// 泛型擦除:实现或者继承父类的子类,没有指定类型,相似于Objectclass C4 extends Father {   @Override  public void test(Object name) {  }}

泛型通配符

  • ?未知类型 类型参数赋予不确定值,任意类型, 只能用在公告类型、方法参数上,不能用在定义泛型类上
/** * 泛型的通配符 类型不确定,用于公告变量或者者形参上面 * * 不能使用在类上 或者者  new 创立对象上 * @author Administrator * */public class Demo04 {   // 用在形参上  public static void test(List<?> list) {    List<?> list2; // 用在公告变量上   list2 = new ArrayList<String>();   list2 = new ArrayList<Integer>();   list2 = new ArrayList<Object>();   }   public static void main(String[] args) {   test(new ArrayList<String>());   test(new ArrayList<Integer>());  }}

Generic<Integer>不能被看作为`Generic<Number>的子类。由此可以看出:同一种泛型可以对应多个版本(由于参数类型是不确定的),不同版本的泛型类实例是不兼容的。

泛型上下边界 extends/super

上限(extends)

指定的类必需是继承某个类,或者者实现了某个接口(不是implements),即<=

  • ? extends List

下限(super)

即父类或者本身

  • ? super List
/** * extends:泛型的上限 <= 一般用于限制操作 不能使用在增加数据上,一般都是用于数据的读取 * * supper:泛型的上限 >= 即父类或者自身。一般用于下限操作 * * @author Administrator * @param <T> */ public class Test<T extends Fruit> {   private static void test01() {    Test<Fruit> t1 = new Test<Fruit>();    Test<Apple> t2 = new Test<Apple>();    Test<Pear> t3 = new Test<Pear>();    t1.getCustFruit(new ArrayList<Fruit>());    Apple apple=t2.getCustFruit(new ArrayList<Apple>());    Pear pear=t2.getCustFruit(new ArrayList<Pear>());  }   private static void test02(List<? extends Fruit> list) {   }   private static void test03(List<? super Apple> list) {   }  //在泛型方法中增加上下边界限制的时候,必需在权限公告与返回值之间的<T>上增加上下边界,即在泛型公告的时候增加  public <T1 extends Fruit> T1 getCustFruit(List<T1> list){            if(list!=null&&list.size()>0) {                return list.get(0);            }else{                return null;            }        }   public static void main(String[] args) {     // 调用test02(),测试 extends  <=    test02(new ArrayList<Fruit>());    test02(new ArrayList<Apple>());    test02(new ArrayList<ReadApple>());    // test02(new ArrayList<Object>()); Object 不是 Fruit 的子类 ,编译不通过            // 调用test03() ,测试super >=    test03(new ArrayList<Apple>());    test03(new ArrayList<Fruit>());    //test03(new ArrayList<ReadApple>());  ReadApple < apple,所以不能放入  } } class Fruit { } class Apple extends Fruit { } class Pear extends Fruit { } class ReadApple extends Apple { }

说明
1. 本站所有资源来源于用户上传和网络,如有侵权请邮件联系站长!
2. 分享目的仅供大家学习和交流,您必须在下载后24小时内删除!
3. 不得使用于非法商业用途,不得违反国家法律。否则后果自负!
4. 本站提供的源码、模板、插件等等其他资源,都不包含技术服务请大家谅解!
5. 如有链接无法下载、失效或广告,请联系管理员处理!
6. 本站资源售价只是摆设,本站源码仅提供给会员学习使用!
7. 如遇到加密压缩包,请使用360解压,如遇到无法解压的请联系管理员
开心源码网 » java中的泛型

发表回复