重生之我在deepseek中学习java 第八天-Java-E先生的博客

Java学习指南-第八天：泛型

　　1.泛型简介

　　泛型（Generics）是Java 5引入的特性，允许在定义类、接口和方法时使用类型参数。泛型的主要目的是提高代码的重用性和类型安全性。

　　2.泛型类

　　泛型类是在类定义时使用类型参数的类。类型参数可以在类内部作为类型使用。

　　2.1定义泛型类

public class Box<T> {
    private T item;

    public void setItem(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }
}

　　2.2使用泛型类

public class Main {
    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();
        stringBox.setItem("Hello");
        System.out.println("String Box: " + stringBox.getItem());

        Box<Integer> integerBox = new Box<>();
        integerBox.setItem(123);
        System.out.println("Integer Box: " + integerBox.getItem());
    }
}

　　3.泛型方法

　　泛型方法是在方法定义时使用类型参数的方法。类型参数可以在方法内部作为类型使用。

　　3.1定义泛型方法

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

    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3, 4, 5};
        String[] strArray = {"A", "B", "C"};

        printArray(intArray);
        printArray(strArray);
    }
}

　　4.泛型接口

　　泛型接口是在接口定义时使用类型参数的接口。类型参数可以在接口内部作为类型使用。

　　4.1定义泛型接口

public interface Pair<K, V> {
    K getKey();
    V getValue();
}

　　4.2实现泛型接口　　

public class OrderedPair<K, V> implements Pair<K, V> {
    private K key;
    private V value;

    public OrderedPair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public K getKey() {
        return key;
    }

    @Override
    public V getValue() {
        return value;
    }
}

public class Main {
    public static void main(String[] args) {
        Pair<String, Integer> pair = new OrderedPair<>("One", 1);
        System.out.println("Key: " + pair.getKey() + ", Value: " + pair.getValue());
    }
}

　　5.泛型通配符

　　泛型通配符用于表示未知类型，通常用于方法参数中。通配符有三种形式：

<?>：表示任意类型。
<? extends T>：表示T类型或其子类型。
<? super T>：表示T类型或其父类型。

　　5.1使用通配符

import java.util.List;

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

    public static void main(String[] args) {
        List<Integer> intList = List.of(1, 2, 3);
        List<String> strList = List.of("A", "B", "C");

        printList(intList);
        printList(strList);
    }
}

　　5.2使用extends通配符

import java.util.List;

public class Main {
    public static double sumOfList(List<? extends Number> list) {
        double sum = 0.0;
        for (Number number : list) {
            sum += number.doubleValue();
        }
        return sum;
    }

    public static void main(String[] args) {
        List<Integer> intList = List.of(1, 2, 3);
        List<Double> doubleList = List.of(1.1, 2.2, 3.3);

        System.out.println("Sum of intList: " + sumOfList(intList));
        System.out.println("Sum of doubleList: " + sumOfList(doubleList));
    }
}

　　5.3使用super通配符

import java.util.List;

public class Main {
    public static void addNumbers(List<? super Integer> list) {
        for (int i = 1; i <= 5; i++) {
            list.add(i);
        }
    }

    public static void main(String[] args) {
        List<Number> numberList = new ArrayList<>();
        addNumbers(numberList);
        System.out.println("Number List: " + numberList);
    }
}

　　6.今日任务

定义一个泛型类Container，包含一个泛型类型的字段和相应的Getter/Setter方法。
定义一个泛型方法swap，用于交换数组中两个元素的位置。
定义一个泛型接口Converter，包含一个方法convert，将一种类型转换为另一种类型。
使用通配符编写一个方法printList，可以打印任意类型的列表。

　　7.示例代码

public class Container<T> {
    private T item;

    public void setItem(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }
}

public class Main {
    public static <T> void swap(T[] array, int i, int j) {
        T temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    public static void main(String[] args) {
        Container<String> stringContainer = new Container<>();
        stringContainer.setItem("Hello");
        System.out.println("Container Item: " + stringContainer.getItem());

        Integer[] intArray = {1, 2, 3, 4, 5};
        swap(intArray, 1, 3);
        System.out.println("Swapped Array: " + Arrays.toString(intArray));
    }
}

public interface Converter<T, U> {
    U convert(T input);
}

public class Main {
    public static void main(String[] args) {
        Converter<String, Integer> converter = Integer::valueOf;
        Integer result = converter.convert("123");
        System.out.println("Converted Value: " + result);
    }
}

import java.util.List;

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

    public static void main(String[] args) {
        List<Integer> intList = List.of(1, 2, 3);
        List<String> strList = List.of("A", "B", "C");

        printList(intList);
        printList(strList);
    }
}

　　8.总结

　　今天的内容涵盖了泛型的基本概念和使用方法，包括泛型类、泛型方法、泛型接口和泛型通配符。泛型是Java编程中非常重要的特性，能够提高代码的重用性和类型安全性。明天我们将深入学习Java的输入输出（I/O）操作。

　　提示：多动手编写代码，尝试定义和使用泛型类、泛型方法和泛型接口，理解泛型的工作原理和适用场景。

　　祝你学习愉快！