第40天

Java 泛型

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。

java 中泛型标记符：

E - Element (在集合中使用，因为集合中存放的是元素)
T - Type（Java 类）
K - Key（键）
V - Value（值）
N - Number（数值类型）
？ - 表示不确定的 java 类型

泛型类

public class Box<T> {
   
  private T t;
 
  public void add(T t) {
    this.t = t;
  }
 
  public T get() {
    return t;
  }
 
  public static void main(String[] args) {
    Box<Integer> integerBox = new Box<Integer>();
    Box<String> stringBox = new Box<String>();
 
    integerBox.add(new Integer(10));
    stringBox.add(new String("菜鸟教程"));
 
    System.out.printf("整型值为 :%d\n\n", integerBox.get());
    System.out.printf("字符串为 :%s\n", stringBox.get());
  }
}

类型通配符

1、类型通配符一般是使用 ? 代替具体的类型参数。例如 List<?> 在逻辑上是 List<String>,List<Integer> 等所有 List<具体类型实参> 的父类。

import java.util.*;
 
public class GenericTest {
     
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
        
        name.add("icon");
        age.add(18);
        number.add(314);
 
        getData(name);
        getData(age);
        getData(number);
       
   }
 
   public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));
   }
}

2、类型通配符上限通过形如List来定义，如此定义就是通配符泛型值接受Number及其下层子类类型。

import java.util.*;
 
public class GenericTest {
     
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
        
        name.add("icon");
        age.add(18);
        number.add(314);
 
        //getUperNumber(name);//1
        getUperNumber(age);//2
        getUperNumber(number);//3
       
   }
 
   public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));
   }
   
   public static void getUperNumber(List<? extends Number> data) {
          System.out.println("data :" + data.get(0));
       }
}

Java 泛型（Generics）是 Java 编程语言的一个特性，它允许在编译时进行类型检查，从而提高代码的类型安全性和可重用性。泛型通过使用类型参数（type parameters）来表示类、接口或方法可以操作的多种类型。

实现原理

泛型通过类型参数来表示类、接口或方法可以操作的多种类型。类型参数通常使用单个大写字母来表示，如 T、E、K、V 等。泛型类型参数在声明类、接口或方法时指定，并在使用时替换为具体的类型。

主要方法

1. 泛型类：

• 定义泛型类时，在类名后面添加类型参数。例如：

public class Box<T> {
    private T t;
    public void add(T t) {
        this.t = t;
    }
    public T get() {
        return t;
    }
}

• 使用泛型类时，在类名后面添加具体的类型。例如：

Box<Integer> integerBox = new Box<Integer>();

2. 泛型接口：

• 定义泛型接口时，在接口名后面添加类型参数。例如：

public interface MyInterface<T> {
    void myMethod(T t);
}

• 使用泛型接口时，在接口名后面添加具体的类型。例如：

MyInterface<String> myInterface = new MyInterface<String>() {
    @Override
    public void myMethod(String s) {
        System.out.println(s);
    }
};

3. 泛型方法：

• 定义泛型方法时，在返回类型前面添加类型参数。例如：

public <T> void myMethod(T t) {
    System.out.println(t);
}

• 使用泛型方法时，在方法名后面添加具体的类型。例如：

myMethod("Hello, World!");

示例代码

import java.util.ArrayList;
import java.util.List;

public class GenericExample {
    public static void main(String[] args) {
        List<String> stringList = new ArrayList<>();
        stringList.add("Hello");
        stringList.add("World");

        List<Integer> integerList = new ArrayList<>();
        integerList.add(1);
        integerList.add(2);

        printList(stringList);
        printList(integerList);
    }

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

---

学完这一篇，是不是对编程又有了新的理解呢？继续加油，下一篇等着你哦～