JAVA泛型深入学习理解

最新推荐文章于 2024-10-23 11:26:38 发布

花泽生菜.

最新推荐文章于 2024-10-23 11:26:38 发布

阅读量463

点赞数

分类专栏： java学习文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_51270766/article/details/122659485

版权

java学习专栏收录该内容

15 篇文章 1 订阅

订阅专栏

1、为什么要有泛型

集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。 Collection， List，ArrayList 这个就是类型参数，即泛型。

在集合中， Java加上泛型就可以让元素类型更安全，避免出现异常ClassCastException

1.1 什么是泛型

所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参）。

2、使用泛型

我们在前面接触到泛型，都是用的是集合中的泛型，没有其余的地方使用到泛型

2.1 在集合中使用泛型

在集合中使用泛型

    public void test1() {
        List<String> list = new ArrayList<String>();
        list.add("String"); // 安全类型    
        list.add(123); // 编译错误，类型不一致
    }

在Map中使用泛型

public void test2() {
        Map<String, Human> map = new HashMap<String, Human>();
        map.put("String", new Huamn("Hello", 123));
        map.put("String", new Obejct());  // 会发生错误，类型不一致，数据安全 
            }

3、泛型自定义

3.1 自定义泛型

3.1.1 泛型的声明

jdk8举例

// List
public interface List<E> extends Collection<E>{}
// Map
public interface Map<K,V> {}

说明，其中E， K， V 都是代表一个类型，不是具体类型，只要是变量就可以

3.1.2 泛型的实例化

在类名后面指定类型参数（泛型）

List<Sting> list=new ArrayList<String>();
Set<String> set=new HashSet();//1.7之后加的

说明， <> 一对尖括号中只能放置引用数据类型，非基本数据类型

3.2 定义泛型类/接口

3.2.1 特点说明和举例

泛型类可以有多个参数，放在同一个尖括号内，用"， " 隔开

/*
    L,U 类型参数
**/
 public class Calculator<L,U> {
    }

构造方法不含有尖括号

public class Order<E> {
    List<E> productions = new ArrayList<>();
    public void setProductions(List<E> productions) {
    this.productions = productions;
    }

public List<E> getProductions() {
    return productions;
}

public Order() {
    }
}

创建对象之后，泛型位置要和指定的泛型一致

public void test4() {
        Order<Computer> order = new Order<>();
        List<String> list = new ArrayList<>();
        order.setProductions(list); // 这个位置会发生错误
    }

泛型之间不能互相赋值

public void test5() {
    Order<Computer> order=new Order<>();
    Order<Human< order1=new Order<>();
  //order=order1; 会发生错误
    Order<Human> humanOrder = new Order<>();
    Order<Student> studentOrder = new Order<>();
 //    humanOrder = studentOrder; // 会发生错误
       Order<Student> studentOrder1 = new Order<>();
       studentOrder1 = studentOrder; // 没有错误，赋值的时候，需要保持泛型一致
       Human student = new Student();
}

若不指定泛型则会被擦除(不指定泛型，就会Object)

public void test6() {
        List<Integer> list = new ArrayList<>();
        list.add(123);
        List llist1 = new ArrayList(); //
        llist1.add(new Object()); // 如果不指定类型就会将泛型位置的类型变为Object                                   llist1.add(new Human());// 向上转型
//  Employee[] employees = new Employee[10];
// employees[0] = new GeneralEmployee(); // 向上转型，在泛型中也同样适用
    }

泛型结构若是抽象的，则不可以创建对象(实例)

public void test7() {
        Employee<Computer> employee = new Employee<Computer>() {
        // new Employee<Computer>()
        // 这个位置的Computer不能被省略
    };
InterGeneric<Computer> interGeneric = new InterGeneric<Computer>() {};
// 匿名泛型类不可以省略泛型的内容，也就是不能使用菱形语法
// 但是可以完全省略泛型
    }

简化操作<>

1.7 之后可以使用菱形语法

创建对象时，不能放基本数据类型

在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静

态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。

// 泛型类或接口在使用静态方法时，不允许指定泛型
// 只有在创建对象时才可以指定泛型

异常不能带泛型

不能使用new E[]。但是可以： E[] elements = (E[])new Object[capacity]; Object[] elementData;

public List<E> getProductions() {
        new E[123]; // 有错误
        new E();// 有错误


        E[] es = (E[])new Computer[123]; // 没有错误
        E e = (E) new Computer(); // 没有错误
        E e1 = (E) new Object(); // 没有错误

        return productions;
}

父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：

子类不保留父类的泛型：按需实现

没有类型擦除

具体类型

子类保留父类的泛型：泛型子类

全部保留，要注意，保留的泛型写法上字母要和父类的一致

部分保留

结论：子类除了指定或保留父类的泛型，还可以增加自己的泛型

3.3 定义泛型方法

单独一个方法也可以被泛型化，无论此时定义在其中的类是不是泛型类。在泛型方法中可以定义泛

型参数，此时，参数的类型就是传入数据的类型。

泛型方法的格式：

[访问权限] <泛型> 返回类型方法名([泛型参数名称]) 抛出的异常

举例

代码

public static <T> List<T> arrayToList(T[] array) {
         List<T> list = new ArrayList<>();
            for (T t : array) {
            list.add(t);
                }
            return list;
    }

4、继承

说明：泛型是泛型，类是类，泛型类是泛型类

  @Test
  public void test1() {
      List<Human> humanList = new ArrayList<>();
      List<Student> students = new ArrayList<>(); 5      /*
             List<Human> 和List<Student>都是List, 这两个之前没有继承关系
             humanList = students 是错误的 8       */
      }

5、通配符

？父类类型，只读，返回 Object ，不能写入对象，但能写入 null

List<?> 是 List List 的父类类型

public void test2() { 
     List<?> list = new ArrayList<>();
     List<Human> humanList = new ArrayList<>();
     List<Student> students = new ArrayList<>(); 
     list = humanList; // 正确 list = students; // 正确
 // list.add(new Student()); 错误
 // list.add(new Object()); 错误 
    int size = list.size();
     System.out.println("size = " + size); 
     list.add(null); size = list.size();
     System.out.println("size = " + size); }
    public static void test(List<?> list) { 
        // List<?> 只读状态，不能插入元素，但可以插入null 
        // List<?> 其实就相当于List<任意一个类型>的父类了 
        }

上限

上限 extends ：使用时指定的类型必须是继承某个类，或者实现某个接口，即 <=

下限

下限 super ：使用时指定的类型不能小于操作的类，即 >=

注意：添加元素的时候，考虑的是多少的问题，赋值的时候，考虑父子关系

public static void testExtends(List<? extends Person> list) { 
    Person human = list.get(0); 
}
public static void testSuper(List<? super Person> list) {
    Object object = list.get(0);
 }
@Test
 public void test2() { 
         List<? super Person> list = new ArrayList<>();
         list.add(new Person()); 
         list.add(new Student());
         List<Human> humanList = new ArrayList<>();
         humanList.add(new Human());
         humanList.add(new Human()); 
         humanList.add(new Human()); 
         testSuper(humanList);
}
@Test 
public void test1() {
     List<? extends Human> list = new ArrayList<>();
     // (-∞, Human]
     list.add(null); 

     List<Person> personList = new ArrayList<>();
     List<Student> studentList = new ArrayList<>();

     testExtends(personList);
     testExtends(studentList); 
}