为什么在 Java 中使用泛型？它与重载有何不同？

Question

我想在 Java 中编写一个方法 add()，它可以同时添加整数、字符串等。Is Generics 会帮助我。

我无法理解泛型的最终目的。我很困惑。

泛型与重载？

public Integer add(Integer i, Integer j){return i+j;}
public String add(String i, String j){return i+j;}
public <T> T add(T i, T j){return i+j;} //this gives me error.

请让我摆脱它。

谢谢。

Answer 1

泛型可以帮助，这里的问题是+ 操作只为java 原语和String 定义，而不是一般类型。在 Java 中，我们不能重载运算符（例如，我们可以在 C++ 中重载）。

没有泛型的实用解决方案是：

public Integer add(Integer a, Integer b) { return a + b; }    // sum of a and b
public String add(String a, String b) { return a + b; }      // concatenate operation!
public MyType add(MyType a, MyType b) { return a.add(b); }   // requires add operation

Answer 2

其他人指出了为什么这不起作用。让我补充一下，我认为您误解了 Java 泛型的用途。也许您熟悉 C++ 模板，或者 C 宏扩展，它们都类似于泛型，但又是完全不同的东西。

泛型实际上是关于类型安全和避免混乱的强制转换。您告诉编译器某个集合包含字符串，然后它知道您放入或取出的所有内容都必须是字符串。您可以在编译时检查您放入的内容，并为您取出的内容节省一些演员表。

它不会导致编译器根据类型生成不同的代码。泛型不是避免编写同一函数的“int”版本和“float”版本的捷径，就像宏或 C++ 模板会为您做的那样。您可以通过让两个类实现相同功能但一个使用 int 而另一个使用浮点数来获得这种所需的不同行为。但是您可以使用没有泛型的面向对象技术来做到这一点。如果您无法使用“非泛型”面向对象技术获得所需的独特行为，那么您也无法使用泛型来实现。

Answer 3

我想在 Java 中编写一个 add() 方法，它可以同时添加整数、字符串等。Is Generics 会帮助我。

否

泛型主要在编译时用于类型安全。

您只能指定一种类型添加到集合中

List<String> lst;

只接受String，没有String的超类没有子类[例如如果存在]

• Generics

Answer 4

public Integer add(Integer i, Integer j){return i+j;}
public String add(String i, String j){return i+j;}
public <T> T add(T i, T j){return i+j;} //this gives me error.

虽然这些方法看起来几乎相同，但在这种情况下，泛型无法提供帮助。考虑一下：

public <T> T add(T i, T j){return i+j;}
...
add(new Object(), new Object());

把普通的Objects 加在一起是什么意思？不，Object 不支持+，并且许多其他可以替代T 的类型也不支持。

在创建泛型方法<T> T add(T i, T j) 时，泛型方法仅限于泛型类型参数T 上允许的方法和操作，这实际上意味着您可以使用Object 执行的操作。您正在尝试使用 + 的方法/操作，这是您可以使用 Object 执行的操作。

我们可以尝试通过找到一个公共基类String 和Integer 来解决这个问题，它支持我们在泛型方法体中必须使用的所有方法和操作。 如果有这样一个公共基类XXXXX 支持+ 运算符，我们可以这样做：

public <T extends XXXXX> T add(T i, T j) { return i+j; }

但是，没有通用基类XXXXX支持我们在泛型方法（+）中想做的一切，所以泛型不能用来解决这个问题。

Answer 5

泛型很好，因为如果处理得当，它可以让您概括您编写的一些代码。在编写软件方面，您希望尽量减少不必要的代码并尽可能多地重用代码。

通过使用重载方法，您必须写出每个重载，而使用泛型您只需执行一次。泛型在您操作集合的情况下工作得很好，因为您对一组集合执行某些常见操作。在某些情况下，如果您希望使用更定制的方法来处理某些情况，那么您可能必须重载方法，但如果您可以在多个地方使用泛型，我会以编写泛型为目标。

Answer 6

这正是泛型的意义所在。 您不想实现一种可以接受所有内容的方法。坦率地说，你总是可以实现方法

add(Object obj)

并将整数、字符串、布尔值传递给它...但在大多数情况下，您不想这样做。该方法必须处理参数，因此它应该知道参数的类型。这就是如果你想让接收字符串和整数的方法 add 实现 2 个方法的原因：

add(String s);
add(int i);

现在您不能将布尔值发送到 add() 方法：这种方法根本不存在。

你也可以实现泛型方法

<T> void add(T arg);

并将其命名为：this.<String>add("hello"); 或 this.<Integer>add(123);

在这种情况下，this.<String>add(123); 会导致编译错误。

Answer 7

Java 中的泛型只向字节码添加强制转换。

代码将是相同的，除了强制转换。

所以这两种结构：

List list1 = new ArrayList();
List<String list2 = new ArrayList<String>();
....
String string1 = (String) list1.get(0);
String string2 = list2.get(0);

正在做同样的事情。

Answer 8

使用通用接口的方法怎么样：

interface Adder<T> {
    T add(T first, T second);
}

还有一个经理类：

public class AdderManager{

    public <T> AdderManager putAdder(final Class<T> clazz,
        final Adder<? extends T> adder){
        adders.put(clazz, adder);
        return this;
    }

    @SuppressWarnings("unchecked")
    public <T> Adder<T> getAdder(final Class<T> clazz){
        return (Adder<T>) adders.get(clazz);
    }

    private final Map<Class<?>, Adder<?>> adders =
        new HashMap<Class<?>, Adder<?>>();

}

现在您可以为不同的类注册和使用自定义加法器：

final AdderManager manager = new AdderManager();
manager
.putAdder(String.class, new Adder<String>(){

    @Override
    public String add(final String first, final String second){
        return first.concat(second);
    }
})
.putAdder(Integer.class, new Adder<Integer>(){

    @Override
    public Integer add(final Integer first, final Integer second){
        return first + second;
    }
})
.putAdder(List.class, new Adder<List<?>>(){

    @Override
    public List<?> add(final List<?> first, final List<?> second){
        final List<Object> newList = new ArrayList<Object>();

        return newList;
        }
});

现在你可以像这样使用这些加法器了：

String addedString = manager.getAdder(String.class).add("abc", "def");

@SuppressWarnings("unchecked") // this is necessary because of
                               // the generic <Integer> type
List<Integer> addedList = manager
                            .getAdder(List.class)
                            .add(
                                Arrays.asList(1,2,3),
                                Arrays.asList(4,5,6)
                             );