JavaSE—泛型

1 泛型定义和基本使用

泛型是JDK1.5以后才有的， 可以在编译时期进行类型检查，且可以避免频繁类型转化！

@Test
public void test1() {
    List list = new ArrayList();
    list.add("ZhangSan");
    list.add(1);
    //集合使用 取出元素
    Object object = list.get(0);
    System.out.println(object);
    String str1 = (String) list.get(0);
    System.out.println(str1);
    //String str2 = (String) list.get(1);//ClassCastException
}

//使用泛型
@Test
public void test2() {
    //声明泛型集合的时候指定元素的类型
    List<String> list = new ArrayList<>();
    list.add("Java");
    //泛型解决的的是编译时期的报错，提前检查
    //list.add(1);//会报错
    String str = list.get(0);
    System.out.println(str);
}

    @Test
    public void test3() {
        // 两端的数据类型必须要一致
        List<Object> list1 = new ArrayList<Object>();
        List<String> list2 = new ArrayList<String>();
        // 右侧的泛型可以不写
        List<String> list3 = new ArrayList<>();
        // 只在右侧写泛型不起作用
        List list4 = new ArrayList<String>();
        list4.add(1);

        // 两边不一致编译时候报错 -----> 红色波浪线
        // List<Object> list5 = new ArrayList<String>();
        // 泛型类型必须为引用数据类型
        // List<int> list6 = new ArrayList<>();
    }

2 泛型擦除

泛型只在编译时期有效，编译后的字节码文件中不存在有泛型信息！

1. 帮助开发者写出正确的代码。

2. 虚拟机的向下兼容问题

    @Test
    public void test5() {
        List<String> list1 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();
        Class clazz1 = list1.getClass();
        Class clazz2 = list2.getClass();
        System.out.println(clazz1 == clazz2);
        System.out.println(clazz1);
        System.out.println(clazz2);
    }

    //泛型擦除:参数都是List list   认为是同一个方法
    /*public void add(List<Student> list) {

    }
    public void add(List<Teacher> list) {

    }*/
    //'add(List<Student>)' clashes with 'add(List<Teacher>)'; both methods have same erasure

3 泛型方法/泛型类/泛型接口

作用：设计公用的类、方法，对公用的业务实现进行抽取！使程序更灵活！

泛型方法

public class GenericDemo2 {

    public Student add1(Student student, Teacher teacher) {
        return null;
    }

    public <K,T> K add(K k, T t) {
        return k;
    }

    @Test
    public void test1() {
        // 使用泛型方法:  在使用泛型方法的时候，确定泛型类型
        Float result1 = add(1.0f, 1);
        System.out.println(result1);

        String result2 = add("abc", 1);
        System.out.println(result2);
    }
}

泛型类

不用像泛型方法那样每个方法都要声明。

public class BaseDao<T> {
    public <K> K save(K k) {
        return k;
    }
    public void add(T t) {
    }

    public void update(T t) {
    }
}

@Test
public void test2() {
    Student student = new Student();
    BaseDao<Student> baseDao1 = new BaseDao<>();
    baseDao1.add(student);
    baseDao1.update(student);

    Teacher teacher = new Teacher();
    BaseDao<Teacher> baseDao2 = new BaseDao<>();
    baseDao2.add(teacher);
    baseDao2.update(teacher);
}

泛型接口

public interface IBaseDao<T> {
    void add(T t );
    void update(T t );
}
//泛型接口类型确定： 在业务实现类中直接确定接口的类型
public class PersonDao implements IBaseDao<Person> {
}

4 泛型关键字

常用的 ？, T, E, K, V, N的含义

我们在泛型中使用通配符经常看到T、F、U、E，K，V其实这些并没有啥区别,我们可以选 A-Z 之间的任何一个字母都可以，并不会影响程序的正常运行。

只不过大家心照不宣的在命名上有些约定:

T (Type) 具体的Java类

E (Element)在集合中使用，因为集合中存放的是元素

K V (key value) 分别代表java键值中的Key Value

N （Number）数值类型

? 表示不确定的 Java 类型

泛型中：

? 在泛型代码中，问号(?)称为通配符，用来表示不确定的 Java 类型

extends 元素的类型必须继承自指定的类

super 元素的类型必须是指定的类的父类

使用<?>通配符，可以使方法更加灵活，可以接受不同类型的 List 列表，同时又不会对List进行修改，保证代码的安全性。

既要限定传递过来的是集合类型，但是又不确定里面类型List<?> list；

public void add1(List<?> list) {

}

// extends      元素的类型必须继承自指定的类
/**
* list集合只能处理 Double/Float/Integer等类型
* 限定元素范围：元素的类型要继承自Number类  (上限)
* @param list
*/
public void add2(List<? extends Number> list) {
}

@Test
public void testGeneric23() throws Exception {
    List<Double> list1 = new ArrayList<Double>();
    List<Float> list2 = new ArrayList<Float>();
    List<Integer> list3 = new ArrayList<Integer>();
    List<String> list4 = new ArrayList<String>();

    // 调用
    add2(list1);
    add2(list2);
    add2(list3);
    //add2(list4);
}

/**
* super限定元素范围：必须是String父类,String类也可以   (下限)
* @param list
*/
public void add3(List<? super String> list) {
}

@Test
public void testGeneric24() throws Exception {
    // 调用上面方法，必须传入String的父类
    List<Object> list1 = new ArrayList<Object>();
    List<String> list2 = new ArrayList<String>();
    List<Integer> list3 = new ArrayList<Integer>();
    
    //add(list3);
}

5 List和List<?>的区别

ChatGPT 也可能会犯错。请核查重要信息。

这两段代码之间的主要区别在于泛型的使用。让我们仔细看看每段代码，并解释它们的差异。

第一段代码

public void add(List<?> list) {
    //list.add(1);//Required type: capture of ? | Provided:int
    for (Object object : list) {
        System.out.println(object);
    }
}

解释

• List<?>：这是一个使用通配符 ? 的泛型列表。这表示列表可以包含任何类型的元素，但是我们不能向这个列表添加任何元素（除了 null）。
  • 为什么不能添加元素：由于 List<?> 表示一个未知类型的列表，编译器无法确定添加的元素是否与列表的实际类型兼容。因此，添加操作会导致编译错误。
  • 遍历元素：我们可以遍历这个列表，并将每个元素作为 Object 类型处理，因为我们不知道确切的元素类型。

示例：

public void add(List<?> list) {
    // 编译错误：不能向未知类型的列表添加元素
    // list.add(1);
    
    // 可以遍历列表并打印元素
    for (Object object : list) {
        System.out.println(object);
    }
}

第二段代码

public void add1(List list) {
    //list.add(1);//Required type: capture of ? | Provided:int
    for (Object object : list) {
        System.out.println(object);
    }
}

解释

• List（原始类型）：这是一个原始类型的列表，没有使用泛型。这意味着列表可以包含任何类型的元素，且类型检查在编译时被绕过，但在运行时可能导致 ClassCastException。
  • 可以添加元素：尽管没有泛型限制，可以向列表添加元素。然而，这种做法会失去类型安全性。
  • 遍历元素：我们可以遍历这个列表，并将每个元素作为 Object 类型处理。

示例：

public void add1(List list) {
    // 可以向原始类型的列表添加元素，但这不安全
    list.add(1);
    
    // 可以遍历列表并打印元素
    for (Object object : list) {
        System.out.println(object);
    }
}

关键区别

1. 类型安全性：

   • List<?> 提供类型安全性，不能向列表添加元素，除了 null。
   • List 是原始类型，没有类型安全性，可以向列表添加任何类型的元素，但这可能会在运行时导致 ClassCastException。

2. 编译检查：

   • List<?> 在编译时会进行类型检查，确保没有非法的添加操作。
   • List 由于没有泛型，编译器无法提供类型检查，这可能导致潜在的运行时错误。

3. 可添加元素：

   • 在 List<?> 中，不能添加元素（除了 null）。
   • 在 List 中，可以添加任何类型的元素。

总结

• List<?>：使用通配符泛型表示未知类型的列表，提供类型安全性，但不能添加元素。
• List：使用原始类型，没有类型安全性，可以添加任何类型的元素，但可能导致运行时错误。

选择使用哪种类型取决于具体的需求和安全性考虑。对于大多数情况下，使用泛型是推荐的做法，因为它提供了编译时的类型检查，从而提高了代码的安全性和可维护性。

6 全面简单地介绍下Java的泛型及其作用

ChatGPT 也可能会犯错。请核查重要信息。

Java的泛型

泛型是Java编程语言的一项强大特性，它允许你定义和使用带有类型参数的类、接口和方法。泛型提供了编译时的类型检查和代码重用性，减少了类型转换的需要和运行时错误的风险。

主要特性和语法

1. 泛型类和接口：
   定义包含类型参数的类或接口。

   public class Box<T> {
       private T content;
   
       public void setContent(T content) {
           this.content = content;
       }
   
       public T getContent() {
           return content;
       }
   }
   

2. 泛型方法：
   定义带有类型参数的方法。

   public class Util {
       public static <T> void printArray(T[] array) {
           for (T element : array) {
               System.out.println(element);
           }
       }
   }
   

3. 类型推断：
   在调用泛型方法时，编译器可以根据传递的参数推断出类型参数。

   Box<Integer> intBox = new Box<>();
   intBox.setContent(123);
   Integer content = intBox.getContent();
   

4. 通配符：
   使用问号 ? 表示未知类型。

   public void processList(List<?> list) {
       for (Object obj : list) {
           System.out.println(obj);
       }
   }
   

5. 边界通配符：
   限制类型参数的范围，可以是上界或下界。

   public void processNumbers(List<? extends Number> list) { // 上界通配符
       for (Number num : list) {
           System.out.println(num);
       }
   }
   
   public void addNumbers(List<? super Integer> list) { // 下界通配符
       list.add(123);
   }
   

6. 泛型限制：
   泛型类型不能是基本类型（如 int，char 等），只能是引用类型（如 Integer，String 等）。

   // 正确的写法
   List<Integer> list = new ArrayList<>();
   
   // 错误的写法
   // List<int> list = new ArrayList<>();
   

泛型的作用

1. 类型安全：
   泛型提供了编译时的类型检查，防止类型转换错误。例如，使用泛型集合可以确保集合中的所有元素都是指定类型。

   List<String> list = new ArrayList<>();
   list.add("hello");
   // list.add(123); // 编译时错误
   

2. 减少类型转换：
   使用泛型可以减少显式类型转换的需要，从而使代码更加简洁和可读。

   List<String> list = new ArrayList<>();
   list.add("hello");
   String str = list.get(0); // 不需要类型转换
   

3. 代码重用：
   泛型使得可以编写通用的类、接口和方法，这些代码可以与不同类型的对象一起工作，提高代码的重用性。

   public class Pair<T, U> {
       private T first;
       private U second;
   
       public Pair(T first, U second) {
           this.first = first;
           this.second = second;
       }
   
       // getter 和 setter
   }
   
   Pair<String, Integer> pair = new Pair<>("age", 30);
   

4. 提高代码可读性：
   泛型使得代码更加清晰和可读，因为类型信息明确。

   // 不使用泛型
   List list = new ArrayList();
   list.add("hello");
   String str = (String) list.get(0); // 类型转换
   
   // 使用泛型
   List<String> list = new ArrayList<>();
   list.add("hello");
   String str = list.get(0); // 无需类型转换
   

总结

Java 的泛型是一种用于定义和使用带有类型参数的类、接口和方法的强大特性。它提供了类型安全、减少类型转换、代码重用和提高代码可读性等诸多优点。在现代 Java 编程中，泛型广泛应用于集合框架和许多库中，极大地增强了语言的灵活性和安全性。