Java031——泛型

把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection，List，ArrayList 这个<E>就是类型参数，即泛型。

所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数只有在使用时才能确定。

自定义泛型方法

格式：
访问修饰符 <E> 返回值类型 方法名< E 参数名 >

class test {
    // 泛型方法 printParam
    public static <E> void printParam(E param )
    {
        System.out.println();
    }

    public static void main( String args[] )
    {
        // 创建不同类型变量
        Integer intParam = 12;
        Double doubleParam = 12.4;
        Character charParam ='A';

        System.out.println( "整型元素为:" );
        printParam( intParam  ); // 传递一个整型数组

        System.out.println( "\n双精度型元素为:" );
        printParam( doubleParam ); // 传递一个双精度型数组

        System.out.println( "\n字符型元素为:" );
        printParam( charParam ); // 传递一个字符型数组
    }
}

//运行结果
整型元素为:
12

双精度型元素为:
12.4

字符型元素为:
A

自定义泛型类

格式：
class 类名<T>

class Book<T> {                    // 定义带泛型的Book<T>类
    private T bookInfo;            // 类型形参：书籍信息

    public Book(T bookInfo) {      // 参数为类型形参的构造方法
        this.bookInfo = bookInfo;  // 为书籍信息赋值
    }

    public T getBookInfo() {       // 获取书籍信息的值
        return bookInfo;
    }
}

class test {
    public static void main(String[] args) {
        // 创建参数为String类型的书名对象
        Book<String> bookName = new Book<String>("《王二毛历险记》");
        // 创建参数为String类型的作者对象
        Book<String> bookAuthor = new Book<String>("二毛");
        // 创建参数为Double类型的价格对象
        Book<Double> bookPrice = new Book<Double>(88.8);
        // 创建参数为Boolean类型的附赠源码
        Book<Boolean> hasSource = new Book<Boolean>(true);

        // 控制台输出书名、作者、价格和是否真实事件
        System.out.println("书名：" + bookName.getBookInfo());
        System.out.println("作者：" + bookAuthor.getBookInfo());
        System.out.println("价格：" + bookPrice.getBookInfo());
        System.out.println("是否真实事件？" + hasSource.getBookInfo());
    }
}

//运行结果
书名：《王二毛历险记》
作者：二毛
价格：88.8
是否真实事件？true

自定义泛型接口

泛型接口的定义格式:
interface 接口名<声明自定义泛型>{

}

//定义了一个名为Dao的泛型接口，使用<T>来表示类型参数。
interface Dao<T>{
    public void add(T t);
}

class DaoImpl implements Dao<String>{
    @Override
    public void add(String  str) {
        System.out.println("Processing string: " + str);
    }
}

class DaoImplPlus implements Dao<Integer>{
    @Override
    public void add(Integer  i) {
        System.out.println("Processing Integer: " + i);
    }
}

class test {
    public static void main(String[] args) {
        DaoImpl daoImpl = new DaoImpl();
        daoImpl.add("Hello");
        DaoImplPlus daoImplPlus = new DaoImplPlus();
        daoImplPlus.add(123);
    }
}

//运行结果
Processing string: Hello
Processing Integer: 123

在上述示例中，分别实现了Dao接口的两个具体类DaoImpl和DaoImplPlus 。每个实现类都指定了一个具体的类型作为T的替代。

在实现类中，必须实现泛型接口中定义的方法，并传入相应类型的参数进行具体的操作。

使用自定义的泛型接口，你可以根据需求创建不同类型的实现类，并对各自的类型进行具体的操作。这样，你就可以在不同场景下重用相同的接口定义，但可以为不同的类型提供不同的行为。

类型通配符

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

class test {
    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));
    }
}

//运行结果
data :icon
data :18
data :314

参考文章