5.2. 泛型

5.2. 泛型
上一页	第 5 章面向对象	下一页

java 中泛型标记符：

		
E - Element (在集合中使用，因为集合中存放的是元素)
T - Type（Java 类）
K - Key（键）
V - Value（值）
N - Number（数值类型）
？ - 表示不确定的 java 类型	
S 和 U 基本上与 T 相同，即表示任意的一个Java类型。

其实我们可以使用 A-Z 之间的任何一个字母，并不会影响程序的正常运行，但是如果换成 T，E，K，V，？，S，U 字母，在可读性上更好一些。

5.2.1.

			
package cn.netkiller.test;

import java.util.List;

public class Test {

    public <T> String method(String name, T t) {
        System.out.println("普通泛型参数 ： " + t + " 数据类型: " + t.getClass().getName());
        String str = name + ": " + t;
        return str;
    }

    public static void main(String[] args) {

        Test test = new Test();

        System.out.println(test.method("001", "bb"));
        System.out.println(test.method("002", true));
        System.out.println(test.method("003", 100));
        System.out.println(test.method("003", 100L));
        System.out.println(test.method("003", 100.00));
        System.out.println(test.method("003", 'c'));
        System.out.println(test.method("003", List.of("Neo")));

    }

}

			
通泛型参数 ： bb 数据类型: java.lang.String
001: bb
普通泛型参数 ： true 数据类型: java.lang.Boolean
002: true
普通泛型参数 ： 100 数据类型: java.lang.Integer
003: 100
普通泛型参数 ： 100 数据类型: java.lang.Long
003: 100
普通泛型参数 ： 100.0 数据类型: java.lang.Double
003: 100.0
普通泛型参数 ： c 数据类型: java.lang.Character
003: c
普通泛型参数 ： [Neo] 数据类型: java.util.ImmutableCollections$List12
003: [Neo]

5.2.2. 数组泛型方法

下面的例子演示了如何使用泛型方法打印不同类型的数组元素：

		
package cn.netkiller.test;

public class GenericsTest {
    // 泛型方法 printArray
    public static <E> void printArray(E[] inputArray) {
        // 输出数组元素
        for (E element : inputArray) {
            System.out.printf("%s ", element);
        }
        System.out.println();
    }

    public static void main(String[] args) {
        System.out.println(Thread.currentThread());

        // 创建不同类型数组： Integer, Double 和 Character, String
        Integer[] intArray = {1, 2, 3, 4, 5};
        Double[] doubleArray = {1.1, 2.2, 3.3, 4.4};
        Character[] charArray = {'H', 'E', 'L', 'L', 'O'};
        String[] stringArray = {"Neo", "Chen"};

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

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

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

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

}

5.2.3. 静态方法

			
package cn.netkiller.test;

import java.util.List;

public class Test {

    public static <T, E> String staticMethod(T t, E e) {
        String str = "静态泛型方法 参数：" + t + ", " + e + " 数据类型：" + e.getClass().getName();
        return str;
    }

    public static void main(String[] args) {

        System.out.println(Test.staticMethod("001", "bb"));
        System.out.println(Test.staticMethod("002", true));
        System.out.println(Test.staticMethod("003", 100));
        System.out.println(Test.staticMethod("003", 100L));
        System.out.println(Test.staticMethod("003", 100.00));
        System.out.println(Test.staticMethod("003", 'c'));
        System.out.println(Test.staticMethod("003", List.of("Neo")));

    }

}

5.2.4. 可变参数的泛型方法

			
package cn.netkiller.test;

import java.util.List;

public class Test {
    public <A> void argsMethod(A... args) {
        for (A arg : args) {
            System.out.print(arg);
            System.out.print(" - ");
        }

        System.out.println();
    }

    public static void main(String[] args) {

        Test test = new Test();
        System.out.println("静态泛型方法");
        test.argsMethod("aaa", "bbb", "ccc");
        test.argsMethod(1, 2, 3);

        test.argsMethod(true, false, true);
        test.argsMethod(73.5, 100.00, 88.8);
        test.argsMethod('a', 'b', 'c');
        test.argsMethod(1L, 3L, 5L);

    }
}

5.2.5. 返回泛型值

			
package cn.netkiller.test;

import java.util.Arrays;
import java.util.List;
import java.util.Map;

public class Test {
    public <T> T method(T t) {
        System.out.println("类型：" + t.getClass().getName() + " 返回值：" + t);
        return t;
    }

    public static void main(String[] args) {

        Test test = new Test();
        System.out.println("返回泛型方法");
        String s = test.method("aaa");
        System.out.println(s);
        int n = test.method(13579);
        System.out.println(n);
        boolean b = test.method(false);
        System.out.println(b);
        List<String> l = test.method(Arrays.asList("neo", "chen", "netkiller"));
        System.out.println(l);
        Object m = test.method(Map.of("name", "neo", "nickname", "netkiller"));
        System.out.println(m);

    }

}

			
返回泛型方法
类型：java.lang.String 返回值：aaa
aaa
类型：java.lang.Integer 返回值：13579
13579
类型：java.lang.Boolean 返回值：false
false
类型：java.util.Arrays$ArrayList 返回值：[neo, chen, netkiller]
[neo, chen, netkiller]
类型：java.util.ImmutableCollections$MapN 返回值：{nickname=netkiller, name=neo}
{nickname=netkiller, name=neo}

5.2.6. 泛型类

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

上一页	上一级	下一页
第 5 章面向对象	起始页	5.3. record